domainkit 0.2.2 → 0.3.0

package/dist/promise.mjs

@@ -0,0 +1,636 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { $ as RemoveDomainResult, A as make$7, C as integrationFlow$1, Ct as encode$1, D as tokenMethod$3, E as tokenConnectionMethod$3, F as subjectResolver$1, G as secret_exports, H as authorize$2, I as tokenConnectionMethod$2, J as decode$5, K as Method$2, L as tokenMethod$2, M as manifest$2, N as oauthFlow$1, P as oauthMethod$1, Q as Method$1, R as tokenValidator$1, S as exchangeCode$1, St as decode$6, T as manifest$3, Tt as version, V as make$6, W as selection_exports, X as diagnostic_exports, Z as Error, _ as toAsync$2, _t as CapabilityEvidence, a as Result, at as AuthorizationError, bt as Schema$3, c as Observation, ct as assertGrant, d as defaultMake$1, dt as decode$4, et as StartResult, f as make$8, ft as encode, gt as Capability, h as toAsync$4, i as PublicDnsObservation, it as start$1, l as Policy, mt as removeDomain$1, n as ProviderObservation, nt as extend$1, o as observe$1, ot as Grant, pt as includeDomains, q as Schema$2, r as PublicDns$1, rt as removeDomain$2, st as Schema$1, t as Provider$1, tt as complete$1, u as Service, ut as coversDomain, vt as Evidence, w as integrationMethod$1, wt as provider_context_exports, y as toAsync$3, yt as EvidenceSchema } from "./verify-B00c81-n.mjs";
+import { $ as Txt, A as decodeReceipt$1, D as Receipt, E as Operation, F as webCryptoLayer, G as Cname, H as A, I as Error$2, J as Observed, K as Mx, L as Service$2, M as encodeReceipt, O as Schema$6, Q as Srv, S as create$3, T as Authorization, U as Aaaa, W as Caa, X as RequirementMetadata, Y as Opaque, Z as Schema$4, a as Authorization$1, at as parse, b as apply$3, bt as invalid_input_exports, c as PartialError, ct as make$9, d as apply$2, dt as zones_exports, et as Type, f as authorize$3, ft as Error$1, g as CreateResult, ht as Schema$5, it as equals, j as encode$2, k as decode$7, l as Plan, o as Error$3, ot as Candidate, p as create$2, pt as Service$1, q as Ns, s as Operation$1, st as Service$3, t as Error$4, tt as data, u as Receipt$1, vt as parse$1, w as renderManualInstructions$1, x as authorize$4, y as Target, z as layerFromAsync } from "./resolver-CvK7JoJM.mjs";
+import { Data, Effect, Layer } from "effect";
+//#region src/promise/authorization-lifecycle.ts
+var authorization_lifecycle_exports = /* @__PURE__ */ __exportAll({
+	Error: () => Error$1,
+	from: () => from,
+	layerFrom: () => layerFrom,
+	toAsync: () => toAsync$1
+});
+const failure = (operation, cause) => cause instanceof Error$1 ? cause : new Error$1({
+	category: "storage",
+	message: cause instanceof globalThis.Error ? cause.message : String(cause),
+	operation,
+	retry: "safe"
+});
+const layerFrom = (repository) => Layer.succeed(Service$1, {
+	bind: Effect.fn("AuthorizationLifecycleRepository.bind")((authorizationId, binding) => Effect.tryPromise({
+		try: () => repository.bind(authorizationId, binding),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.bind", cause)
+	})),
+	connect: Effect.fn("AuthorizationLifecycleRepository.connect")((aggregate) => Effect.tryPromise({
+		try: () => repository.connect(aggregate),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.connect", cause)
+	})),
+	detach: ({ connectionId, revoke }) => Effect.tryPromise({
+		try: () => repository.detach({
+			connectionId,
+			revoke: (aggregate) => Effect.runPromise(revoke(aggregate))
+		}),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.detach", cause)
+	}),
+	findByProviderAccount: Effect.fn("AuthorizationLifecycleRepository.findByProviderAccount")((providerId, providerAccountId) => Effect.tryPromise({
+		try: () => repository.findByProviderAccount(providerId, providerAccountId),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.findByProviderAccount", cause)
+	})),
+	get: Effect.fn("AuthorizationLifecycleRepository.get")((authorizationId) => Effect.tryPromise({
+		try: () => repository.get(authorizationId),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.get", cause)
+	})),
+	getByConnectionId: Effect.fn("AuthorizationLifecycleRepository.getByConnectionId")((connectionId) => Effect.tryPromise({
+		try: () => repository.getByConnectionId(connectionId),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.getByConnectionId", cause)
+	})),
+	modifyBinding: (connectionId, modify) => Effect.tryPromise({
+		try: () => repository.modifyBinding(connectionId, modify),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.modifyBinding", cause)
+	}),
+	promoteEvidence: Effect.fn("AuthorizationLifecycleRepository.promoteEvidence")((authorizationId, evidence) => Effect.tryPromise({
+		try: () => repository.promoteEvidence(authorizationId, evidence),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.promoteEvidence", cause)
+	})),
+	recover: ({ authorizationId, revoke }) => Effect.tryPromise({
+		try: () => repository.recover({
+			authorizationId,
+			revoke: (aggregate) => Effect.runPromise(revoke(aggregate))
+		}),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.recover", cause)
+	}),
+	rotate: Effect.fn("AuthorizationLifecycleRepository.rotate")((authorizationId, credential, expiresAt) => Effect.tryPromise({
+		try: () => repository.rotate(authorizationId, credential, expiresAt),
+		catch: (cause) => failure("AuthorizationLifecycleRepository.rotate", cause)
+	}))
+});
+const toAsync$1 = (repository) => ({
+	bind: (authorizationId, binding) => Effect.runPromise(repository.bind(authorizationId, binding)),
+	connect: (aggregate) => Effect.runPromise(repository.connect(aggregate)),
+	detach: ({ connectionId, revoke }) => Effect.runPromise(repository.detach({
+		connectionId,
+		revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate))
+	})),
+	findByProviderAccount: (providerId, providerAccountId) => Effect.runPromise(repository.findByProviderAccount(providerId, providerAccountId)),
+	get: (authorizationId) => Effect.runPromise(repository.get(authorizationId)),
+	getByConnectionId: (connectionId) => Effect.runPromise(repository.getByConnectionId(connectionId)),
+	modifyBinding: (connectionId, modify) => Effect.runPromise(repository.modifyBinding(connectionId, modify)),
+	promoteEvidence: (authorizationId, evidence) => Effect.runPromise(repository.promoteEvidence(authorizationId, evidence)),
+	recover: ({ authorizationId, revoke }) => Effect.runPromise(repository.recover({
+		authorizationId,
+		revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate))
+	})),
+	rotate: (authorizationId, credential, expiresAt) => Effect.runPromise(repository.rotate(authorizationId, credential, expiresAt))
+});
+const from = (repository) => repository;
+//#endregion
+//#region src/promise/connection.ts
+var connection_exports = /* @__PURE__ */ __exportAll({
+	AuthorizationError: () => AuthorizationError,
+	Error: () => Error,
+	Grant: () => Grant,
+	Method: () => Method,
+	RemoveDomainResult: () => RemoveDomainResult,
+	Schema: () => Schema$1,
+	StartResult: () => StartResult,
+	assertGrant: () => assertGrant,
+	complete: () => complete,
+	coversDomain: () => coversDomain,
+	decode: () => decode$3,
+	encode: () => encode,
+	extend: () => extend,
+	fromEffectFlow: () => fromEffectFlow,
+	fromEffectTokenMethod: () => fromEffectTokenMethod,
+	includeDomains: () => includeDomains,
+	removeDomain: () => removeDomain,
+	removeDomainFromGrant: () => removeDomain$1,
+	start: () => start,
+	toAsyncContinuations: () => toAsyncContinuations
+});
+function decode$3(input) {
+	return Effect.runPromise(decode$4(input));
+}
+const Method = Data.taggedEnum();
+const connectionFailure = (operation, cause) => cause instanceof Error ? cause : new Error({
+	category: "provider",
+	message: cause instanceof globalThis.Error ? cause.message : String(cause),
+	operation,
+	retry: "unknown"
+});
+const effectMethod = (method) => method._tag === "Interactive" ? Method$1.Interactive({
+	continuations: effectContinuations(method.continuations),
+	flow: effectFlow(method.flow),
+	...method.ttlMs === void 0 ? {} : { ttlMs: method.ttlMs }
+}) : Method$1.Token({
+	authenticate: (token) => Effect.tryPromise({
+		try: () => method.authenticate(token),
+		catch: (cause) => connectionFailure("Connection.start", cause)
+	}),
+	providerId: method.providerId,
+	requiredCapabilities: method.requiredCapabilities,
+	token: method.token
+});
+const effectContinuations = (store) => ({
+	consume: (id, now) => Effect.tryPromise({
+		try: () => store.consume(id, now),
+		catch: (cause) => connectionFailure("ConnectionContinuations.consume", cause)
+	}),
+	put: (continuation) => Effect.tryPromise({
+		try: () => store.put(continuation),
+		catch: (cause) => connectionFailure("ConnectionContinuations.put", cause)
+	})
+});
+const toAsyncContinuations = (store) => ({
+	consume: (id, now) => Effect.runPromise(store.consume(id, now)),
+	put: (continuation) => Effect.runPromise(store.put(continuation))
+});
+const effectFlow = (flow) => ({
+	complete: (payload, callbackUrl) => Effect.tryPromise({
+		try: () => flow.complete(payload, callbackUrl),
+		catch: (cause) => connectionFailure("Connection.complete", cause)
+	}),
+	method: flow.method,
+	providerId: flow.providerId,
+	requiredCapabilities: flow.requiredCapabilities,
+	start: (continuationId) => Effect.tryPromise({
+		try: () => flow.start(continuationId),
+		catch: (cause) => connectionFailure("Connection.start", cause)
+	})
+});
+/** Adapts an Effect-native provider flow to the Promise facade. */
+const fromEffectFlow = (flow) => ({
+	complete: (payload, callbackUrl) => Effect.runPromise(flow.complete(payload, callbackUrl)),
+	method: flow.method,
+	providerId: flow.providerId,
+	requiredCapabilities: flow.requiredCapabilities,
+	start: (continuationId) => Effect.runPromise(flow.start(continuationId).pipe(Effect.provide(webCryptoLayer)))
+});
+/** Adapts an Effect-native token method to the Promise facade. */
+function fromEffectTokenMethod(method) {
+	return Method.Token({
+		authenticate: (token) => Effect.runPromise(method.authenticate(token)),
+		providerId: method.providerId,
+		requiredCapabilities: method.requiredCapabilities,
+		token: method.token
+	});
+}
+async function start(input) {
+	return Effect.runPromise(start$1({
+		authorizedById: input.authorizedById,
+		grant: input.grant,
+		method: effectMethod(input.method),
+		ownerId: input.ownerId
+	}).pipe(Effect.provide(Layer.merge(layerFrom(input.repository), webCryptoLayer))));
+}
+async function complete(input) {
+	return Effect.runPromise(complete$1({
+		callbackUrl: input.callbackUrl,
+		continuationId: input.continuationId,
+		continuations: effectContinuations(input.continuations),
+		flow: effectFlow(input.flow)
+	}).pipe(Effect.provide(Layer.merge(layerFrom(input.repository), webCryptoLayer))));
+}
+/** Extends one owner binding without repeating provider authentication. */
+async function extend(input) {
+	return Effect.runPromise(extend$1({
+		connectionId: input.connectionId,
+		grant: input.grant,
+		ownerId: input.ownerId
+	}).pipe(Effect.provide(layerFrom(input.repository))));
+}
+/** Removes one domain from an owner binding without revoking provider authorization. */
+async function removeDomain(input) {
+	return Effect.runPromise(removeDomain$2({
+		connectionId: input.connectionId,
+		domain: input.domain,
+		ownerId: input.ownerId
+	}).pipe(Effect.provide(layerFrom(input.repository))));
+}
+//#endregion
+//#region src/promise/provider-auth.ts
+var provider_auth_exports = /* @__PURE__ */ __exportAll({
+	Method: () => Method$2,
+	Schema: () => Schema$2,
+	decode: () => decode$2
+});
+function decode$2(input) {
+	return Effect.runPromise(decode$5(input));
+}
+//#endregion
+//#region src/promise/provider-authorization.ts
+var provider_authorization_exports = /* @__PURE__ */ __exportAll({
+	Capability: () => Capability,
+	CapabilityEvidence: () => CapabilityEvidence,
+	Evidence: () => Evidence,
+	EvidenceSchema: () => EvidenceSchema,
+	Schema: () => Schema$3,
+	decode: () => decode$1,
+	encode: () => encode$1
+});
+function decode$1(input) {
+	return Effect.runPromise(decode$6(input));
+}
+//#endregion
+//#region src/promise/zone-discovery.ts
+var zone_discovery_exports = /* @__PURE__ */ __exportAll({
+	Candidate: () => Candidate,
+	discover: () => discover,
+	toEffectSource: () => toEffectSource
+});
+function discover(input) {
+	return Effect.runPromise(make$9(input.sources.map(toEffectSource)).discover(input.domain).pipe(Effect.map(projectOutcome)));
+}
+function toEffectSource(source) {
+	return {
+		listZones: (name) => Effect.tryPromise({
+			try: () => source.listZones(name),
+			catch: (cause) => new Error$2({
+				cause,
+				message: cause instanceof globalThis.Error ? cause.message : String(cause),
+				operation: "ZoneDiscovery.listZones",
+				providerId: source.provider.id,
+				reason: "transport"
+			})
+		}),
+		provider: Service$2.of({
+			id: source.provider.id,
+			createRecord: (zone, record) => Effect.tryPromise({
+				try: () => source.provider.createRecord(zone, record),
+				catch: (cause) => providerFailure(source.provider.id, "createRecord", cause)
+			}),
+			deleteRecord: (zone, providerRecordId) => Effect.tryPromise({
+				try: () => source.provider.deleteRecord(zone, providerRecordId),
+				catch: (cause) => providerFailure(source.provider.id, "deleteRecord", cause)
+			}),
+			getRecord: (zone, providerRecordId) => Effect.tryPromise({
+				try: () => source.provider.getRecord(zone, providerRecordId),
+				catch: (cause) => providerFailure(source.provider.id, "getRecord", cause)
+			}),
+			listRecords: (zone) => Effect.tryPromise({
+				try: () => source.provider.listRecords(zone),
+				catch: (cause) => providerFailure(source.provider.id, "listRecords", cause)
+			})
+		})
+	};
+}
+function projectOutcome(outcome) {
+	switch (outcome._tag) {
+		case "NotFound": return outcome;
+		case "Resolved": return {
+			_tag: "Resolved",
+			candidate: outcome.candidate
+		};
+		case "SelectionRequired": return outcome;
+	}
+}
+function providerFailure(providerId, operation, cause) {
+	return cause instanceof Error$2 ? cause : new Error$2({
+		cause,
+		message: cause instanceof globalThis.Error ? cause.message : String(cause),
+		operation,
+		providerId
+	});
+}
+//#endregion
+//#region src/promise/dns-record.ts
+var dns_record_exports = /* @__PURE__ */ __exportAll({
+	A: () => A,
+	Aaaa: () => Aaaa,
+	Caa: () => Caa,
+	Cname: () => Cname,
+	Mx: () => Mx,
+	Ns: () => Ns,
+	Observed: () => Observed,
+	Opaque: () => Opaque,
+	RequirementMetadata: () => RequirementMetadata,
+	Schema: () => Schema$4,
+	Srv: () => Srv,
+	Txt: () => Txt,
+	Type: () => Type,
+	data: () => data,
+	equals: () => equals,
+	parse: () => parse
+});
+//#endregion
+//#region src/promise/domain-name.ts
+var domain_name_exports = /* @__PURE__ */ __exportAll({
+	Schema: () => Schema$5,
+	parse: () => parse$1
+});
+//#endregion
+//#region src/promise/dns-plan.ts
+var dns_plan_exports = /* @__PURE__ */ __exportAll({
+	Authorization: () => Authorization,
+	Operation: () => Operation,
+	Receipt: () => Receipt,
+	Schema: () => Schema$6,
+	decode: () => decode,
+	decodeReceipt: () => decodeReceipt,
+	encode: () => encode$2,
+	encodeReceipt: () => encodeReceipt
+});
+function decode(input) {
+	return Effect.runPromise(decode$7(input));
+}
+function decodeReceipt(input) {
+	return Effect.runPromise(decodeReceipt$1(input));
+}
+//#endregion
+//#region src/promise/deletion.ts
+var deletion_exports = /* @__PURE__ */ __exportAll({
+	Authorization: () => Authorization$1,
+	Error: () => Error$3,
+	Operation: () => Operation$1,
+	PartialError: () => PartialError,
+	Plan: () => Plan,
+	Receipt: () => Receipt$1,
+	apply: () => apply$1,
+	authorize: () => authorize$1,
+	create: () => create$1
+});
+function create$1(input) {
+	return Effect.runPromise(create$2({
+		plan: input.plan,
+		receipt: input.receipt,
+		...input.ttlMs === void 0 ? {} : { ttlMs: input.ttlMs }
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+function authorize$1(plan, operationIds) {
+	return Effect.runPromise(authorize$3(plan, operationIds).pipe(Effect.provide(webCryptoLayer)));
+}
+function apply$1(input) {
+	return Effect.runPromise(apply$2({
+		authorization: input.authorization,
+		plan: input.plan,
+		...input.priorReceipt === void 0 ? {} : { priorReceipt: input.priorReceipt }
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+//#endregion
+//#region src/promise/cloudflare-auth.ts
+var cloudflare_auth_exports = /* @__PURE__ */ __exportAll({
+	manifest: () => manifest$1,
+	oauthFlow: () => oauthFlow,
+	oauthMethod: () => oauthMethod,
+	subjectResolver: () => subjectResolver,
+	tokenConnectionMethod: () => tokenConnectionMethod$1,
+	tokenMethod: () => tokenMethod$1,
+	tokenValidator: () => tokenValidator
+});
+const manifest$1 = manifest$2;
+const oauthMethod = oauthMethod$1;
+const tokenMethod$1 = tokenMethod$2;
+function subjectResolver(options) {
+	const resolve = subjectResolver$1(options);
+	return (tokens, accessToken) => Effect.runPromise(resolve(tokens, accessToken));
+}
+/** Creates Cloudflare's OAuth implementation for the Promise connection facade. */
+function oauthFlow(options) {
+	return fromEffectFlow(oauthFlow$1(options));
+}
+/** Creates a Cloudflare token method for the Promise connection facade. */
+function tokenConnectionMethod$1(options) {
+	return fromEffectTokenMethod(tokenConnectionMethod$2(options));
+}
+function tokenValidator(options) {
+	const validate = tokenValidator$1(options);
+	return (token) => Effect.runPromise(validate(token));
+}
+//#endregion
+//#region src/promise/cloudflare.ts
+var cloudflare_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => cloudflare_auth_exports,
+	discovery: () => discovery$1,
+	make: () => make$5
+});
+/** Creates a Promise-compatible facade over the Effect-native Cloudflare client. */
+function make$5(options) {
+	const client = make$6(options);
+	return {
+		id: client.id,
+		createRecord: (zone, record) => Effect.runPromise(client.createRecord(zone, record)),
+		deleteRecord: (zone, providerRecordId) => Effect.runPromise(client.deleteRecord(zone, providerRecordId)),
+		getRecord: (zone, providerRecordId) => Effect.runPromise(client.getRecord(zone, providerRecordId)),
+		listAccounts: () => Effect.runPromise(client.listAccounts()),
+		listRecords: (zone) => Effect.runPromise(client.listRecords(zone)),
+		listZones: (input) => Effect.runPromise(client.listZones(input)),
+		validateToken: () => Effect.runPromise(client.validateToken())
+	};
+}
+/** Creates the optional Cloudflare discovery source for Promise consumers. */
+function discovery$1(options) {
+	const client = make$5(options);
+	return {
+		listZones: async (name) => (await client.listZones({ name })).map((zone) => ({
+			...zone,
+			status: zone.status === "active" || zone.status === "pending" ? zone.status : "unknown"
+		})),
+		provider: client
+	};
+}
+//#endregion
+//#region src/promise/vercel-auth.ts
+var vercel_auth_exports = /* @__PURE__ */ __exportAll({
+	exchangeCode: () => exchangeCode,
+	integrationFlow: () => integrationFlow,
+	integrationMethod: () => integrationMethod,
+	manifest: () => manifest,
+	tokenConnectionMethod: () => tokenConnectionMethod,
+	tokenMethod: () => tokenMethod
+});
+const integrationMethod = integrationMethod$1;
+const manifest = manifest$3;
+const tokenMethod = tokenMethod$3;
+function exchangeCode(options) {
+	return Effect.runPromise(exchangeCode$1(options));
+}
+/** Creates Vercel Integration's implementation for the Promise connection facade. */
+function integrationFlow(options) {
+	return fromEffectFlow(integrationFlow$1(options));
+}
+/** Creates a Vercel token method for the Promise connection facade. */
+function tokenConnectionMethod(options) {
+	return fromEffectTokenMethod(tokenConnectionMethod$3(options));
+}
+//#endregion
+//#region src/promise/vercel.ts
+var vercel_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => vercel_auth_exports,
+	discovery: () => discovery,
+	make: () => make$4
+});
+/** Creates a Promise-compatible facade over the Effect-native Vercel client. */
+function make$4(options) {
+	const client = make$7(options);
+	return {
+		id: client.id,
+		createRecord: (zone, record) => Effect.runPromise(client.createRecord(zone, record)),
+		deleteRecord: (zone, providerRecordId) => Effect.runPromise(client.deleteRecord(zone, providerRecordId)),
+		getRecord: (zone, providerRecordId) => Effect.runPromise(client.getRecord(zone, providerRecordId)),
+		listAccounts: () => Effect.runPromise(client.listAccounts()),
+		listRecords: (zone) => Effect.runPromise(client.listRecords(zone)),
+		listZones: (input) => Effect.runPromise(client.listZones(input)),
+		validateToken: () => Effect.runPromise(client.validateToken())
+	};
+}
+/** Creates the optional Vercel discovery source for Promise consumers. */
+function discovery(options) {
+	const client = make$4(options);
+	return {
+		listZones: (name) => client.listZones({ name }),
+		provider: client
+	};
+}
+//#endregion
+//#region src/promise/provisioning.ts
+var provisioning_exports = /* @__PURE__ */ __exportAll({
+	CreateResult: () => CreateResult,
+	Target: () => Target,
+	apply: () => apply,
+	authorize: () => authorize,
+	authorizeForConnection: () => authorizeForConnection,
+	create: () => create,
+	renderManualInstructions: () => renderManualInstructions
+});
+function create(input) {
+	if ("sources" in input) {
+		const { sources, ...programInput } = input;
+		return Effect.runPromise(create$3(programInput).pipe(Effect.provide(Layer.merge(Layer.succeed(Service$3, make$9(sources.map(toEffectSource))), webCryptoLayer))));
+	}
+	const { provider, ...programInput } = input;
+	return Effect.runPromise(create$3(programInput).pipe(Effect.provide(Layer.merge(layerFromAsync(provider), webCryptoLayer))));
+}
+function authorize(plan, operationIds, options = {}) {
+	return Effect.runPromise(authorize$4(plan, operationIds, options).pipe(Effect.provide(webCryptoLayer)));
+}
+function apply(input) {
+	return Effect.runPromise(apply$3({
+		authorization: input.authorization,
+		plan: input.plan
+	}).pipe(Effect.provide(Layer.merge(layerFromAsync(input.provider), webCryptoLayer))));
+}
+function authorizeForConnection(input) {
+	return Effect.runPromise(authorize$2(input).pipe(Effect.provide(webCryptoLayer)));
+}
+const renderManualInstructions = renderManualInstructions$1;
+//#endregion
+//#region src/promise/verification.ts
+var verification_exports = /* @__PURE__ */ __exportAll({
+	Provider: () => Provider,
+	ProviderObservation: () => ProviderObservation,
+	PublicDns: () => PublicDns,
+	PublicDnsObservation: () => PublicDnsObservation,
+	Result: () => Result,
+	observe: () => observe
+});
+const PublicDns = PublicDns$1;
+const Provider = Data.taggedEnum();
+function observe(input) {
+	const provider = input.provider ?? Provider.Disabled();
+	let program = provider._tag === "Enabled" ? observe$1({
+		record: input.record,
+		...input.publicDns === void 0 ? {} : { publicDns: input.publicDns },
+		provider: Provider$1.Enabled({ zone: provider.zone })
+	}).pipe(Effect.provide(layerFromAsync(provider.provider))) : observe$1({
+		record: input.record,
+		...input.publicDns === void 0 ? {} : { publicDns: input.publicDns },
+		provider: Provider$1.Disabled()
+	});
+	if (input.resolvers !== void 0) program = program.pipe(Effect.provide(Layer.succeed(Service, make$8(input.resolvers.map((entry) => ({
+		id: entry.id,
+		resolver: fromAsyncResolver(entry.resolver),
+		...entry.timeoutMs === void 0 ? {} : { timeoutMs: entry.timeoutMs }
+	}))))));
+	return Effect.runPromise(program);
+}
+function fromAsyncResolver(resolver) {
+	return { resolve: (query) => Effect.tryPromise({
+		try: () => resolver.resolve(query),
+		catch: (cause) => new Error$4({
+			cause,
+			message: cause instanceof globalThis.Error ? cause.message : String(cause),
+			reason: "transport"
+		})
+	}).pipe(Effect.flatMap((resolution) => {
+		switch (resolution._tag) {
+			case "answer":
+			case "nodata": return Effect.succeed(resolution);
+			case "timeout": return Effect.fail(new Error$4({
+				message: "DNS query timed out",
+				reason: "timeout"
+			}));
+			case "failure": return Effect.fail(new Error$4({
+				message: resolution.message,
+				reason: "transport"
+			}));
+		}
+	})) };
+}
+//#endregion
+//#region src/promise/cloudflare-doh.ts
+var cloudflare_doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$3 });
+function make$3(options = {}) {
+	return toAsync$2(options);
+}
+//#endregion
+//#region src/promise/doh.ts
+var doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$2 });
+function make$2(options) {
+	return toAsync$3(options);
+}
+//#endregion
+//#region src/promise/google-doh.ts
+var google_doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+function make$1(options = {}) {
+	return toAsync$4(options);
+}
+//#endregion
+//#region src/promise/resolver-pool.ts
+var resolver_pool_exports = /* @__PURE__ */ __exportAll({
+	Observation: () => Observation,
+	Policy: () => Policy,
+	defaultMake: () => defaultMake,
+	make: () => make
+});
+function make(entries) {
+	return toAsync(make$8(entries.map((entry) => ({
+		id: entry.id,
+		resolver: asyncResolver(entry.resolver),
+		...entry.timeoutMs === void 0 ? {} : { timeoutMs: entry.timeoutMs }
+	}))));
+}
+function defaultMake(options = {}) {
+	return toAsync(defaultMake$1(options));
+}
+function toAsync(pool) {
+	return { observe: (query) => Effect.runPromise(pool.observe(query)) };
+}
+function asyncResolver(resolver) {
+	return { resolve: (query) => Effect.tryPromise({
+		try: () => resolver.resolve(query),
+		catch: (cause) => new Error$4({
+			cause,
+			message: cause instanceof globalThis.Error ? cause.message : String(cause),
+			reason: "transport"
+		})
+	}).pipe(Effect.flatMap((resolution) => {
+		switch (resolution._tag) {
+			case "answer":
+			case "nodata": return Effect.succeed(resolution);
+			case "timeout": return Effect.fail(new Error$4({
+				message: "DNS query timed out",
+				reason: "timeout"
+			}));
+			case "failure": return Effect.fail(new Error$4({
+				message: resolution.message,
+				reason: "transport"
+			}));
+		}
+	})) };
+}
+//#endregion
+//#region src/promise.ts
+/** The current package version from the package manifest. */
+const VERSION = version;
+//#endregion
+export { authorization_lifecycle_exports as AuthorizationLifecycle, cloudflare_exports as Cloudflare, cloudflare_doh_exports as CloudflareDnsOverHttps, connection_exports as Connection, deletion_exports as Deletion, diagnostic_exports as Diagnostic, doh_exports as DnsOverHttps, dns_plan_exports as DnsPlan, dns_record_exports as DnsRecord, resolver_pool_exports as DnsResolverPool, domain_name_exports as DomainName, google_doh_exports as GoogleDnsOverHttps, invalid_input_exports as InvalidInput, provider_auth_exports as ProviderAuth, provider_authorization_exports as ProviderAuthorization, provider_context_exports as ProviderContext, selection_exports as ProviderDiscovery, provisioning_exports as Provisioning, secret_exports as Secret, VERSION, vercel_exports as Vercel, verification_exports as Verification, zone_discovery_exports as ZoneDiscovery, zones_exports as Zones };
+
+//# sourceMappingURL=promise.mjs.map