alchemy 2.0.0-beta.17 → 2.0.0-beta.19

package/bin/alchemy.js

@@ -10,14 +10,21 @@ import * as Path$1 from "effect/Path";
 import { Path } from "effect/Path";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
-import * as NodeOs from "node:os";
+import * as os$1 from "node:os";
 import os from "node:os";
-import { execFileSync } from "node:child_process";
-import * as fs$1 from "node:fs";
+import { exec, execFileSync } from "node:child_process";
+import * as fs$2 from "node:fs";
 import fs from "node:fs";
 import tty from "node:tty";
 import { EventEmitter } from "node:events";
 import { Buffer as Buffer$1 } from "node:buffer";
+import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
+import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
+import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
+import * as crypto$2 from "node:crypto";
+import crypto$1 from "node:crypto";
+import * as fs$1 from "node:fs/promises";
+import * as nodePath from "node:path";
 import * as Cause from "effect/Cause";
 import * as Config from "effect/Config";
 import * as Console from "effect/Console";
@@ -26,6 +33,9 @@ import * as Schema from "effect/Schema";
 import * as Argument$1 from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import * as Flag$1 from "effect/unstable/cli/Flag";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Metric from "effect/Metric";
 import * as p from "@clack/prompts";
 import * as Data from "effect/Data";
 import { ChildProcess } from "effect/unstable/process";
@@ -43,11 +53,8 @@ import { SingleShotGen } from "effect/Utils";
 import { pipeArguments } from "effect/Pipeable";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 import * as Match from "effect/Match";
-import * as NodeCrypto from "node:crypto";
-import crypto$1 from "node:crypto";
 import * as cfAccounts from "@distilled.cloud/cloudflare/accounts";
 import * as CfCredentialsModule from "@distilled.cloud/cloudflare/Credentials";
-import * as Duration from "effect/Duration";
 import http from "node:http";
 import * as Stream$1 from "effect/Stream";
 
