alchemy 2.0.0-beta.27 → 2.0.0-beta.29

package/bin/alchemy.js

@@ -1,4 +1,4 @@
-import { runMain } from "alchemy/Util";
+import { runMain } from "alchemy/Util/PlatformServices";
 import { main } from "alchemy/Cli";
 main.pipe(runMain);
 //# sourceMappingURL=alchemy.js.map

package/bin/alchemy.js.map

@@ -1 +1 @@
-{"version":3,"file":"alchemy.js","sourceRoot":"","sources":["alchemy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"alchemy.js","sourceRoot":"","sources":["alchemy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC"}

package/bin/alchemy.ts

@@ -1,4 +1,4 @@
-import { runMain } from "alchemy/Util";
+import { runMain } from "alchemy/Util/PlatformServices";
 
 import { main } from "alchemy/Cli";
 

package/bin/exec.js

@@ -1,30 +1,30 @@
-import * as EffectContext from "effect/Context";
+import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as S from "effect/Schema";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as EffectContext from "effect/Context";
+import * as FileSystem from "effect/FileSystem";
 import * as Path$1 from "effect/Path";
 import { Path } from "effect/Path";
+import * as Console from "effect/Console";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
 import * as Data from "effect/Data";
 import { pipe } from "effect/Function";
 import * as Redacted from "effect/Redacted";
 import { SingleShotGen } from "effect/Utils";
-import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Logger from "effect/Logger";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as Deferred from "effect/Deferred";
-import * as S from "effect/Schema";
 import path from "pathe";
 import * as Config from "effect/Config";
 import os from "node:os";
-import * as Console from "effect/Console";
-import * as Command from "effect/unstable/cli/Command";
-import * as Flag from "effect/unstable/cli/Flag";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
 import * as Metric from "effect/Metric";
-import "effect/Cause";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -44,10 +44,6 @@ const AlchemyContextLive = Layer.effect(AlchemyContext, Effect.gen(function* ()
 	};
 }));
 
-//#endregion
-//#region lib/Util/data.js
-const isPrimitive = (value) => value === void 0 || value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "symbol" || typeof value === "bigint";
-
 //#endregion
 //#region lib/Util/PlatformServices.js
 const isBun = typeof Bun !== "undefined";
@@ -65,6 +61,74 @@ const runMain = (effect, options) => {
 	else import("@effect/platform-node/NodeRuntime").then((NodeRuntime) => NodeRuntime.runMain(effect, options));
 };
 
