@samebase/alchemy-convex 0.1.0 → 0.2.0

package/lib/index.js

@@ -1,11 +1,963 @@
-// @samebase/alchemy-convex: Convex resources for Alchemy v2.
-export { ACCESS_TOKEN_ENV, Credentials, CredentialsError, fromConfig, fromToken, } from "./Credentials.js";
-export { DefaultEnvironmentVariable, } from "./DefaultEnvironmentVariable.js";
-export { Deploy, deployArgs, parseDeployOutput, } from "./Deploy.js";
-export { DeployKey, } from "./DeployKey.js";
-export { EnvironmentVariable, } from "./EnvironmentVariable.js";
-export { ConvexApiError, ManagementApi } from "./ManagementApi.js";
-export { PreviewDeployKey, } from "./PreviewDeployKey.js";
-export { Project, } from "./Project.js";
-export { Providers, providers } from "./Providers.js";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { Resource } from "alchemy";
+import { AdoptPolicy, OwnedBySomeoneElse, Unowned } from "alchemy/AdoptPolicy";
+import { havePropsChanged, isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { AlchemyContext } from "alchemy/AlchemyContext";
+import { Stack } from "alchemy/Stack";
+import * as Option from "effect/Option";
+import { createDeploymentClient, createManagementClient } from "@convex-dev/platform";
+import * as Schedule from "effect/Schedule";
+import { stripVTControlCharacters } from "node:util";
+import { CommandExecutor, CommandExecutorLive } from "alchemy/Command";
+import { hashDirectory } from "alchemy/Command/Memo";
+import { createHash } from "node:crypto";
+//#region src/Credentials.ts
+var Credentials = class extends Context.Service()("@samebase/alchemy-convex/Credentials") {};
+/** Environment variable read by {@link fromConfig}. */
+const ACCESS_TOKEN_ENV = "CONVEX_ACCESS_TOKEN";
+/** The Convex CLI stores its device login here after `npx convex login`. */
+const convexCliConfigPath = () => join(homedir(), ".convex", "config.json");
+const CliConfig = Schema.Struct({ accessToken: Schema.String });
+/**
+* Token the Convex CLI saved on this machine. It works on the Management API
+* for the teams the logged-in user belongs to. Fails when nobody is logged in.
+*/
+const readConvexCliLogin = Effect.gen(function* () {
+	const path = convexCliConfigPath();
+	const text = yield* Effect.tryPromise({
+		try: () => readFile(path, "utf8"),
+		catch: () => new CredentialsError({ reason: `no Convex CLI login at ${path}` })
+	});
+	const parsed = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(CliConfig))(text).pipe(Effect.mapError(() => new CredentialsError({ reason: `${path} has no accessToken` })));
+	return {
+		accessToken: Redacted.make(parsed.accessToken),
+		source: "convex-cli-login"
+	};
+});
+var CredentialsError = class extends Schema.TaggedError()("CredentialsError", { reason: Schema.String }) {};
+/**
+* Default resolution: `CONVEX_ACCESS_TOKEN` from the stack ConfigProvider
+* (process env, `.env`, stack secrets), then the Convex CLI login on this
+* machine. CI sets the variable; a developer who ran `npx convex login` needs
+* nothing.
+*/
+const fromConfig = () => Layer.succeed(Credentials, Effect.cached(Config.Redacted(ACCESS_TOKEN_ENV).pipe(Effect.map((accessToken) => ({
+	accessToken,
+	source: "env"
+})), Effect.catch(() => readConvexCliLogin), Effect.orDie)).pipe(Effect.flatten));
+/** Explicit token, for tests or callers that already hold a value. */
+const fromToken = (accessToken) => Layer.succeed(Credentials, Effect.succeed({
+	accessToken,
+	source: "explicit"
+}));
+//#endregion
+//#region src/Adoption.ts
+/** True when the resource `fqn` may take over an object that is not in state. */
+const shouldAdopt = (fqn) => Effect.gen(function* () {
+	const stack = yield* Effect.serviceOption(Stack);
+	const own = Option.isSome(stack) ? stack.value.resources[fqn]?.Adopt : void 0;
+	if (own !== void 0) return own;
+	const policy = yield* Effect.serviceOption(AdoptPolicy);
+	if (Option.isSome(policy)) return policy.value;
+	const context = yield* Effect.serviceOption(AlchemyContext);
+	return Option.isSome(context) && context.value.adopt;
+});
+//#endregion
+//#region src/ManagementApi.ts
+/**
+* One error for every control-plane and deployment call. Resources branch on
+* `status` (404 means absent for read and delete), so the class is load
+* bearing, not decorative.
+*/
+var ConvexApiError = class extends Schema.TaggedError()("ConvexApiError", {
+	operation: Schema.String,
+	status: Schema.Number,
+	code: Schema.optionalKey(Schema.String),
+	message: Schema.String
+}) {};
+const ErrorBody = Schema.Struct({
+	code: Schema.optionalKey(Schema.String),
+	message: Schema.optionalKey(Schema.String)
+});
+const toApiError = (operation, result) => {
+	const body = Schema.decodeUnknownSync(Schema.NullishOr(ErrorBody))(result.error ?? null);
+	const code = body?.code;
+	return new ConvexApiError({
+		operation,
+		status: result.response.status,
+		...code === void 0 ? {} : { code },
+		message: body?.message ?? `${operation} failed with HTTP ${result.response.status}`
+	});
+};
+/** The part of a Convex token after the first "|", or the whole value when it has none. */
+const tokenPart = (value) => value.slice(value.indexOf("|") + 1);
+var ManagementApi = class extends Context.Service()("@samebase/alchemy-convex/ManagementApi") {};
+const attempt = (operation, run) => Effect.tryPromise({
+	try: run,
+	catch: (cause) => new ConvexApiError({
+		operation,
+		status: 0,
+		message: cause instanceof Error ? cause.message : String(cause)
+	})
+});
+/** Reads `data` or fails with the HTTP status and the API's own code and message. */
+const settle = (operation, run) => attempt(operation, run).pipe(Effect.flatMap((result) => result.response.ok && result.data !== void 0 ? Effect.succeed(result.data) : Effect.fail(toApiError(operation, result))));
+/** For endpoints that answer with an empty body, such as delete calls. */
+const settleVoid = (operation, run) => attempt(operation, run).pipe(Effect.flatMap((result) => result.response.ok ? Effect.void : Effect.fail(toApiError(operation, result))));
+/**
+* True when an idempotent write can succeed on a new attempt:
+*
+* - A Convex write conflict. Two parallel update_environment_variables calls
+*   on one deployment gave HTTP 503 `OptimisticConcurrencyControlFailure`,
+*   "Data read or written in this mutation changed while it was being run",
+*   in a live run. The platform codes `OCC` and `WriteConflict` and the
+*   message "... changed while this mutation was being run ..." mean the same.
+* - Any other 5xx answer. Two parallel delete_preview_deploy_key calls on one
+*   project gave HTTP 500 `InternalServerError`, "Your request couldn't be
+*   completed. Try again later.", in a live run. The next attempt succeeded.
+*/
+const isRetryableWriteError = (error) => error.code === "OptimisticConcurrencyControlFailure" || error.code === "OCC" || error.code === "WriteConflict" || /changed while (it|this mutation) was being run/.test(error.message) || error.status >= 500;
+/**
+* Runs an idempotent write again after a retryable Convex error: at most
+* four more attempts, with exponential backoff from 100 ms and jitter. Other
+* errors fail at once, and so does the last retryable error. Use it only for
+* a write that has the same result when it runs twice, such as setting a
+* value or deleting by id. Never for a create that does not check first.
+*/
+const retryIdempotentWrite = (effect) => effect.pipe(Effect.retry({
+	while: (error) => error instanceof ConvexApiError && isRetryableWriteError(error),
+	times: 4,
+	schedule: Schedule.exponential("100 millis").pipe(Schedule.jittered)
+}));
+/** Turns a 404 into `undefined` so read and delete stay idempotent. */
+const absentAsUndefined = (effect) => effect.pipe(Effect.catchIf((error) => error.status === 404, () => Effect.succeed(void 0)));
+const TeamRow = Schema.Struct({
+	id: Schema.Number,
+	slug: Schema.String
+});
+const TeamRows = Schema.Array(TeamRow);
+const ManagementApiLive = () => Layer.effect(ManagementApi, Effect.gen(function* () {
+	const credentials = yield* Credentials;
+	const client = Effect.cached(credentials.pipe(Effect.map((resolved) => createManagementClient(Redacted.value(resolved.accessToken))))).pipe(Effect.flatten);
+	const request = (operation, run) => client.pipe(Effect.flatMap((c) => settle(operation, () => run(c))));
+	const requestVoid = (operation, run) => client.pipe(Effect.flatMap((c) => settleVoid(operation, () => run(c))));
+	const deploymentRequest = (operation, deploymentUrlOrName, deployKey, run) => settle(operation, () => run(createDeploymentClient(deploymentUrlOrName, Redacted.value(deployKey))));
+	const resolveTeamId = (team) => Effect.gen(function* () {
+		if (typeof team === "number") return team;
+		if (/^\d+$/.test(team)) return Number(team);
+		const resolved = yield* credentials;
+		const match = (yield* Effect.tryPromise({
+			try: async () => {
+				const response = await fetch("https://api.convex.dev/api/dashboard/teams", { headers: { Authorization: `Bearer ${Redacted.value(resolved.accessToken)}` } });
+				if (!response.ok) throw new Error(`team lookup for "${team}" failed with HTTP ${response.status}`);
+				return Schema.decodeUnknownSync(TeamRows)(await response.json());
+			},
+			catch: (cause) => new ConvexApiError({
+				operation: "resolve team",
+				status: 0,
+				message: cause instanceof Error ? cause.message : String(cause)
+			})
+		})).find((row) => row.slug === team);
+		if (match === void 0) return yield* new ConvexApiError({
+			operation: "resolve team",
+			status: 404,
+			message: `no team with slug "${team}" for this token`
+		});
+		return match.id;
+	});
+	const isCredentialToken = (secret) => credentials.pipe(Effect.map((resolved) => tokenPart(Redacted.value(resolved.accessToken)) === tokenPart(secret)));
+	return {
+		request,
+		requestVoid,
+		deploymentRequest,
+		resolveTeamId,
+		isCredentialToken
+	};
+}));
+//#endregion
+//#region src/EnvironmentVariable.ts
+/**
+* The variable's identity when the listing has `name`. Own keys only: a
+* valid variable name such as `toString` must not match the object prototype.
+*/
+const findVariable = (list, deployment, name) => Object.hasOwn(list.environmentVariables, name) ? {
+	deployment,
+	name
+} : void 0;
+/**
+* One attempt to set one variable, or to remove it when `value` is null. The
+* deployment answers 200 with an empty body, so this reads no response data.
+*/
+const writeVariable = (deployment, deployKey, name, value) => settleVoid("update environment variables", () => createDeploymentClient(deployment, Redacted.value(deployKey)).POST("/update_environment_variables", { body: { changes: [{
+	name,
+	value: Redacted.isRedacted(value) ? Redacted.value(value) : value
+}] } }));
+/**
+* Sets one variable, or removes it when `value` is null. The call sets a
+* value, so it runs again after a write conflict or a 5xx answer, for example
+* when another resource writes a variable of the same deployment at the same
+* time. Use it only where the variable is already ours to set.
+*/
+const updateVariable = (deployment, deployKey, name, value) => retryIdempotentWrite(writeVariable(deployment, deployKey, name, value));
+/** GET https://<deployment>.convex.cloud/api/v1/list_environment_variables */
+const EnvironmentVariableList = Schema.Struct({ environmentVariables: Schema.Record(Schema.String, Schema.String) });
+/** The variable's identity, or undefined when the variable or the deployment is absent. */
+const readVariable = (api, deployment, deployKey, name) => absentAsUndefined(api.deploymentRequest("list environment variables", deployment, deployKey, (client) => client.GET("/list_environment_variables"))).pipe(Effect.map((body) => body === void 0 ? void 0 : findVariable(Schema.decodeUnknownSync(EnvironmentVariableList)(body), deployment, name)));
+const EnvironmentVariable = Resource("Convex.EnvironmentVariable");
+/**
+* The props name another variable than the one in state. Used by
+* Convex.EnvironmentVariable and Convex.DefaultEnvironmentVariable.
+*/
+var VariableIdentityChange = class extends Schema.TaggedError()("VariableIdentityChange", {
+	resourceType: Schema.String,
+	field: Schema.Literals([
+		"name",
+		"deployment",
+		"projectId",
+		"deploymentType"
+	]),
+	current: Schema.String,
+	requested: Schema.String
+}) {
+	get message() {
+		return `${this.resourceType} cannot change its ${this.field} from ${this.current} to ${this.requested}. Create a new resource with a new logical id for the new name or deployment, and remove this one.`;
+	}
+};
+/** Fails with {@link VariableIdentityChange} when the props name another variable than the one in state. */
+const checkIdentity$1 = (output, news) => output.name !== news.name ? Effect.fail(new VariableIdentityChange({
+	resourceType: EnvironmentVariable.Type,
+	field: "name",
+	current: output.name,
+	requested: news.name
+})) : output.deployment !== news.deployment ? Effect.fail(new VariableIdentityChange({
+	resourceType: EnvironmentVariable.Type,
+	field: "deployment",
+	current: output.deployment,
+	requested: news.deployment
+})) : Effect.void;
+/**
+* The deploy key for the variable in state: from the attributes, or, for
+* state from 0.1.x, from props that name the same deployment.
+*/
+const keyOf = (output, olds) => output.deployKey ?? (olds?.deployment === output.deployment ? olds.deployKey : void 0);
+const EnvironmentVariableProvider = () => Provider.effect(EnvironmentVariable, Effect.gen(function* () {
+	const api = yield* ManagementApi;
+	return {
+		diff: Effect.fn(function* ({ news, output }) {
+			if (!isResolved(news) || output === void 0) return void 0;
+			yield* checkIdentity$1(output, news);
+		}),
+		read: Effect.fn(function* ({ olds, output }) {
+			if (output !== void 0) {
+				const key = keyOf(output, olds);
+				if (key === void 0) return output;
+				return (yield* readVariable(api, output.deployment, key, output.name)) === void 0 ? void 0 : output;
+			}
+			const found = yield* readVariable(api, olds.deployment, olds.deployKey, olds.name);
+			return found === void 0 ? void 0 : Unowned({
+				...found,
+				deployKey: olds.deployKey
+			});
+		}),
+		reconcile: Effect.fn(function* ({ fqn, news, output }) {
+			if (output !== void 0) yield* checkIdentity$1(output, news);
+			const write = writeVariable(news.deployment, news.deployKey, news.name, news.value);
+			if (output !== void 0 || (yield* shouldAdopt(fqn))) yield* retryIdempotentWrite(write);
+			else yield* retryIdempotentWrite(Effect.gen(function* () {
+				if ((yield* readVariable(api, news.deployment, news.deployKey, news.name)) !== void 0) return yield* new OwnedBySomeoneElse({
+					message: `Environment variable ${news.name} already exists on deployment ${news.deployment}. Re-run with --adopt to take it over and overwrite its value, or use a different name.`,
+					resourceType: EnvironmentVariable.Type,
+					physicalName: news.name
+				});
+				yield* write;
+			}));
+			return {
+				deployment: news.deployment,
+				name: news.name,
+				deployKey: news.deployKey
+			};
+		}),
+		delete: Effect.fn(function* ({ olds, output }) {
+			const key = keyOf(output, olds);
+			if (key === void 0) {
+				yield* Effect.logWarning(`Environment variable ${output.name} on deployment ${output.deployment} stays: Alchemy has no deploy key for that deployment. Remove it in the Convex dashboard.`);
+				return;
+			}
+			yield* absentAsUndefined(updateVariable(output.deployment, key, output.name, null));
+		})
+	};
+}));
+//#endregion
+//#region src/DefaultEnvironmentVariable.ts
+/**
+* Attributes when the listing has `name` for `deploymentType`. An unfiltered
+* listing merges the deployment types that share one value into one row, so
+* the match checks membership in `deploymentTypes`.
+*/
+const findDefault = (list, projectId, name, deploymentType) => list.items.some((item) => item.name === name && item.deploymentTypes.includes(deploymentType)) ? {
+	projectId,
+	name,
+	deploymentType
+} : void 0;
+/**
+* Lists the defaults named `name` for `deploymentType`. Convex filters on
+* both, so the listing has at most one row and needs no pagination.
+*/
+const listDefaults = (api, projectId, name, deploymentType) => api.request("list default environment variables", (client) => client.GET("/projects/{project_id}/list_default_environment_variables", { params: {
+	path: { project_id: projectId },
+	query: {
+		name,
+		deploymentType
+	}
+} })).pipe(Effect.map((body) => Schema.decodeUnknownSync(DefaultEnvironmentVariableList)(body)));
+/** One attempt to set one default, or to remove it when `value` is null. */
+const writeDefault = (api, projectId, name, deploymentType, value) => api.requestVoid("update default environment variables", (client) => client.POST("/projects/{project_id}/update_default_environment_variables", {
+	params: { path: { project_id: projectId } },
+	body: { changes: [{
+		name,
+		deploymentType,
+		value: Redacted.isRedacted(value) ? Redacted.value(value) : value
+	}] }
+}));
+/**
+* Sets one default, or removes it when `value` is null. Convex answers 200
+* with an empty body, so this reads no response data. The call sets a value,
+* so it runs again after a write conflict or a 5xx answer, for example when
+* another resource writes a default of the same project at the same time.
+*/
+const updateDefault = (api, projectId, name, deploymentType, value) => retryIdempotentWrite(writeDefault(api, projectId, name, deploymentType, value));
+/** The default's identity, or undefined when the default or the project is absent. */
+const readDefault = (api, projectId, name, deploymentType) => absentAsUndefined(listDefaults(api, projectId, name, deploymentType)).pipe(Effect.map((list) => list === void 0 ? void 0 : findDefault(list, projectId, name, deploymentType)));
+/**
+* GET /projects/{project_id}/list_default_environment_variables. Only the
+* fields the provider uses: the row's `value` is the secret in plain text.
+*/
+const DefaultEnvironmentVariableList = Schema.Struct({ items: Schema.Array(Schema.Struct({
+	name: Schema.String,
+	deploymentTypes: Schema.Array(Schema.String)
+})) });
+const DefaultEnvironmentVariable = Resource("Convex.DefaultEnvironmentVariable");
+/** Fails with VariableIdentityChange when the props name another default than the one in state. */
+const checkIdentity = (output, news) => {
+	const changed = output.projectId !== news.projectId ? {
+		field: "projectId",
+		current: `${output.projectId}`,
+		requested: `${news.projectId}`
+	} : output.name !== news.name ? {
+		field: "name",
+		current: output.name,
+		requested: news.name
+	} : output.deploymentType !== news.deploymentType ? {
+		field: "deploymentType",
+		current: output.deploymentType,
+		requested: news.deploymentType
+	} : void 0;
+	return changed === void 0 ? Effect.void : Effect.fail(new VariableIdentityChange({
+		resourceType: DefaultEnvironmentVariable.Type,
+		...changed
+	}));
+};
+const DefaultEnvironmentVariableProvider = () => Provider.effect(DefaultEnvironmentVariable, Effect.gen(function* () {
+	const api = yield* ManagementApi;
+	return {
+		diff: Effect.fn(function* ({ news, output }) {
+			if (!isResolved(news) || output === void 0) return void 0;
+			yield* checkIdentity(output, news);
+		}),
+		read: Effect.fn(function* ({ olds, output }) {
+			const at = output ?? olds;
+			const found = yield* readDefault(api, at.projectId, at.name, at.deploymentType);
+			if (found === void 0) return void 0;
+			return output ?? Unowned(found);
+		}),
+		reconcile: Effect.fn(function* ({ fqn, news, output }) {
+			if (output !== void 0) yield* checkIdentity(output, news);
+			const write = writeDefault(api, news.projectId, news.name, news.deploymentType, news.value);
+			if (output !== void 0 || (yield* shouldAdopt(fqn))) yield* retryIdempotentWrite(write);
+			else yield* retryIdempotentWrite(Effect.gen(function* () {
+				if ((yield* readDefault(api, news.projectId, news.name, news.deploymentType)) !== void 0) return yield* new OwnedBySomeoneElse({
+					message: `Project ${news.projectId} already has a ${news.deploymentType} default environment variable ${news.name}. Re-run with --adopt to take it over and overwrite its value, or use a different name.`,
+					resourceType: DefaultEnvironmentVariable.Type,
+					physicalName: news.name
+				});
+				yield* write;
+			}));
+			return {
+				projectId: news.projectId,
+				name: news.name,
+				deploymentType: news.deploymentType
+			};
+		}),
+		delete: Effect.fn(function* ({ output }) {
+			yield* absentAsUndefined(updateDefault(api, output.projectId, output.name, output.deploymentType, null));
+		})
+	};
+}));
+//#endregion
+//#region src/Deploy.ts
+const Deploy = Resource("Convex.Deploy");
+/**
+* The CLI prints this line with `logFinishedStep` after the push succeeds, to
+* stderr (convex 1.45 `cli/lib/deploy2.js` for existing deployments,
+* `cli/deploy.js` for preview deployments). The host is
+* `<deployment>.convex.cloud` or `<deployment>.<region>.convex.cloud`.
+*/
+const DEPLOYED_LINE = /Deployed Convex functions to (https:\/\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)?\.convex\.cloud)\/?(?=\s|$)/m;
+/** Reads the deployment URL from `convex deploy` output. ANSI escape codes are removed first. */
+const parseDeployOutput = (text) => {
+	const match = DEPLOYED_LINE.exec(stripVTControlCharacters(text));
+	const url = match?.[1];
+	const deploymentName = match?.[2];
+	return url === void 0 || deploymentName === void 0 ? void 0 : {
+		url,
+		deploymentName
+	};
+};
+/** The `convex deploy` argv, starting with `npx`. */
+const deployArgs = (props) => [
+	"npx",
+	"convex",
+	"deploy",
+	...props.previewName === void 0 ? [] : ["--preview-name", props.previewName],
+	...props.previewCreate === void 0 ? [] : ["--preview-create", props.previewCreate],
+	...props.previewRun === void 0 ? [] : ["--preview-run", props.previewRun],
+	...props.extraArgs ?? []
+];
+/** A `convex deploy` argument contains whitespace, which Alchemy's command runner splits on. */
+var DeployArgumentError = class extends Schema.TaggedError()("DeployArgumentError", { argument: Schema.String }) {
+	get message() {
+		return `Convex.Deploy argument "${this.argument}" contains whitespace, and Alchemy splits the command on whitespace. Use the --flag=value form, such as --typecheck=disable, and names without spaces.`;
+	}
+};
+/** `npx convex deploy` exited 0 but did not print the deployment URL. */
+var DeployOutputError = class extends Schema.TaggedError()("DeployOutputError", { outputTail: Schema.String }) {
+	get message() {
+		return `npx convex deploy exited 0 but printed no "Deployed Convex functions to <url>" line, so Convex.Deploy has no deployment URL. Remove --dry-run from extraArgs if it is there, and read the CLI output. Last output:\n${this.outputTail}`;
+	}
+};
+const DeployProvider = () => Provider.effect(Deploy, Effect.gen(function* () {
+	const { run } = yield* CommandExecutor;
+	const hashOf = (props) => props.memo === false ? Effect.succeed(void 0) : hashDirectory({
+		...props.cwd === void 0 ? {} : { cwd: props.cwd },
+		memo: props.memo === true || props.memo === void 0 ? {} : props.memo
+	});
+	return {
+		diff: Effect.fn(function* ({ olds, news, output }) {
+			if (!isResolved(news)) return void 0;
+			if (news.previewName !== void 0 || news.previewCreate !== void 0 || output === void 0 || output.hash === void 0 || havePropsChanged(olds, news)) return { action: "update" };
+			return { action: (yield* hashOf(news)) === output.hash ? "noop" : "update" };
+		}),
+		reconcile: Effect.fn(function* ({ news, session }) {
+			const args = deployArgs(news);
+			const spaced = args.find((arg) => /\s/.test(arg));
+			if (spaced !== void 0) return yield* new DeployArgumentError({ argument: spaced });
+			const { stdout, stderr } = yield* run({
+				command: args.join(" "),
+				...news.cwd === void 0 ? {} : { cwd: news.cwd },
+				...news.timeout === void 0 ? {} : { timeout: news.timeout },
+				env: {
+					...news.env,
+					CONVEX_DEPLOY_KEY: news.deployKey
+				}
+			}, session);
+			const output = `${stdout}\n${stderr}`;
+			const deployed = parseDeployOutput(output);
+			if (deployed === void 0) return yield* new DeployOutputError({ outputTail: stripVTControlCharacters(output).split(/\r?\n|\r/).filter((line) => line.trim() !== "").slice(-20).join("\n") });
+			return {
+				...deployed,
+				hash: yield* hashOf(news)
+			};
+		}),
+		delete: () => Effect.void
+	};
+}));
+//#endregion
+//#region src/DeployKey.ts
+/**
+* True when `listedName` is how Convex lists a key created as `name`: the
+* requested name itself, or the requested name, a space, and one
+* parenthesized suffix without spaces. The suffix check keeps `my-key` from
+* matching a key created as `my-key (old)`.
+*/
+const isListedAs = (listedName, name) => {
+	const prefix = `${name} (`;
+	return listedName === name || listedName.startsWith(prefix) && /^[^\s()]+\)$/.test(listedName.slice(prefix.length));
+};
+/**
+* True when the listing still has the key in state: by numeric id, or by
+* listed name for state written by 0.1.x, which has no id.
+*/
+const isKeyListed = (entries, key) => entries.some((entry) => key.keyId === void 0 ? entry.name === key.uniqueName : entry.id === key.keyId);
+/** The listed keys that Convex shows for a key created as `name`. */
+const keysListedAs = (entries, name) => entries.filter((entry) => isListedAs(entry.name, name));
+/**
+* The name that a resource instance requests: `name`, a dash, and the first
+* 12 hex characters of sha256("<fqn>:<instanceId>"). Two resources, or the
+* old and the new generation of one replaced resource, never request the
+* same name. Pattern from Confect `packages/alchemy/src/internal/ResourceIdentity.ts`
+* (https://github.com/rjdellecese/confect, ISC license).
+*/
+const requestedKeyName = (name, fqn, instanceId) => `${name}-${createHash("sha256").update(`${fqn}:${instanceId}`).digest("hex").slice(0, 12)}`;
+/** One row of list_deploy_keys and list_preview_deploy_keys. Only the fields the providers use. */
+const ListedKey = Schema.Struct({
+	id: Schema.Number,
+	name: Schema.String
+});
+/** GET /deployments/{deployment_name}/list_deploy_keys */
+const DeployKeyList = Schema.Array(ListedKey);
+/** POST /deployments/{deployment_name}/create_deploy_key */
+const CreatedDeployKey = Schema.Struct({ deployKey: Schema.String });
+/**
+* A key cannot be tied to one resource: before the create, listed keys
+* already have the requested name, or after the create, not exactly one has it.
+*/
+var DeployKeyRecoveryRequired = class extends Schema.TaggedError()("DeployKeyRecoveryRequired", {
+	/** Where the keys live, such as `deployment happy-otter-123` or `project 3145389`. */
+	target: Schema.String,
+	/** The requested name. */
+	name: Schema.String,
+	/** The listed keys with the requested name. */
+	keys: Schema.Array(ListedKey),
+	/** True when this run created a key before the listing check failed. */
+	afterCreate: Schema.Boolean
+}) {
+	get message() {
+		const listed = this.keys.length === 0 ? "no key" : this.keys.map((key) => `"${key.name}" (id ${key.id})`).join(", ");
+		return this.afterCreate ? `Convex created deploy key "${this.name}" on ${this.target}, but the listing shows ${listed} with that name, not exactly one, so this resource cannot track the new key. Alchemy does not revoke it. Delete the keys with that name in the Convex dashboard, then run the deploy again.` : `${this.target} already lists ${listed} with the name "${this.name}", but Alchemy state has no such key. An interrupted run probably created it, and its secret is lost. Delete these keys in the Convex dashboard, then run the deploy again.`;
+	}
+};
+/**
+* Convex returned the Management API credential itself as the new key. This
+* happens with an OAuth token: Convex creates no key. A delete of the
+* returned secret would revoke the credential, so the resource does not keep it.
+*/
+var DeployKeyIsCredential = class extends Schema.TaggedError()("DeployKeyIsCredential", {
+	target: Schema.String,
+	name: Schema.String
+}) {
+	get message() {
+		return `Convex returned the Management API credential itself as deploy key "${this.name}" on ${this.target}. With an OAuth token, Convex creates no new key, and deleting the returned key would revoke the OAuth token. Alchemy does not keep it. Use a team access token in CONVEX_ACCESS_TOKEN, or the Convex CLI login.`;
+	}
+};
+/**
+* Creates a key named `name` and ties it to the caller. Fails before the
+* create when keys with that name already exist. After the create, fails
+* when the secret is the Management API credential itself, or when the
+* listing does not show exactly one key with that name. It never revokes a
+* key: the returned secret can be a shared credential.
+*/
+const createTrackedKey = (options) => Effect.gen(function* () {
+	const { target, name } = options;
+	const existing = keysListedAs(yield* options.list, name);
+	if (existing.length > 0) return yield* new DeployKeyRecoveryRequired({
+		target,
+		name,
+		keys: existing,
+		afterCreate: false
+	});
+	const secret = yield* options.create;
+	if (yield* options.isCredentialToken(secret)) return yield* new DeployKeyIsCredential({
+		target,
+		name
+	});
+	const listed = keysListedAs(yield* options.list, name);
+	const [only] = listed;
+	if (only === void 0 || listed.length !== 1) return yield* new DeployKeyRecoveryRequired({
+		target,
+		name,
+		keys: listed,
+		afterCreate: true
+	});
+	return {
+		keyId: only.id,
+		uniqueName: only.name,
+		secret: Redacted.make(secret)
+	};
+});
+/**
+* The secret to send to a delete call, or undefined when a delete is not
+* safe. Only a key with a `keyId` in state is known to be a new key that
+* this resource owns: createTrackedKey found exactly one new listed key, and
+* the secret was not the credential. State from 0.1.x has no `keyId`, and its
+* secret can be an OAuth token that Convex returned as a key, so a delete
+* could revoke that OAuth token. Such a key stays, and a warning names it.
+*/
+const secretToDelete = (key, label) => Effect.gen(function* () {
+	if (key.keyId === void 0 || !Redacted.isRedacted(key.secret)) {
+		yield* Effect.logWarning(`${label} has no verified key id and secret in state (state from 0.1.x, for example), so Alchemy does not delete it. Delete it in the Convex dashboard.`);
+		return;
+	}
+	return Redacted.value(key.secret);
+});
+const DeployKey = Resource("Convex.DeployKey");
+const DeployKeyProvider = () => Provider.effect(DeployKey, Effect.gen(function* () {
+	const api = yield* ManagementApi;
+	const listKeys = (deployment) => api.request("list deploy keys", (client) => client.GET("/deployments/{deployment_name}/list_deploy_keys", { params: { path: { deployment_name: deployment } } })).pipe(Effect.map((body) => Schema.decodeUnknownSync(DeployKeyList)(body)));
+	/**
+	* `id` is the secret: Convex accepts it, and it matches only the key
+	* that this resource created. A second delete answers 404.
+	*/
+	const deleteKey = (deployment, secret) => retryIdempotentWrite(api.requestVoid("delete deploy key", (client) => client.POST("/deployments/{deployment_name}/delete_deploy_key", {
+		params: { path: { deployment_name: deployment } },
+		body: { id: secret }
+	})));
+	return {
+		stables: ["uniqueName", "deployment"],
+		diff: ({ olds, news, output }) => {
+			if (!isResolved(news)) return Effect.succeed(void 0);
+			return Effect.succeed(output !== void 0 && output.deployKey === void 0 || havePropsChanged(olds, news) ? { action: "replace" } : { action: "noop" });
+		},
+		read: Effect.fn(function* ({ output }) {
+			if (output === void 0) return void 0;
+			const entries = yield* absentAsUndefined(listKeys(output.deployment));
+			return entries !== void 0 && isKeyListed(entries, output) ? output : void 0;
+		}),
+		reconcile: Effect.fn(function* ({ fqn, instanceId, news, output }) {
+			if (output !== void 0) {
+				if (isKeyListed(yield* listKeys(news.deployment), output)) return output;
+			}
+			const name = requestedKeyName(news.name, fqn, instanceId);
+			const { keyId, uniqueName, secret } = yield* createTrackedKey({
+				target: `deployment ${news.deployment}`,
+				name,
+				list: listKeys(news.deployment),
+				create: api.request("create deploy key", (client) => client.POST("/deployments/{deployment_name}/create_deploy_key", {
+					params: { path: { deployment_name: news.deployment } },
+					body: {
+						name,
+						...news.allowedActions === void 0 ? {} : { allowedActions: [...news.allowedActions] }
+					}
+				})).pipe(Effect.map((body) => Schema.decodeUnknownSync(CreatedDeployKey)(body).deployKey)),
+				isCredentialToken: api.isCredentialToken
+			});
+			return {
+				uniqueName,
+				keyId,
+				deployment: news.deployment,
+				deployKey: secret
+			};
+		}),
+		delete: Effect.fn(function* ({ output }) {
+			const secret = yield* secretToDelete({
+				keyId: output.keyId,
+				secret: output.deployKey
+			}, `Convex.DeployKey "${output.uniqueName}" on ${output.deployment}`);
+			if (secret === void 0) return;
+			yield* absentAsUndefined(deleteKey(output.deployment, secret));
+		})
+	};
+}));
+//#endregion
+//#region src/PreviewDeployKey.ts
+/** GET /projects/{project_id}/list_preview_deploy_keys */
+const PreviewDeployKeyList = Schema.Struct({ items: Schema.Array(ListedKey) });
+/** POST /projects/{project_id}/create_preview_deploy_key */
+const CreatedPreviewDeployKey = Schema.Struct({ previewDeployKey: Schema.String });
+const PreviewDeployKey = Resource("Convex.PreviewDeployKey");
+const PreviewDeployKeyProvider = () => Provider.effect(PreviewDeployKey, Effect.gen(function* () {
+	const api = yield* ManagementApi;
+	const listKeys = (projectId) => api.request("list preview deploy keys", (client) => client.GET("/projects/{project_id}/list_preview_deploy_keys", { params: { path: { project_id: projectId } } })).pipe(Effect.map((body) => Schema.decodeUnknownSync(PreviewDeployKeyList)(body).items));
+	/**
+	* `id` is the secret: Convex accepts it, and it matches only the key
+	* that this resource created. A second delete answers 404.
+	*/
+	const deleteKey = (projectId, secret) => retryIdempotentWrite(api.requestVoid("delete preview deploy key", (client) => client.POST("/projects/{project_id}/delete_preview_deploy_key", {
+		params: { path: { project_id: projectId } },
+		body: { id: secret }
+	})));
+	return {
+		stables: ["uniqueName", "projectId"],
+		diff: ({ olds, news, output }) => {
+			if (!isResolved(news)) return Effect.succeed(void 0);
+			return Effect.succeed(output !== void 0 && output.previewDeployKey === void 0 || havePropsChanged(olds, news) ? { action: "replace" } : { action: "noop" });
+		},
+		read: Effect.fn(function* ({ output }) {
+			if (output === void 0) return void 0;
+			const entries = yield* absentAsUndefined(listKeys(output.projectId));
+			return entries !== void 0 && isKeyListed(entries, output) ? output : void 0;
+		}),
+		reconcile: Effect.fn(function* ({ fqn, instanceId, news, output }) {
+			if (output !== void 0) {
+				if (isKeyListed(yield* listKeys(news.projectId), output)) return output;
+			}
+			const name = requestedKeyName(news.name, fqn, instanceId);
+			const { keyId, uniqueName, secret } = yield* createTrackedKey({
+				target: `project ${news.projectId}`,
+				name,
+				list: listKeys(news.projectId),
+				create: api.request("create preview deploy key", (client) => client.POST("/projects/{project_id}/create_preview_deploy_key", {
+					params: { path: { project_id: news.projectId } },
+					body: { name }
+				})).pipe(Effect.map((body) => Schema.decodeUnknownSync(CreatedPreviewDeployKey)(body).previewDeployKey)),
+				isCredentialToken: api.isCredentialToken
+			});
+			return {
+				uniqueName,
+				keyId,
+				projectId: news.projectId,
+				previewDeployKey: secret
+			};
+		}),
+		delete: Effect.fn(function* ({ output }) {
+			const secret = yield* secretToDelete({
+				keyId: output.keyId,
+				secret: output.previewDeployKey
+			}, `Convex.PreviewDeployKey "${output.uniqueName}" in project ${output.projectId}`);
+			if (secret === void 0) return;
+			yield* absentAsUndefined(deleteKey(output.projectId, secret));
+		})
+	};
+}));
+//#endregion
+//#region src/Project.ts
+const Project = Resource("Convex.Project", { defaultRemovalPolicy: "retain" });
+/** The props change the team of an existing project. Convex cannot move a project. */
+var ProjectTeamChange = class extends Schema.TaggedError()("ProjectTeamChange", {
+	projectId: Schema.Number,
+	teamId: Schema.Number,
+	requestedTeamId: Schema.Number
+}) {
+	get message() {
+		return `Convex.Project cannot move project ${this.projectId} from team ${this.teamId} to team ${this.requestedTeamId}. Set team back to ${this.teamId}. To use the other team, create a new resource with a new logical id and move the data yourself.`;
+	}
+};
+/**
+* The props change `deploymentType` or `deploymentRegion` of an existing
+* project. Convex uses them only when it creates the project.
+*/
+var ProjectDeploymentChange = class extends Schema.TaggedError()("ProjectDeploymentChange", {
+	projectId: Schema.Number,
+	field: Schema.Literals(["deploymentType", "deploymentRegion"]),
+	current: Schema.UndefinedOr(Schema.String),
+	requested: Schema.UndefinedOr(Schema.String)
+}) {
+	get message() {
+		const show = (value) => value === void 0 ? "(not set)" : value;
+		return `Convex.Project cannot change ${this.field} of project ${this.projectId} from ${show(this.current)} to ${show(this.requested)}: Convex uses it only when it creates a project. Set ${this.field} back to ${show(this.current)}. For a new deployment, create a new resource with a new logical id and move the data yourself.`;
+	}
+};
+/** More than one project in the team has the name, so the lookup cannot choose one. */
+var AmbiguousProject = class extends Schema.TaggedError()("AmbiguousProject", {
+	teamId: Schema.Number,
+	name: Schema.String,
+	projectIds: Schema.Array(Schema.Number)
+}) {
+	get message() {
+		return `Team ${this.teamId} has ${this.projectIds.length} projects named "${this.name}" (ids ${this.projectIds.join(", ")}). Convex.Project does not choose one. Rename the projects in the Convex dashboard so that only one has this name, or use a different name.`;
+	}
+};
+/** Convex answered a create call but then did not return the project. */
+var CreatedProjectNotFound = class extends Schema.TaggedError()("CreatedProjectNotFound", { projectId: Schema.Number }) {
+	get message() {
+		return `Convex created project ${this.projectId} but GET /projects/${this.projectId} did not return it. Run the deploy again with --adopt to take over project ${this.projectId}.`;
+	}
+};
+/** Fields of GET /projects/{id}, PATCH /projects/{id}, and GET /teams/{team}/projects rows that the provider uses. */
+const ProjectDetails = Schema.Struct({
+	id: Schema.Number,
+	name: Schema.String,
+	slug: Schema.String,
+	teamId: Schema.Number,
+	prodDeploymentName: Schema.NullOr(Schema.String)
+});
+/** GET /teams/{team_id}/projects: one page of projects. */
+const ProjectPage = Schema.Struct({
+	items: Schema.Array(ProjectDetails),
+	pagination: Schema.Struct({
+		hasMore: Schema.Boolean,
+		nextCursor: Schema.optionalKey(Schema.NullOr(Schema.String))
+	})
+});
+/** POST /teams/{team_id}/create_project. Only the id: everything else comes from GET /projects/{id}. */
+const CreatedProject = Schema.Struct({ projectId: Schema.Number });
+const DeploymentRow = Schema.Struct({
+	name: Schema.String,
+	deploymentType: Schema.String,
+	isDefault: Schema.Boolean,
+	deploymentUrl: Schema.String
+});
+const DeploymentRows = Schema.Array(DeploymentRow);
+/**
+* Fails with {@link ProjectDeploymentChange} when a create-time prop
+* changed. An omitted `deploymentType` means `prod`.
+*/
+const checkCreateTimeProps = (projectId, olds, news) => {
+	const oldType = olds.deploymentType ?? "prod";
+	const newType = news.deploymentType ?? "prod";
+	if (oldType !== newType) return Effect.fail(new ProjectDeploymentChange({
+		projectId,
+		field: "deploymentType",
+		current: oldType,
+		requested: newType
+	}));
+	if (olds.deploymentRegion !== news.deploymentRegion) return Effect.fail(new ProjectDeploymentChange({
+		projectId,
+		field: "deploymentRegion",
+		current: olds.deploymentRegion,
+		requested: news.deploymentRegion
+	}));
+	return Effect.void;
+};
+const ProjectProvider = () => Provider.effect(Project, Effect.gen(function* () {
+	const api = yield* ManagementApi;
+	const prodDeployment = (projectId) => api.request("list deployments", (client) => client.GET("/projects/{project_id}/list_deployments", { params: { path: { project_id: projectId } } })).pipe(Effect.map((rows) => Schema.decodeUnknownSync(DeploymentRows)(rows).find((row) => row.deploymentType === "prod" && row.isDefault)));
+	const attributesOf = (details) => prodDeployment(details.id).pipe(Effect.map((prod) => ({
+		projectId: details.id,
+		slug: details.slug,
+		name: details.name,
+		teamId: details.teamId,
+		prodDeploymentName: prod?.name ?? details.prodDeploymentName ?? void 0,
+		prodDeploymentUrl: prod?.deploymentUrl
+	})));
+	const getById = (projectId) => absentAsUndefined(api.request("get project", (client) => client.GET("/projects/{project_id}", { params: { path: { project_id: projectId } } }))).pipe(Effect.map((body) => body === void 0 ? void 0 : Schema.decodeUnknownSync(ProjectDetails)(body)));
+	/**
+	* The one project in the team with exactly this name, or undefined.
+	* Reads every page. `q` narrows the listing on the server, and the
+	* exact match here decides. Pattern from Confect
+	* `packages/alchemy/src/ConvexClient.ts` and `Project.ts`
+	* (https://github.com/rjdellecese/confect, ISC license).
+	*/
+	const findByName = (teamId, name) => Effect.gen(function* () {
+		const matches = [];
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor;
+		while (true) {
+			const body = yield* api.request("list projects", (client) => client.GET("/teams/{team_id}/projects", { params: {
+				path: { team_id: teamId },
+				query: {
+					q: name,
+					...cursor === void 0 ? {} : { cursor }
+				}
+			} }));
+			const page = Schema.decodeUnknownSync(ProjectPage)(body);
+			matches.push(...page.items.filter((row) => row.name === name));
+			if (!page.pagination.hasMore) break;
+			const next = page.pagination.nextCursor;
+			if (next === void 0 || next === null || seenCursors.has(next)) return yield* new ConvexApiError({
+				operation: "list projects",
+				status: 0,
+				code: "InvalidPagination",
+				message: `The project listing of team ${teamId} reports more pages but gives no new cursor. Convex.Project stops so that it does not miss a project named "${name}".`
+			});
+			seenCursors.add(next);
+			cursor = next;
+		}
+		if (matches.length > 1) return yield* new AmbiguousProject({
+			teamId,
+			name,
+			projectIds: matches.map((row) => row.id)
+		});
+		return matches[0];
+	});
+	/**
+	* Brings an existing project to the desired name. The team cannot
+	* change, so a project in another team fails.
+	*/
+	const converge = (details, teamId, name) => Effect.gen(function* () {
+		if (details.teamId !== teamId) return yield* new ProjectTeamChange({
+			projectId: details.id,
+			teamId: details.teamId,
+			requestedTeamId: teamId
+		});
+		if (details.name === name) return yield* attributesOf(details);
+		const updated = yield* api.request("update project", (client) => client.PATCH("/projects/{project_id}", {
+			params: { path: { project_id: details.id } },
+			body: { name }
+		}));
+		return yield* attributesOf(Schema.decodeUnknownSync(ProjectDetails)(updated));
+	});
+	return {
+		stables: [
+			"projectId",
+			"slug",
+			"teamId"
+		],
+		diff: Effect.fn(function* ({ olds, news, output }) {
+			if (!isResolved(news)) return void 0;
+			if (output === void 0) return void 0;
+			if (olds.team !== news.team) {
+				const requestedTeamId = yield* api.resolveTeamId(news.team);
+				if (requestedTeamId !== output.teamId) return yield* new ProjectTeamChange({
+					projectId: output.projectId,
+					teamId: output.teamId,
+					requestedTeamId
+				});
+			}
+			return olds.name === news.name ? void 0 : { action: "update" };
+		}),
+		read: Effect.fn(function* ({ olds, output }) {
+			if (output !== void 0) {
+				const details = yield* getById(output.projectId);
+				return details === void 0 ? void 0 : yield* attributesOf(details);
+			}
+			const existing = yield* findByName(yield* api.resolveTeamId(olds.team), olds.name);
+			return existing === void 0 ? void 0 : Unowned(yield* attributesOf(existing));
+		}),
+		reconcile: Effect.fn(function* ({ fqn, olds, news, output }) {
+			const teamId = yield* api.resolveTeamId(news.team);
+			if (output !== void 0) {
+				if (olds !== void 0) yield* checkCreateTimeProps(output.projectId, olds, news);
+				if (output.teamId !== teamId) return yield* new ProjectTeamChange({
+					projectId: output.projectId,
+					teamId: output.teamId,
+					requestedTeamId: teamId
+				});
+				const details = yield* getById(output.projectId);
+				if (details !== void 0) return yield* converge(details, teamId, news.name);
+			} else {
+				const existing = yield* findByName(teamId, news.name);
+				if (existing !== void 0) {
+					if (!(yield* shouldAdopt(fqn))) return yield* new OwnedBySomeoneElse({
+						message: `Convex project ${existing.id} in team ${teamId} already has the name "${news.name}". Re-run with --adopt to take it over, or use a different name.`,
+						resourceType: Project.Type,
+						physicalName: news.name
+					});
+					return yield* converge(existing, teamId, news.name);
+				}
+			}
+			const created = yield* api.request("create project", (client) => client.POST("/teams/{team_id}/create_project", {
+				params: { path: { team_id: teamId } },
+				body: {
+					projectName: news.name,
+					deploymentType: news.deploymentType ?? "prod",
+					...news.deploymentRegion === void 0 ? {} : { deploymentRegion: news.deploymentRegion }
+				}
+			}));
+			const { projectId } = Schema.decodeUnknownSync(CreatedProject)(created);
+			const details = yield* getById(projectId);
+			if (details === void 0) return yield* new CreatedProjectNotFound({ projectId });
+			return yield* converge(details, teamId, news.name);
+		}),
+		delete: Effect.fn(function* ({ output }) {
+			yield* absentAsUndefined(api.requestVoid("delete project", (client) => client.POST("/projects/{project_id}/delete", { params: { path: { project_id: output.projectId } } })));
+		})
+	};
+}));
+//#endregion
+//#region src/Providers.ts
+var Providers = class extends Provider.ProviderCollection()("Convex") {};
+/**
+* All Convex resource providers. Pass a credentials layer to override the
+* default lookup (`CONVEX_ACCESS_TOKEN`, then the Convex CLI login).
+*/
+const providers = (credentials = fromConfig()) => Layer.effect(Providers, Provider.collection([
+	Project,
+	DeployKey,
+	PreviewDeployKey,
+	EnvironmentVariable,
+	DefaultEnvironmentVariable,
+	Deploy
+])).pipe(Layer.provide(Layer.mergeAll(ProjectProvider(), DeployKeyProvider(), PreviewDeployKeyProvider(), EnvironmentVariableProvider(), DefaultEnvironmentVariableProvider(), DeployProvider())), Layer.provide(ManagementApiLive()), Layer.provide(credentials), Layer.provide(CommandExecutorLive()), Layer.orDie);
+//#endregion
+export { ACCESS_TOKEN_ENV, AmbiguousProject, ConvexApiError, CreatedProjectNotFound, Credentials, CredentialsError, DefaultEnvironmentVariable, Deploy, DeployArgumentError, DeployKey, DeployKeyIsCredential, DeployKeyRecoveryRequired, DeployOutputError, EnvironmentVariable, ManagementApi, PreviewDeployKey, Project, ProjectDeploymentChange, ProjectTeamChange, Providers, VariableIdentityChange, deployArgs, fromConfig, fromToken, parseDeployOutput, providers };
+
 //# sourceMappingURL=index.js.map