@@ -82,15 +89,15 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "2.0.0-beta.17";
+var version = "2.0.0-beta.19";
 
 //#endregion
 //#region src/AlchemyContext.ts
 var AlchemyContext = class extends EffectContext.Service()("alchemy/Context") {};
 const AlchemyContextLive = Layer.effect(AlchemyContext, Effect.gen(function* () {
-	const fs$2 = yield* FileSystem.FileSystem;
+	const fs$3 = yield* FileSystem.FileSystem;
 	const dir = (yield* Path$1.Path).join(process.cwd(), ".alchemy");
-	yield* fs$2.makeDirectory(dir, { recursive: true });
+	yield* fs$3.makeDirectory(dir, { recursive: true });
 	return {
 		dotAlchemy: dir,
 		updateStateStore: false
@@ -4241,7 +4248,7 @@ const stringVisibleTrimSpacesRight = (string) => {
 	if (last === words.length) return string;
 	return words.slice(0, last).join(" ") + words.slice(last).join("");
 };
-const exec$1 = (string, columns, options$2 = {}) => {
+const exec$2 = (string, columns, options$2 = {}) => {
 	if (options$2.trim !== false && string.trim() === "") return "";
 	let returnValue = "";
 	let escapeCode;
@@ -4307,14 +4314,14 @@ const exec$1 = (string, columns, options$2 = {}) => {
 	return returnValue;
 };
 function wrapAnsi(string, columns, options$2) {
-	return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec$1(line, columns, options$2)).join("\n");
+	return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec$2(line, columns, options$2)).join("\n");
 }
 
 //#endregion
 //#region ../../node_modules/.bun/terminal-size@4.0.1/node_modules/terminal-size/index.js
 const defaultColumns = 80;
 const defaultRows = 24;
-const exec = (command, arguments_, { shell, env: env$2 } = {}) => execFileSync(command, arguments_, {
+const exec$1 = (command, arguments_, { shell, env: env$2 } = {}) => execFileSync(command, arguments_, {
 	encoding: "utf8",
 	stdio: [
 		"ignore",
@@ -4379,11 +4386,11 @@ const devTty = () => {
 };
 const tput = () => {
 	try {
-		const columns = exec("tput", ["cols"], { env: {
+		const columns = exec$1("tput", ["cols"], { env: {
 			TERM: "dumb",
 			...process$1.env
 		} });
-		const rows = exec("tput", ["lines"], { env: {
+		const rows = exec$1("tput", ["lines"], { env: {
 			TERM: "dumb",
 			...process$1.env
 		} });
@@ -4393,7 +4400,7 @@ const tput = () => {
 const resize = () => {
 	try {
 		if (!isForegroundProcess()) return;
-		const size = exec("resize", ["-u"]).match(/\d+/g);
+		const size = exec$1("resize", ["-u"]).match(/\d+/g);
 		if (size.length === 2) return createIfNotDefault(size[0], size[1]);
 	} catch {}
 };
@@ -40981,8 +40988,8 @@ function ErrorOverview({ error }) {
 	const filePath = cleanupPath(origin?.file);
 	let excerpt;
 	let lineWidth = 0;
-	if (filePath && origin?.line && fs$1.existsSync(filePath)) {
-		excerpt = dist_default$1(fs$1.readFileSync(filePath, "utf8"), origin.line);
+	if (filePath && origin?.line && fs$2.existsSync(filePath)) {
+		excerpt = dist_default$1(fs$2.readFileSync(filePath, "utf8"), origin.line);
 		if (excerpt) for (const { line } of excerpt) lineWidth = Math.max(lineWidth, String(line).length);
 	}
 	return import_react.createElement(Box_default, {
@@ -43148,6 +43155,215 @@ const startApplySession = Effect.fn(function* (plan) {
 	};
 });
 
+//#endregion
+//#region src/Telemetry/Attributes.ts
+const ALCHEMY_DIR = nodePath.join(os$1.homedir(), ".alchemy");
+const ID_PATH = nodePath.join(ALCHEMY_DIR, "id");
+const DISABLED_PATH = nodePath.join(ALCHEMY_DIR, "telemetry-disabled");
+const tryRead = (path) => Effect.tryPromise({
+	try: () => fs$1.readFile(path, "utf-8").then((s) => s.trim()),
+	catch: () => null
+}).pipe(Effect.catch(() => Effect.succeed(null)));
+const sha256Hex = (input) => crypto$2.createHash("sha256").update(input).digest("hex");
+const hashStringOrEmpty = (input) => input == null || input === "" ? "" : sha256Hex(input);
+const execCapture = (cmd) => Effect.callback((resume$1) => {
+	exec(cmd, { timeout: 1500 }, (err, stdout) => {
+		if (err) {
+			resume$1(Effect.succeed(null));
+			return;
+		}
+		resume$1(Effect.succeed(stdout.toString().trim()));
+	});
+});
+const getOrCreateUserId = Effect.gen(function* () {
+	const existing = yield* tryRead(ID_PATH);
+	if (existing) return existing;
+	const id = crypto$2.randomUUID();
+	yield* Effect.tryPromise({
+		try: async () => {
+			await fs$1.mkdir(ALCHEMY_DIR, { recursive: true });
+			await fs$1.writeFile(ID_PATH, id);
+		},
+		catch: () => null
+	}).pipe(Effect.catch(() => Effect.void));
+	return id;
+});
+const getRootCommitHash = execCapture(process.platform === "win32" ? `git rev-list --max-parents=0 HEAD | ForEach-Object { if (-not (git cat-file -p $_ | Select-String "^parent ")) { $_ } }` : `git rev-list --max-parents=0 HEAD | xargs -r -I{} sh -c 'git cat-file -p {} | grep -q "^parent " || echo {}'`);
+const getGitOriginUrl = execCapture("git config --get remote.origin.url");
+const getBranchName = execCapture("git rev-parse --abbrev-ref HEAD");
+const getRuntime = () => {
+	const g = globalThis;
+	if (typeof g.Bun !== "undefined") return {
+		name: "bun",
+		version: g.Bun.version
+	};
+	if (typeof g.Deno !== "undefined") return {
+		name: "deno",
+		version: g.Deno.version?.deno ?? ""
+	};
+	if (globalThis.process?.versions?.node) return {
+		name: "node",
+		version: process.versions.node
+	};
+	return {
+		name: "",
+		version: ""
+	};
+};
+const CI_PROVIDERS = [
+	{
+		env: "GITHUB_ACTIONS",
+		provider: "GitHub Actions",
+		isCI: true
+	},
+	{
+		env: "GITLAB_CI",
+		provider: "GitLab CI",
+		isCI: true
+	},
+	{
+		env: "CIRCLECI",
+		provider: "CircleCI",
+		isCI: true
+	},
+	{
+		env: "JENKINS_URL",
+		provider: "Jenkins",
+		isCI: true
+	},
+	{
+		env: "TRAVIS",
+		provider: "Travis CI",
+		isCI: true
+	},
+	{
+		env: "BUILDKITE",
+		provider: "Buildkite",
+		isCI: true
+	},
+	{
+		env: "NOW_BUILDER",
+		provider: "Vercel",
+		isCI: true
+	},
+	{
+		env: "VERCEL",
+		provider: "Vercel",
+		isCI: false
+	}
+];
+const getCIEnvironment = () => {
+	for (const p$1 of CI_PROVIDERS) if (process.env[p$1.env]) return {
+		provider: p$1.provider,
+		isCI: p$1.isCI
+	};
+	return {
+		provider: "",
+		isCI: !!process.env.CI
+	};
+};
+const TELEMETRY_DISABLED_ENV = () => !!process.env.ALCHEMY_TELEMETRY_DISABLED || !!process.env.DO_NOT_TRACK || !!process.env.NO_TRACK;
+/**
+* `true` if telemetry is disabled via environment variable
+* (`DO_NOT_TRACK`, `NO_TRACK`, `ALCHEMY_TELEMETRY_DISABLED`) or via a
+* persisted opt-out file at `~/.alchemy/telemetry-disabled`.
+*/
+const isTelemetryDisabled = Effect.gen(function* () {
+	if (TELEMETRY_DISABLED_ENV()) return true;
+	return (yield* tryRead(DISABLED_PATH)) === "true";
+});
+/**
+* Persists an opt-out so future invocations skip telemetry without needing
+* an env var.
+*/
+const setTelemetryDisabled = Effect.tryPromise({
+	try: async () => {
+		await fs$1.mkdir(ALCHEMY_DIR, { recursive: true });
+		await fs$1.writeFile(DISABLED_PATH, "true");
+	},
+	catch: () => null
+}).pipe(Effect.catch(() => Effect.void));
+const setTelemetryEnabled = Effect.tryPromise({
+	try: () => fs$1.rm(DISABLED_PATH, { force: true }),
+	catch: () => null
+}).pipe(Effect.catch(() => Effect.void));
+const collectAttributesUncached = Effect.gen(function* () {
+	const [userId, rootCommit, originUrl, branch] = yield* Effect.all([
+		getOrCreateUserId,
+		getRootCommitHash,
+		getGitOriginUrl,
+		getBranchName
+	], { concurrency: "unbounded" });
+	const runtime = getRuntime();
+	const ci = getCIEnvironment();
+	return {
+		"alchemy.user.id": userId,
+		"alchemy.session.id": process.env.ALCHEMY_TELEMETRY_SESSION_ID ?? crypto$2.randomUUID(),
+		"alchemy.version": version,
+		"alchemy.git.root_commit": rootCommit ?? "",
+		"alchemy.git.origin_hash": hashStringOrEmpty(originUrl),
+		"alchemy.git.branch_hash": hashStringOrEmpty(branch),
+		"alchemy.runtime.name": runtime.name,
+		"alchemy.runtime.version": runtime.version,
+		"alchemy.ci.provider": ci.provider,
+		"alchemy.ci": ci.isCI,
+		"host.arch": os$1.arch(),
+		"os.type": os$1.platform(),
+		"os.version": os$1.release(),
+		"host.cpus": os$1.cpus().length,
+		"host.memory_mb": Math.round(os$1.totalmem() / 1024 / 1024)
+	};
+});
+let cachedAttrs;
+/**
+* Resolves the {@link TelemetryAttributes} for the current process. Cached
+* so file I/O and `git` invocations only run once per CLI invocation; every
+* subsequent caller gets the same record (and therefore the same session
+* id).
+*/
+const collectAttributes = Effect.suspend(() => cachedAttrs !== void 0 ? Effect.succeed(cachedAttrs) : collectAttributesUncached.pipe(Effect.tap((a) => Effect.sync(() => {
+	cachedAttrs = a;
+}))));
+
+//#endregion
+//#region src/Telemetry/Layer.ts
+const TRACES_URL = "https://otel.alchemy.run/v1/traces";
+const METRICS_URL = "https://otel.alchemy.run/v1/metrics";
+const SERVICE_NAME = "alchemy-cli";
+const buildOtlpLayer = (attrs) => {
+	const resource = {
+		serviceName: SERVICE_NAME,
+		serviceVersion: version,
+		attributes: attrs
+	};
+	const tracer = OtlpTracer.layer({
+		url: TRACES_URL,
+		resource,
+		exportInterval: "1 second"
+	});
+	const metrics = OtlpMetrics.layer({
+		url: METRICS_URL,
+		resource,
+		exportInterval: "1 second"
+	});
+	return Layer.mergeAll(tracer, metrics).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer));
+};
+/**
+* The CLI's telemetry layer. Builds an OTLP HTTP exporter that ships spans
+* to {@link TRACES_URL} and metrics to {@link METRICS_URL}, attaching
+* {@link collectAttributes} as resource-level attributes so every signal
+* carries user/project/runtime context.
+*
+* If the user has opted out (via `DO_NOT_TRACK`, `NO_TRACK`,
+* `ALCHEMY_TELEMETRY_DISABLED`, or `~/.alchemy/telemetry-disabled`), this
+* resolves to {@link Layer.empty}. Effect's default `Tracer` is a no-op,
+* so all `withSpan`/`Effect.fn` instrumentation in core stays free.
+*/
+const TelemetryLive = Layer.unwrap(Effect.gen(function* () {
+	if (yield* isTelemetryDisabled) return Layer.empty;
+	return buildOtlpLayer(yield* collectAttributes);
+}));
+
 //#endregion
 //#region src/Util/PlatformServices.ts
 const isBun = typeof Bun !== "undefined";
@@ -43190,6 +43406,62 @@ const AuthProvider = () => (name, impl) => Effect.gen(function* () {
 */
 const AuthProviderLayer = () => (name, impl) => Layer.effectDiscard(AuthProvider()(name, impl));
 
+//#endregion
+//#region src/Telemetry/Metrics.ts
+/**
+* Counter for resource lifecycle operations. Tagged per call with
+* `resource_type`, `op` (`precreate`/`create`/`update`/`delete`/`read`),
+* and `status` (`success`/`error`).
+*/
+const resourceCounter = Metric.counter("alchemy.resource.operations", {
+	description: "Number of resource lifecycle operations dispatched by alchemy apply.",
+	incremental: true
+});
+/**
+* Histogram of how long each lifecycle operation takes.
+*/
+const resourceDuration = Metric.timer("alchemy.resource.duration", { description: "Wall-clock duration of resource lifecycle operations dispatched by alchemy apply." });
+/**
+* Counter for CLI command invocations.
+*/
+const cliCounter = Metric.counter("alchemy.cli.invocations", {
+	description: "Number of alchemy CLI command invocations.",
+	incremental: true
+});
+/**
+* Wraps a resource lifecycle Effect to record a counter + timer entry,
+* tagged with `resource_type`, `op`, and `status` (`success`/`error`).
+*
+* Usage:
+* ```ts
+* provider.create(input).pipe(recordResourceOp(node.resource.Type, "create"))
+* ```
+*/
+const recordResourceOp = (resourceType, op) => (self$1) => Effect.suspend(() => {
+	const startNs = process.hrtime.bigint();
+	const baseAttrs = {
+		resource_type: resourceType,
+		op
+	};
+	return self$1.pipe(Effect.onExit((exit) => recordOutcome(baseAttrs, Exit.isSuccess(exit) ? "success" : "error", elapsed(startNs))));
+});
+/**
+* Wraps a CLI command Effect to bump {@link cliCounter} with the
+* outcome (`success`/`error`).
+*/
+const recordCli = (command) => (self$1) => self$1.pipe(Effect.onExit((exit) => Metric.update(Metric.withAttributes(cliCounter, {
+	command,
+	status: Exit.isSuccess(exit) ? "success" : "error"
+}), 1)));
+const elapsed = (startNs) => Duration.nanos(process.hrtime.bigint() - startNs);
+const recordOutcome = (baseAttrs, status, duration) => {
+	const attrs = {
+		...baseAttrs,
+		status
+	};
+	return Effect.all([Metric.update(Metric.withAttributes(resourceCounter, attrs), 1), Metric.update(Metric.withAttributes(resourceDuration, attrs), duration)], { discard: true });
+};
+
 //#endregion
 //#region src/Util/Clank.ts
 var PromptCancelled = class extends Data.TaggedError("PromptCancelled") {};
@@ -43319,6 +43591,26 @@ const parseSince = (value) => {
 	if (isNaN(parsed.getTime())) throw new Error(`Invalid --since value: '${value}'. Use a duration (e.g. '1h', '30m') or ISO date.`);
 	return parsed;
 };
+/**
+* Wraps a CLI command handler with a top-level OpenTelemetry span
+* (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
+*
+* `attrs` runs against the parsed command args and contributes
+* additional attributes to the span (e.g. stage, profile, dry-run flag).
+*
+* Usage:
+* ```ts
+* Command.make(
+*   "deploy",
+*   { ...flags },
+*   instrumentCommand("deploy", (a) => ({
+*     "alchemy.stage": a.stage,
+*     "alchemy.profile": a.profile,
+*   }))(execStack),
+* );
+* ```
+*/
+const instrumentCommand = (command, attrs = () => ({})) => (handler) => (args) => handler(args).pipe(Effect.withSpan(`cli.${command}`, { attributes: attrs(args) }), recordCli(command));
 const importStack = Effect.fn(function* (main$1) {
 	const path = yield* Path$1.Path;
 	const stackEffect = (yield* Effect.promise(() => import(path.resolve(process.cwd(), main$1)))).default;
@@ -43560,10 +43852,10 @@ const loadConfigProvider = (envFile$1) => {
 //#region src/Util/FileLogger.ts
 const fileLogger = Effect.fnUntraced(function* (...segments) {
 	const { dotAlchemy } = yield* AlchemyContext;
-	const fs$2 = yield* FileSystem.FileSystem;
+	const fs$3 = yield* FileSystem.FileSystem;
 	const path = yield* Path;
 	const logFile = path.join(dotAlchemy, "log", ...segments);
-	yield* fs$2.makeDirectory(path.dirname(logFile), { recursive: true });
+	yield* fs$3.makeDirectory(path.dirname(logFile), { recursive: true });
 	return yield* Logger.formatLogFmt.pipe(Logger.toFile(logFile, { flag: "a" }));
 });
 
@@ -43577,7 +43869,11 @@ const bootstrapCommand = Command$1.make("bootstrap", {
 	profile: awsProfile,
 	region: awsRegion,
 	destroy: bootstrapDestroy
-}, Effect.fnUntraced(function* ({ envFile: envFile$1, profile: profile$1, region, destroy }) {
+}, instrumentCommand("bootstrap", (a) => ({
+	"alchemy.profile": a.profile,
+	"alchemy.region": a.region ?? "",
+	"alchemy.destroy": a.destroy
+}))(Effect.fnUntraced(function* ({ envFile: envFile$1, profile: profile$1, region, destroy }) {
 	const logger = Logger.layer([fileLogger("bootstrap.txt")]);
 	return yield* Effect.gen(function* () {
 		const ssoProfile = yield* Auth.loadProfile(profile$1);
@@ -43600,7 +43896,7 @@ const bootstrapCommand = Command$1.make("bootstrap", {
 			yield* bootstrap().pipe(Effect.tap(({ bucketName, created }) => created ? Console.log(`✓ Created assets bucket: ${bucketName}`) : Console.log(`✓ Assets bucket already exists: ${bucketName}`)), Effect.provide(bootstrapLayer));
 		});
 	}).pipe(Effect.provide(logger));
-}));
+})));
 
 //#endregion
 //#region src/Artifacts.ts
@@ -43914,7 +44210,7 @@ function proxy(self$1) {
 	});
 	const proxy$1 = new Proxy(target, {
 		has: (_, prop) => prop === ExprSymbol || prop === inspect ? true : prop in self$1,
-		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => hint === "string" ? self$1.toString() : self$1 : prop === ExprSymbol ? self$1 : prop === inspect ? target$1[inspect] : isResourceExpr(self$1) && self$1.stables && prop in self$1.stables ? self$1.stables[prop] : prop === "apply" ? self$1[prop] : prop in self$1 ? typeof self$1[prop] === "function" && !("kind" in self$1) ? new PropExpr(proxy$1, prop) : self$1[prop] : new PropExpr(proxy$1, prop),
+		get: (target$1, prop) => prop === Symbol.toPrimitive ? (hint) => hint === "number" ? NaN : self$1.toString() : prop === ExprSymbol ? self$1 : prop === inspect ? target$1[inspect] : isResourceExpr(self$1) && self$1.stables && prop in self$1.stables ? self$1.stables[prop] : prop === "apply" ? self$1[prop] : prop in self$1 ? typeof self$1[prop] === "function" && !("kind" in self$1) ? new PropExpr(proxy$1, prop) : self$1[prop] : new PropExpr(proxy$1, prop),
 		apply: (_, thisArg, args) => {
 			if (isPropExpr(self$1)) {
 				if (self$1.identifier === "apply") return new ApplyExpr(self$1.expr, args[0]);
@@ -44086,7 +44382,7 @@ const reviveState = (_key, value) => {
 //#region src/State/LocalState.ts
 const localState = () => Layer.effect(State, makeLocalState());
 const makeLocalState = () => Effect.gen(function* () {
-	const fs$2 = yield* FileSystem.FileSystem;
+	const fs$3 = yield* FileSystem.FileSystem;
 	const path = yield* Path$1.Path;
 	const dotAlchemy = path.join(process.cwd(), ".alchemy");
 	const stateDir = path.join(dotAlchemy, "state");
@@ -44098,11 +44394,11 @@ const makeLocalState = () => Effect.gen(function* () {
 	const stageDir = ({ stack, stage: stage$1 }) => path.join(stateDir, stack, stage$1);
 	const resource = ({ stack, stage: stage$1, fqn }) => path.join(stateDir, stack, stage$1, `${encodeFqn(fqn)}.json`);
 	const created = /* @__PURE__ */ new Set();
-	const ensure = (dir) => created.has(dir) ? Effect.succeed(void 0) : fs$2.makeDirectory(dir, { recursive: true }).pipe(Effect.tap(() => Effect.sync(() => created.add(dir))));
+	const ensure = (dir) => created.has(dir) ? Effect.succeed(void 0) : fs$3.makeDirectory(dir, { recursive: true }).pipe(Effect.tap(() => Effect.sync(() => created.add(dir))));
 	const state = {
-		listStacks: () => fs$2.readDirectory(stateDir).pipe(recover, Effect.map((files) => files ?? [])),
-		listStages: (stack) => fs$2.readDirectory(path.join(stateDir, stack)).pipe(recover, Effect.map((files) => files ?? [])),
-		get: (request) => fs$2.readFile(resource(request)).pipe(Effect.map((file) => JSON.parse(file.toString(), reviveState)), recover),
+		listStacks: () => fs$3.readDirectory(stateDir).pipe(recover, Effect.map((files) => files ?? [])),
+		listStages: (stack) => fs$3.readDirectory(path.join(stateDir, stack)).pipe(recover, Effect.map((files) => files ?? [])),
+		get: (request) => fs$3.readFile(resource(request)).pipe(Effect.map((file) => JSON.parse(file.toString(), reviveState)), recover),
 		getReplacedResources: Effect.fnUntraced(function* (request) {
 			return (yield* Effect.all((yield* state.list(request)).map((fqn) => state.get({
 				stack: request.stack,
@@ -44110,13 +44406,13 @@ const makeLocalState = () => Effect.gen(function* () {
 				fqn
 			})))).filter((r) => r?.status === "replaced");
 		}),
-		set: (request) => ensure(stageDir(request)).pipe(Effect.flatMap(() => fs$2.writeFileString(resource(request), JSON.stringify(encodeState(request.value), null, 2))), recover, Effect.map(() => request.value)),
-		delete: (request) => fs$2.remove(resource(request)).pipe(recover),
-		deleteStack: ({ stack, stage: stage$1 }) => fs$2.remove(stage$1 === void 0 ? path.join(stateDir, stack) : stageDir({
+		set: (request) => ensure(stageDir(request)).pipe(Effect.flatMap(() => fs$3.writeFileString(resource(request), JSON.stringify(encodeState(request.value), null, 2))), recover, Effect.map(() => request.value)),
+		delete: (request) => fs$3.remove(resource(request)).pipe(recover),
+		deleteStack: ({ stack, stage: stage$1 }) => fs$3.remove(stage$1 === void 0 ? path.join(stateDir, stack) : stageDir({
 			stack,
 			stage: stage$1
 		}), { recursive: true }).pipe(recover),
-		list: (request) => fs$2.readDirectory(stageDir(request)).pipe(recover, Effect.map((files) => files?.map((file) => decodeFqn(file.replace(/\.json$/, ""))) ?? []))
+		list: (request) => fs$3.readDirectory(stageDir(request)).pipe(recover, Effect.map((files) => files?.map((file) => decodeFqn(file.replace(/\.json$/, ""))) ?? []))
 	};
 	return state;
 });
@@ -44124,6 +44420,23 @@ const makeLocalState = () => Effect.gen(function* () {
 //#endregion
 //#region src/Apply.ts
 const provideLifecycleScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+/**
+* Instruments a single provider lifecycle call with an OTel span
+* (`provider.<op>`), the resource counter / duration histogram, and the
+* scoped artifacts/instance services normally supplied by
+* {@link provideLifecycleScope}.
+*
+* This is the only call site through which provider lifecycle methods
+* are dispatched, so wrapping it here gives us a fully-instrumented
+* toolchain without touching any individual provider implementation.
+*/
+const instrumentLifecycle = (op, fqn, resourceType, logicalId, instanceId) => (effect) => effect.pipe(provideLifecycleScope(fqn, instanceId), recordResourceOp(resourceType, op), Effect.withSpan(`provider.${op}`, { attributes: {
+	"alchemy.resource.fqn": fqn,
+	"alchemy.resource.type": resourceType,
+	"alchemy.resource.logical_id": logicalId,
+	"alchemy.resource.instance_id": instanceId,
+	"alchemy.resource.op": op
+} }));
 const apply = (plan) => Effect.gen(function* () {
 	const session = yield* (yield* Cli).startApplySession(plan);
 	const state = yield* State;
@@ -44145,7 +44458,10 @@ const apply = (plan) => Effect.gen(function* () {
 	if (!plan.output) return;
 	const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	return yield* evaluate(plan.output, outputs);
-}).pipe(ensureArtifactStore);
+}).pipe(ensureArtifactStore, Effect.withSpan("apply", { attributes: {
+	"alchemy.resources.count": Object.keys(plan.resources).length,
+	"alchemy.deletions.count": Object.keys(plan.deletions).length
+} }));
 const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	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]));
@@ -44271,7 +44587,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 					session: scopedSession,
 					instanceId,
 					bindings: excludeDeletedBindings(node.bindings)
-				}).pipe(provideLifecycleScope(fqn, instanceId));
+				}).pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
 				yield* commit({
 					status: "creating",
 					fqn,
@@ -44304,7 +44620,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				session: scopedSession,
 				output: attr
-			}).pipe(provideLifecycleScope(fqn, instanceId));
+			}).pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
 			yield* commit({
 				status: "created",
 				fqn,
@@ -44367,7 +44683,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				session: scopedSession,
 				olds: previousProps,
 				output: node.state.attr
-			}).pipe(provideLifecycleScope(fqn, instanceId));
+			}).pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
 			if (node.state.status === "replaced") yield* commit({
 				...node.state,
 				attr,
@@ -44439,7 +44755,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 					session: scopedSession,
 					instanceId,
 					bindings: excludeDeletedBindings(node.bindings)
-				}).pipe(provideLifecycleScope(fqn, instanceId));
+				}).pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
 				yield* commit({
 					status: "replacing",
 					fqn,
@@ -44474,7 +44790,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				session: scopedSession,
 				output: attr
-			}).pipe(provideLifecycleScope(fqn, instanceId));
+			}).pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
 			yield* commit({
 				status: "replaced",
 				fqn,
@@ -44502,7 +44818,12 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 		}
 		return yield* Effect.die(`Unknown action: ${node.action}`);
 	});
-});
+}).pipe(Effect.withSpan("apply.resource", { attributes: {
+	"alchemy.resource.fqn": fqn,
+	"alchemy.resource.type": node.resource.Type,
+	"alchemy.resource.logical_id": node.resource.LogicalId,
+	"alchemy.resource.action": node.action
+} }));
 const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, session, state, stackName, stage$1) {
 	for (;;) {
 		let anyUpdated = false;
@@ -44537,7 +44858,7 @@ const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, s
 				session: scopedSession,
 				olds: oldProps,
 				output: tracker[fqn].output
-			}).pipe(provideLifecycleScope(fqn, instanceId));
+			}).pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
 			tracker[fqn] = {
 				output: attr,
 				props: newProps,
@@ -44658,7 +44979,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 					output: attr,
 					session: scopedSession,
 					bindings: []
-				}).pipe(provideLifecycleScope(fqn, instanceId));
+				}).pipe(instrumentLifecycle("delete", fqn, resourceType, logicalId, instanceId));
 				if (isDeleteNode(node)) {
 					yield* state.delete({
 						stack: stackName,
@@ -45185,7 +45506,7 @@ const emptyConfig = () => ({
 	version: CONFIG_VERSION,
 	profiles: {}
 });
-const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs$2) => fs$2.readFileString(configFilePath)), Effect.flatMap((data) => Effect.try({
+const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs$3) => fs$3.readFileString(configFilePath)), Effect.flatMap((data) => Effect.try({
 	try: () => {
 		const parsed = JSON.parse(data);
 		if (parsed?.version !== CONFIG_VERSION) return emptyConfig();
@@ -45193,7 +45514,7 @@ const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs$2) =
 	},
 	catch: emptyConfig
 })), Effect.orElseSucceed(emptyConfig));
-const writeConfig = (config) => FileSystem.FileSystem.asEffect().pipe(Effect.tap((fs$2) => fs$2.makeDirectory(posix.dirname(configFilePath), { recursive: true })), Effect.flatMap((fs$2) => fs$2.writeFileString(configFilePath, JSON.stringify(config, null, 2))));
+const writeConfig = (config) => FileSystem.FileSystem.asEffect().pipe(Effect.tap((fs$3) => fs$3.makeDirectory(posix.dirname(configFilePath), { recursive: true })), Effect.flatMap((fs$3) => fs$3.writeFileString(configFilePath, JSON.stringify(config, null, 2))));
 const getProfile = (name) => readConfig.pipe(Effect.map((config) => config.profiles[name]));
 const setProfile = (name, profile$1) => readConfig.pipe(Effect.tap((config) => Effect.sync(() => config.profiles[name] = profile$1)), Effect.flatMap(writeConfig));
 /**
@@ -45311,7 +45632,7 @@ const make = (stack, options$2 = {}) => Effect.gen(function* () {
 		return [fqn, (rawUpstreamDependencies[fqn] ?? []).filter((dep) => newResourceFqns.has(dep))];
 	}));
 	const newDownstreamDependencies = Object.fromEntries(resources.map((resource) => [resource.FQN, Object.entries(newUpstreamDependencies).filter(([_, upstream$1]) => upstream$1.includes(resource.FQN)).map(([depFqn]) => depFqn)]));
-	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn(function* (resource) {
+	const resourceGraph = Object.fromEntries((yield* Effect.all(resources.map(Effect.fn("plan.diff.resource")(function* (resource) {
 		const provider = yield* findProviderByType(resource.Type);
 		const id = resource.LogicalId;
 		const fqn = resource.FQN;
@@ -45484,7 +45805,7 @@ const make = (stack, options$2 = {}) => Effect.gen(function* () {
 	const deletions = Object.fromEntries((yield* Effect.all((yield* state.list({
 		stack: stackName,
 		stage: stage$1
-	})).map(Effect.fn(function* (fqn) {
+	})).map(Effect.fn("plan.diff.deletion")(function* (fqn) {
 		if (newResourceFqns.has(fqn)) return;
 		const oldState = yield* state.get({
 			stack: stackName,
@@ -45546,13 +45867,26 @@ const make = (stack, options$2 = {}) => Effect.gen(function* () {
 		deletions,
 		output: stack.output
 	};
-}).pipe(ensureArtifactStore);
+}).pipe(ensureArtifactStore, Effect.withSpan("plan.make", { attributes: {
+	"alchemy.stack": stack.name,
+	"alchemy.stage": stack.stage,
+	"alchemy.resources.count": Object.keys(stack.resources).length,
+	"alchemy.force": !!options$2.force
+} }));
 const providePlanScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
 var DeleteResourceHasDownstreamDependencies = class extends Data.TaggedError("DeleteResourceHasDownstreamDependencies") {};
 var UnsatisfiedResourceCycle = class extends Data.TaggedError("UnsatisfiedResourceCycle") {};
 
 //#endregion
 //#region bin/commands/deploy.ts
+const stackSpanAttrs = (args) => ({
+	"alchemy.stage": args.stage,
+	"alchemy.profile": args.profile,
+	"alchemy.main": args.main,
+	"alchemy.dry_run": !!args.dryRun,
+	"alchemy.force": !!args.force,
+	"alchemy.destroy": !!args.destroy
+});
 const execStack = Effect.fn(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, dryRun: dryRun$1 = false, force: force$1 = false, yes: yes$1 = false, destroy = false }) {
 	const stackEffect = yield* importStack(main$1);
 	const services$1 = Layer.mergeAll(Layer.succeed(ArtifactStore, createArtifactStore()), Layer.succeed(AuthProviders, yield* Effect.serviceOption(AuthProviders).pipe(Effect.map(Option.getOrElse(() => ({}))))), ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Logger.layer([fileLogger("out")]), Layer.succeed(Stage, stage$1));
@@ -45586,7 +45920,7 @@ const deployCommand = Command$1.make("deploy", {
 	stage,
 	yes,
 	profile
-}, execStack);
+}, instrumentCommand("deploy", stackSpanAttrs)(execStack));
 const destroyCommand = Command$1.make("destroy", {
 	dryRun,
 	main,
@@ -45594,19 +45928,19 @@ const destroyCommand = Command$1.make("destroy", {
 	stage,
 	yes,
 	profile
-}, (args) => execStack({
+}, instrumentCommand("destroy", stackSpanAttrs)((args) => execStack({
 	...args,
 	destroy: true
-}));
+})));
 const planCommand = Command$1.make("plan", {
 	main,
 	envFile,
 	stage,
 	profile
-}, (args) => execStack({
+}, instrumentCommand("plan", stackSpanAttrs)((args) => execStack({
 	...args,
 	dryRun: true
-}));
+})));
 
 //#endregion
 //#region bin/commands/login.ts
@@ -45617,7 +45951,12 @@ const loginCommand = Command.make("login", {
 	stage,
 	profile,
 	configure: loginConfigure
-}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, configure }) {
+}, instrumentCommand("login", (a) => ({
+	"alchemy.stage": a.stage,
+	"alchemy.profile": a.profile,
+	"alchemy.main": a.main,
+	"alchemy.configure": a.configure
+}))(Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, configure }) {
 	const stackEffect = yield* importStack(main$1);
 	const authProviders = {};
 	const services$1 = Layer.mergeAll(Layer.succeed(AuthProviders, authProviders), ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Logger.layer([fileLogger("out")]), Layer.succeed(Stage, stage$1), localState());
@@ -45644,7 +45983,7 @@ const loginCommand = Command.make("login", {
 			yield* provider.prettyPrint(profile$1, cfg);
 		}), { discard: true });
 	}).pipe(Effect.provide(services$1));
-}));
+})));
 
 //#endregion
 //#region bin/commands/logs.ts
@@ -45658,7 +45997,12 @@ const logsCommand = Command.make("logs", {
 	filter: resourceFilter,
 	limit: logsLimit,
 	since: logsSince
-}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter, limit, since }) {
+}, instrumentCommand("logs", (a) => ({
+	"alchemy.stage": a.stage,
+	"alchemy.profile": a.profile,
+	"alchemy.main": a.main,
+	"alchemy.limit": a.limit
+}))(Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter, limit, since }) {
 	const stackEffect = yield* importStack(main$1);
 	const services$1 = Layer.mergeAll(ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Layer.succeed(AuthProviders, {}), Layer.succeed(Stage, stage$1), Logger.layer([fileLogger("out")]), localState());
 	const sinceDate = since ? parseSince(since) : void 0;
@@ -45714,7 +46058,7 @@ const logsCommand = Command.make("logs", {
 			for (const entry of merged) yield* Console.log(entry.formatted);
 		}).pipe(Effect.provide(stack.services));
 	}).pipe(Effect.provide(services$1));
-}));
+})));
 
 //#endregion
 //#region src/Auth/Credentials.ts
@@ -45731,10 +46075,10 @@ const readCredentials = Effect.fnUntraced(function* (profile$1, provider) {
 	}
 });
 const writeCredentials = Effect.fnUntraced(function* (profile$1, provider, credentials) {
-	const fs$2 = yield* FileSystem.FileSystem;
+	const fs$3 = yield* FileSystem.FileSystem;
 	const filePath = credentialsFilePath(profile$1, provider);
-	yield* fs$2.makeDirectory(posix.dirname(filePath), { recursive: true });
-	yield* fs$2.writeFileString(filePath, JSON.stringify(credentials, null, 2));
+	yield* fs$3.makeDirectory(posix.dirname(filePath), { recursive: true });
+	yield* fs$3.writeFileString(filePath, JSON.stringify(credentials, null, 2));
 });
 const deleteCredentials = Effect.fnUntraced(function* (profile$1, provider) {
 	yield* (yield* FileSystem.FileSystem).remove(credentialsFilePath(profile$1, provider)).pipe(Effect.catch(() => Effect.void));
@@ -45864,11 +46208,11 @@ const prettyPrint$1 = (profileName, config) => resolveCredentials$1(profileName,
 const clearDistilledSsoCache = (ssoProfile) => Effect.gen(function* () {
 	const ssoSession = (yield* (yield* Auth.Default).loadProfile(ssoProfile)).sso_session;
 	if (!ssoSession) return;
-	const fs$2 = yield* FileSystem.FileSystem;
+	const fs$3 = yield* FileSystem.FileSystem;
 	const path = yield* Path$1.Path;
-	const hash = NodeCrypto.createHash("sha1").update(ssoSession).digest("hex");
-	const cacheFile = path.join(NodeOs.homedir(), ".aws", "sso", "cache", `${hash}.credentials.json`);
-	yield* fs$2.remove(cacheFile).pipe(Effect.catch(() => Effect.void));
+	const hash = crypto$2.createHash("sha1").update(ssoSession).digest("hex");
+	const cacheFile = path.join(os$1.homedir(), ".aws", "sso", "cache", `${hash}.credentials.json`);
+	yield* fs$3.remove(cacheFile).pipe(Effect.catch(() => Effect.void));
 }).pipe(Effect.catch(() => Effect.void));
 const logout$1 = (profileName, config) => Match.value(config).pipe(Match.when({ method: "env" }, () => Effect.void), Match.when({ method: "sso" }, (config$1) => info(`AWS: running 'aws sso logout --profile ${config$1.ssoProfile}'...`).pipe(Effect.zip(runSsoCommand("logout", config$1.ssoProfile)), Effect.zip(clearDistilledSsoCache(config$1.ssoProfile)), Effect.match({
 	onSuccess: () => success("AWS: SSO logout complete"),
@@ -46495,7 +46839,7 @@ const OAUTH_ENDPOINTS = {
 const showCommand = Command.make("show", {
 	profile,
 	envFile
-}, Effect.fnUntraced(function* ({ profile: profile$1, envFile: envFile$1 }) {
+}, instrumentCommand("profile.show", (a) => ({ "alchemy.profile": a.profile }))(Effect.fnUntraced(function* ({ profile: profile$1, envFile: envFile$1 }) {
 	const stored = yield* getProfile(profile$1);
 	if (stored == null) {
 		const config = yield* readConfig;
@@ -46529,13 +46873,13 @@ const showCommand = Command.make("show", {
 			yield* provider.prettyPrint(profile$1, cfg);
 		}
 	}).pipe(Effect.provide(services$1));
-}));
-const clearCommand$1 = Command.make("clear", { profile }, Effect.fnUntraced(function* ({ profile: profile$1 }) {
+})));
+const clearCommand$1 = Command.make("clear", { profile }, instrumentCommand("profile.clear", (a) => ({ "alchemy.profile": a.profile }))(Effect.fnUntraced(function* ({ profile: profile$1 }) {
 	const removed = yield* deleteProfile(profile$1);
 	yield* deleteProfileCredentials(profile$1);
 	if (removed) yield* Console.log(`Cleared profile '${profile$1}' and all its credentials.`);
 	else yield* Console.log(`Profile '${profile$1}' not found in profiles.json; removed any stray credentials directory.`);
-}));
+})));
 const profileCommand = Command.make("profile", {}).pipe(Command.withSubcommands([showCommand, clearCommand$1]));
 
 //#endregion
@@ -46574,7 +46918,7 @@ const stacksCommand = Command.make("stacks", {
 	stage,
 	profile,
 	local: localFlag
-}, Effect.fnUntraced(function* (args) {
+}, instrumentCommand("state.stacks")(Effect.fnUntraced(function* (args) {
 	yield* withStateService(args, (state) => Effect.gen(function* () {
 		const stacks = yield* state.listStacks();
 		if (stacks.length === 0) {
@@ -46583,7 +46927,7 @@ const stacksCommand = Command.make("stacks", {
 		}
 		for (const s of [...stacks].sort()) yield* Console.log(s);
 	}));
-}));
+})));
 const stagesCommand = Command.make("stages", {
 	stack: stackArg,
 	main,
@@ -46591,7 +46935,7 @@ const stagesCommand = Command.make("stages", {
 	stage,
 	profile,
 	local: localFlag
-}, Effect.fnUntraced(function* ({ stack: stackName,...rest }) {
+}, instrumentCommand("state.stages")(Effect.fnUntraced(function* ({ stack: stackName,...rest }) {
 	yield* withStateService(rest, (state) => Effect.gen(function* () {
 		const stages = yield* state.listStages(stackName);
 		if (stages.length === 0) {
@@ -46600,7 +46944,7 @@ const stagesCommand = Command.make("stages", {
 		}
 		for (const s of [...stages].sort()) yield* Console.log(s);
 	}));
-}));
+})));
 const resourcesCommand = Command.make("resources", {
 	stack: stackArg,
 	stageName: Argument.string("stage").pipe(Argument.withDescription("Stage to list resources from")),
@@ -46609,7 +46953,7 @@ const resourcesCommand = Command.make("resources", {
 	stage,
 	profile,
 	local: localFlag
-}, Effect.fnUntraced(function* ({ stack: stackName, stageName,...rest }) {
+}, instrumentCommand("state.resources")(Effect.fnUntraced(function* ({ stack: stackName, stageName,...rest }) {
 	yield* withStateService(rest, (state) => Effect.gen(function* () {
 		const fqns = yield* state.list({
 			stack: stackName,
@@ -46621,7 +46965,7 @@ const resourcesCommand = Command.make("resources", {
 		}
 		for (const f of [...fqns].sort()) yield* Console.log(f);
 	}));
-}));
+})));
 const getCommand = Command.make("get", {
 	stack: stackArg,
 	stageName: Argument.string("stage").pipe(Argument.withDescription("Stage the resource lives in")),
@@ -46631,7 +46975,7 @@ const getCommand = Command.make("get", {
 	stage,
 	profile,
 	local: localFlag
-}, Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn,...rest }) {
+}, instrumentCommand("state.get")(Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn,...rest }) {
 	yield* withStateService(rest, (state) => Effect.gen(function* () {
 		const value = yield* state.get({
 			stack: stackName,
@@ -46644,14 +46988,14 @@ const getCommand = Command.make("get", {
 		}
 		yield* Console.log(JSON.stringify(encodeState(value), null, 2));
 	}));
-}));
+})));
 const treeCommand = Command.make("tree", {
 	main,
 	envFile,
 	stage,
 	profile,
 	local: localFlag
-}, Effect.fnUntraced(function* (args) {
+}, instrumentCommand("state.tree")(Effect.fnUntraced(function* (args) {
 	yield* withStateService(args, (state) => Effect.gen(function* () {
 		const stacks = [...yield* state.listStacks()].sort();
 		if (stacks.length === 0) {
@@ -46678,7 +47022,7 @@ const treeCommand = Command.make("tree", {
 			}
 		}
 	}));
-}));
+})));
 const clearStackArg = Argument.string("stack").pipe(Argument.withDescription("Stack name to clear. Omit to clear ALL stacks in the store."), Argument.optional);
 const clearStageArg = Argument.string("stage").pipe(Argument.withDescription("Stage to clear within the stack. Omit to clear all stages in the stack."), Argument.optional);
 /**
@@ -46695,7 +47039,7 @@ const clearCommand = Command.make("clear", {
 	profile,
 	local: localFlag,
 	yes
-}, Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag,...rest }) {
+}, instrumentCommand("state.clear")(Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag,...rest }) {
 	const stackName = Option.getOrUndefined(stackOpt);
 	const stageName = Option.getOrUndefined(stageOpt);
 	if (stageName !== void 0 && stackName === void 0) {
@@ -46726,7 +47070,7 @@ const clearCommand = Command.make("clear", {
 			yield* Console.log(`cleared ${target.stack}${target.stage ? `/${target.stage}` : ""}`);
 		}
 	}));
-}));
+})));
 const stateCommand = Command.make("state", {}).pipe(Command.withSubcommands([
 	stacksCommand,
 	stagesCommand,
@@ -46744,7 +47088,11 @@ const tailCommand = Command$1.make("tail", {
 	stage,
 	profile,
 	filter: resourceFilter
-}, Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter }) {
+}, instrumentCommand("tail", (a) => ({
+	"alchemy.stage": a.stage,
+	"alchemy.profile": a.profile,
+	"alchemy.main": a.main
+}))(Effect.fnUntraced(function* ({ main: main$1, stage: stage$1, envFile: envFile$1, profile: profile$1, filter }) {
 	const stackEffect = yield* importStack(main$1);
 	const services$1 = Layer.mergeAll(ConfigProvider.layer(withProfileOverride(yield* loadConfigProvider(envFile$1), profile$1)), Layer.succeed(AuthProviders, {}), Layer.succeed(Stage, stage$1), Logger.layer([fileLogger("out")]), localState());
 	yield* Effect.gen(function* () {
@@ -46794,7 +47142,7 @@ const tailCommand = Command$1.make("tail", {
 			yield* Stream$1.mergeAll(taggedStreams, { concurrency: "unbounded" }).pipe(Stream$1.runForEach((line) => Console.log(line)));
 		}).pipe(Effect.provide(stack.services));
 	}).pipe(Effect.provide(services$1));
-}));
+})));
 
 //#endregion
 //#region bin/alchemy.ts
@@ -46810,7 +47158,7 @@ const root = Command$1.make("alchemy", {}).pipe(Command$1.withSubcommands([
 	stateCommand
 ]));
 const cli = Command$1.run(root, { version });
-const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), inkCLI());
+const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), TelemetryLive, inkCLI());
 cli.pipe(Effect.provide(services), Effect.scoped, handleCancellation, runMain);
 
 //#endregion