+//#endregion
+//#region lib/AdoptPolicy.js
+var AdoptPolicy = class extends EffectContext.Service()("AdoptPolicy") {};
+
+//#endregion
+//#region lib/Artifacts.js
+/**
+* Per-resource in-memory artifacts shared across a single `Plan.make -> apply`
+* execution.
+*
+* The engine scopes this service by resource `FQN` before invoking lifecycle
+* handlers, so providers should treat it as a resource-local bag for expensive,
+* deterministic intermediate results that can be reused across phases.
+*
+* Expected usage:
+*
+* - `diff` computes an expensive artifact once and stores it
+* - `create` / `update` reads the same artifact and skips recomputing it
+* - artifacts are ephemeral and must never be required for correctness on a
+*   later deploy because the bag is reset between runs
+*
+* Example:
+*
+* ```ts
+* const artifacts = yield* Artifacts;
+* const cached = yield* artifacts.get<PreparedBundle>("bundle");
+* if (cached) return cached;
+*
+* const bundle = yield* prepareBundle();
+* yield* artifacts.set("bundle", bundle);
+* return bundle;
+* ```
+*/
+var Artifacts = class extends EffectContext.Service()("Artifacts") {};
+var ArtifactStore = class extends EffectContext.Service()("Artifacts/Store") {};
+/**
+* Create a fresh root store for one deploy/test run.
+*/
+const createArtifactStore = () => /* @__PURE__ */ new Map();
+const getOrCreateBag = (store, fqn) => {
+	const existing = store.get(fqn);
+	if (existing) return existing;
+	const bag = /* @__PURE__ */ new Map();
+	store.set(fqn, bag);
+	return bag;
+};
+const makeScopedArtifacts = (store, fqn) => {
+	const bag = getOrCreateBag(store, fqn);
+	return {
+		get: (key) => Effect.sync(() => bag.get(key)),
+		set: (key, value) => Effect.sync(() => {
+			bag.set(key, value);
+		}),
+		delete: (key) => Effect.sync(() => {
+			bag.delete(key);
+		})
+	};
+};
+/**
+* Ensure an artifact root exists, reusing the ambient store when one is already
+* present. This lets nested helpers participate in the same run-scoped cache.
+*/
+const ensureArtifactStore = (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrUndefined), Effect.flatMap((existing) => effect.pipe(Effect.provideService(ArtifactStore, existing ?? createArtifactStore()))));
+
+//#endregion
+//#region lib/Cli/Cli.js
+var Cli = class extends EffectContext.Service()("CLI") {};
+
 //#endregion
 //#region lib/Util/service.js
 const GenericService = () => (Kind) => {
@@ -73,10 +137,6 @@ const GenericService = () => (Kind) => {
 	return Object.assign(Object.setPrototypeOf(make$2, service), service);
 };
 
-//#endregion
-//#region lib/Util/types.js
-const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(effect);
-
 //#endregion
 //#region lib/ExecutionContext.js
 const ExecutionContext = GenericService()("Alchemy::ExecutionContext");
@@ -179,66 +239,6 @@ const tryFindProviderByType = Effect.fnUntraced(function* (resourceType) {
 	return Option.none();
 });
 
-//#endregion
-//#region lib/Artifacts.js
-/**
-* Per-resource in-memory artifacts shared across a single `Plan.make -> apply`
-* execution.
-*
-* The engine scopes this service by resource `FQN` before invoking lifecycle
-* handlers, so providers should treat it as a resource-local bag for expensive,
-* deterministic intermediate results that can be reused across phases.
-*
-* Expected usage:
-*
-* - `diff` computes an expensive artifact once and stores it
-* - `create` / `update` reads the same artifact and skips recomputing it
-* - artifacts are ephemeral and must never be required for correctness on a
-*   later deploy because the bag is reset between runs
-*
-* Example:
-*
-* ```ts
-* const artifacts = yield* Artifacts;
-* const cached = yield* artifacts.get<PreparedBundle>("bundle");
-* if (cached) return cached;
-*
-* const bundle = yield* prepareBundle();
-* yield* artifacts.set("bundle", bundle);
-* return bundle;
-* ```
-*/
-var Artifacts = class extends EffectContext.Service()("Artifacts") {};
-var ArtifactStore = class extends EffectContext.Service()("Artifacts/Store") {};
-/**
-* Create a fresh root store for one deploy/test run.
-*/
-const createArtifactStore = () => /* @__PURE__ */ new Map();
-const getOrCreateBag = (store, fqn) => {
-	const existing = store.get(fqn);
-	if (existing) return existing;
-	const bag = /* @__PURE__ */ new Map();
-	store.set(fqn, bag);
-	return bag;
-};
-const makeScopedArtifacts = (store, fqn) => {
-	const bag = getOrCreateBag(store, fqn);
-	return {
-		get: (key) => Effect.sync(() => bag.get(key)),
-		set: (key, value) => Effect.sync(() => {
-			bag.set(key, value);
-		}),
-		delete: (key) => Effect.sync(() => {
-			bag.delete(key);
-		})
-	};
-};
-/**
-* Ensure an artifact root exists, reusing the ambient store when one is already
-* present. This lets nested helpers participate in the same run-scoped cache.
-*/
-const ensureArtifactStore = (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrUndefined), Effect.flatMap((existing) => effect.pipe(Effect.provideService(ArtifactStore, existing ?? createArtifactStore()))));
-
 //#endregion
 //#region lib/Auth/Profile.js
 const rootDir = path.join(os.homedir(), ".alchemy");
@@ -281,10 +281,6 @@ const withProfileOverride = (base, profile$1) => {
 //#region lib/Auth/AuthProvider.js
 var AuthProviders = class extends EffectContext.Service()("AuthProviders") {};
 
-//#endregion
-//#region lib/Cli/Cli.js
-var Cli = class extends EffectContext.Service()("CLI") {};
-
 //#endregion
 //#region lib/Stage.js
 var Stage = class extends EffectContext.Service()("Stage") {};
@@ -368,6 +364,10 @@ const isResource = (value) => {
 //#region lib/State/State.js
 var State = class extends EffectContext.Service()("alchemy/State") {};
 
+//#endregion
+//#region lib/Util/data.js
+const isPrimitive = (value) => value === void 0 || value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "symbol" || typeof value === "bigint";
+
 //#endregion
 //#region lib/Output.js
 const inspect = Symbol.for("nodejs.util.inspect.custom");
@@ -603,10 +603,6 @@ const toObject = (acc, v) => ({
 	...v
 });
 
-//#endregion
-//#region lib/AdoptPolicy.js
-var AdoptPolicy = class extends EffectContext.Service()("AdoptPolicy") {};
-
 //#endregion
 //#region lib/Diff.js
 const havePropsChanged = (oldProps, newProps) => hasOutputs(newProps) || JSON.stringify(canonicalize(oldProps ?? {})) !== JSON.stringify(canonicalize(newProps ?? {}));
@@ -645,6 +641,83 @@ const generateInstanceId = () => Effect.sync(() => {
 	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 });
 
+//#endregion
+//#region lib/Util/types.js
+const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(effect);
+
+//#endregion
+//#region lib/Util/scc.js
+/**
+* Compute the set of graph nodes that participate in a dependency cycle.
+*
+* A node is considered "in a cycle" iff it sits in a strongly-connected
+* component (SCC) of size > 1, or has a self-edge (size-1 SCC that loops
+* back to itself).
+*
+* Implementation is iterative Tarjan's algorithm to avoid blowing the JS
+* call stack on very wide graphs.
+*/
+const findCycleMembers = (edges) => {
+	const cycleMembers = /* @__PURE__ */ new Set();
+	let index = 0;
+	const indexOf = /* @__PURE__ */ new Map();
+	const lowlink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const callStack = [];
+	const startNode = (node) => {
+		indexOf.set(node, index);
+		lowlink.set(node, index);
+		index += 1;
+		stack.push(node);
+		onStack.add(node);
+		callStack.push({
+			node,
+			childIdx: 0
+		});
+	};
+	for (const root of Object.keys(edges)) {
+		if (indexOf.has(root)) continue;
+		startNode(root);
+		while (callStack.length > 0) {
+			const frame = callStack[callStack.length - 1];
+			const children = edges[frame.node] ?? [];
+			if (frame.childIdx < children.length) {
+				const child = children[frame.childIdx];
+				frame.childIdx += 1;
+				if (!indexOf.has(child)) {
+					startNode(child);
+					continue;
+				}
+				if (onStack.has(child)) lowlink.set(frame.node, Math.min(lowlink.get(frame.node), indexOf.get(child)));
+				continue;
+			}
+			if (lowlink.get(frame.node) === indexOf.get(frame.node)) {
+				const scc = [];
+				for (;;) {
+					const w = stack.pop();
+					onStack.delete(w);
+					scc.push(w);
+					if (w === frame.node) break;
+				}
+				if (scc.length > 1) for (const fqn of scc) cycleMembers.add(fqn);
+				else {
+					const only = scc[0];
+					if ((edges[only] ?? []).includes(only)) cycleMembers.add(only);
+				}
+			}
+			callStack.pop();
+			const parent = callStack[callStack.length - 1];
+			if (parent) {
+				const cur = lowlink.get(parent.node);
+				const childLow = lowlink.get(frame.node);
+				if (childLow < cur) lowlink.set(parent.node, childLow);
+			}
+		}
+	}
+	return cycleMembers;
+};
+
 //#endregion
 //#region lib/Plan.js
 const make = (stack, options = {}) => Effect.gen(function* () {
@@ -875,6 +948,7 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			state: oldState
 		});
 	})), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
+	const cycleMembers = findCycleMembers(allUpstreamDependencies);
 	{
 		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
 		if (createReplaceNodes.size > 0) {
@@ -965,7 +1039,8 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 	return {
 		resources: resourceGraph,
 		deletions,
-		output: stack.output
+		output: stack.output,
+		cycleMembers
 	};
 }).pipe(ensureArtifactStore, Effect.withSpan("plan.make", { attributes: {
 	"alchemy.stack": stack.name,
@@ -1093,9 +1168,11 @@ const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses
 	const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
 	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	const waitForDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in ready).map((fqn) => Deferred.await(ready[fqn])), { concurrency: "unbounded" });
-	yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps)), { concurrency: "unbounded" });
+	const failures = [];
+	yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, plan.cycleMembers.has(fqn))), { concurrency: "unbounded" });
+	if (failures.length > 0) yield* Effect.failCause(failures.map((f) => f.cause).reduce(Cause.combine));
 });
-const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps) => Effect.gen(function* () {
+const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, inCycle) => Effect.gen(function* () {
 	const logicalId = node.resource.LogicalId;
 	const namespace = node.resource.Namespace;
 	const commit = (value) => state.set({
@@ -1272,7 +1349,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 			return;
 		}
 		if (node.action === "update") {
-			yield* storeAndSignal({
+			if (inCycle) yield* storeAndSignal({
 				output: node.state.attr,
 				props: node.state.props,
 				bindings: node.state.bindings ?? [],
@@ -1335,6 +1412,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				instanceId
 			};
+			yield* signalReady;
 			yield* markTerminal("updated");
 			return;
 		}
@@ -1445,7 +1523,21 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 		}
 		return yield* Effect.die(`Unknown action: ${node.action}`);
 	});
-}).pipe(Effect.withSpan("apply.resource", { attributes: {
+}).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+	failures.push({
+		fqn,
+		logicalId: node.resource.LogicalId,
+		type: node.resource.Type,
+		cause
+	});
+	yield* Deferred.failCause(ready[fqn], cause);
+	yield* session.emit({
+		kind: "status-change",
+		id: node.resource.LogicalId,
+		type: node.resource.Type,
+		status: "fail"
+	});
+})), Effect.withSpan("apply.resource", { attributes: {
 	"alchemy.resource.fqn": fqn,
 	"alchemy.resource.type": node.resource.Type,
 	"alchemy.resource.logical_id": node.resource.LogicalId,