domainkit 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -1,324 +1,325 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { A as invalid_input_exports, O as parse$1, S as layerFromAsync, T as Schema$2, _ as equals, a as Mx, b as Service, c as Opaque, d as Srv, f as Txt, i as Cname, l as RequirementMetadata, m as data, n as Aaaa, o as Ns, p as Type, r as Caa, s as Observed, t as A, u as Schema$1, v as parse, y as Error } from "./dns-record-BLeqo56C.mjs";
-import { a as Schema$3, c as encode, d as provider_context_exports, i as EvidenceSchema, m as secret_exports, n as CapabilityEvidence, r as Evidence, s as decode$3, t as Capability } from "./authorization-CQSKKMrW.mjs";
-import { n as zones_exports } from "./zones-DKHTpX9C.mjs";
-import { i as webCryptoLayer } from "./canonical-json-CpvqGMcr.mjs";
-import { i as authorization_lifecycle_exports, t as connection_exports } from "./connection-X3rZhrBZ.mjs";
-import { t as cloudflare_exports } from "./cloudflare-Bg_p-M2c.mjs";
-import { C as selection_exports, E as decode$4, O as diagnostic_exports, T as Schema$4, _ as toAsync$1, a as Result, c as Observation, d as defaultMake$1, f as make$4, h as toAsync$3, i as PublicDnsObservation, k as version, l as Policy, n as ProviderObservation, o as observe$1, r as PublicDns$1, t as Provider$1, u as Service$1, w as Method, x as authorize$2, y as toAsync$2 } from "./verify-Q5RYpnuw.mjs";
-import { A as decodeReceipt$1, D as Receipt, E as Operation, F as Service$2, I as make$5, M as encodeReceipt, O as Schema$5, P as Candidate, S as create$3, T as Authorization, a as Authorization$1, b as apply$3, c as PartialError, d as apply$2, f as authorize$3, g as CreateResult, j as encode$1, k as decode$5, l as Plan, o as Error$1, p as create$2, s as Operation$1, t as Error$2, u as Receipt$1, w as renderManualInstructions$1, x as authorize$4, y as Target } from "./resolver-CxE-VDw4.mjs";
-import { r as vercel_exports } from "./vercel-BIFpZRPu.mjs";
-import { Data, Effect, Layer } from "effect";
-//#region src/promise/provider-auth.ts
-var provider_auth_exports = /* @__PURE__ */ __exportAll({
-	Method: () => Method,
-	Schema: () => Schema$4,
-	decode: () => decode$2
+import { $ as RemoveDomainResult$1, A as make$1, B as discovery, G as secret_exports, O as client_exports$1, Q as Method$1, Tt as version, U as connection_authorization_exports, V as make, W as selection_exports, X as diagnostic_exports, Y as manifest_exports, Z as Error, at as AuthorizationError, b as dns_data_exports, ct as assertGrant, dt as decode, et as StartResult, ft as encode, g as cloudflare_doh_exports, ht as validate, it as start, j as auth_exports, k as discovery$1, lt as authorizationError, m as google_doh_exports, mt as removeDomain$1, nt as extend, ot as Grant, p as resolver_pool_exports, pt as includeDomains, rt as removeDomain, s as verify_exports, st as Schema$1, tt as complete, ut as coversDomain, v as doh_exports, wt as provider_context_exports, x as auth_exports$1, xt as authorization_exports, z as client_exports } from "./verify-B00c81-n.mjs";
+import { B as provider_exports, C as plan_exports, N as types_exports, P as canonical_json_exports, _t as domain_name_exports, bt as invalid_input_exports, dt as zones_exports, lt as zone_discovery_exports, m as deletion_exports, mt as lifecycle_repository_exports, r as resolver_exports, rt as dns_record_exports } from "./resolver-CvK7JoJM.mjs";
+import { Context, Data, Effect, Layer, Schema } from "effect";
+//#region src/auth/connection-api.ts
+var connection_api_exports = /* @__PURE__ */ __exportAll({
+	AuthorizationError: () => AuthorizationError,
+	Error: () => Error,
+	Grant: () => Grant,
+	Method: () => Method$1,
+	RemoveDomainResult: () => RemoveDomainResult$1,
+	Schema: () => Schema$1,
+	StartResult: () => StartResult,
+	assertGrant: () => assertGrant,
+	authorizationError: () => authorizationError,
+	complete: () => complete,
+	coversDomain: () => coversDomain,
+	decode: () => decode,
+	encode: () => encode,
+	extend: () => extend,
+	includeDomains: () => includeDomains,
+	removeDomain: () => removeDomain,
+	removeDomainFromGrant: () => removeDomain$1,
+	start: () => start,
+	validate: () => validate
+});
+//#endregion
+//#region src/providers/cloudflare/index.ts
+var cloudflare_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => auth_exports,
+	Client: () => client_exports,
+	discovery: () => discovery,
+	make: () => make
 });
-function decode$2(input) {
-	return Effect.runPromise(decode$4(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
+//#region src/providers/vercel/index.ts
+var vercel_exports = /* @__PURE__ */ __exportAll({
+	Auth: () => auth_exports$1,
+	Client: () => client_exports$1,
+	discovery: () => discovery$1,
+	make: () => make$1
 });
-function decode$1(input) {
-	return Effect.runPromise(decode$3(input));
-}
 //#endregion
-//#region src/promise/zone-discovery.ts
-var zone_discovery_exports = /* @__PURE__ */ __exportAll({
-	Candidate: () => Candidate,
-	discover: () => discover,
-	toEffectSource: () => toEffectSource
+//#region src/transport.ts
+var transport_exports = /* @__PURE__ */ __exportAll({
+	ApplyResult: () => ApplyResult,
+	AuthenticationMethod: () => AuthenticationMethod,
+	AuthenticationParameter: () => AuthenticationParameter,
+	CleanupOperation: () => CleanupOperation,
+	CleanupPlan: () => CleanupPlan,
+	CleanupResult: () => CleanupResult,
+	Connected: () => Connected,
+	ConnectionResult: () => ConnectionResult,
+	ConnectionSnapshot: () => ConnectionSnapshot,
+	Disconnected: () => Disconnected,
+	DnsRecord: () => DnsRecord,
+	Failure: () => Failure,
+	Method: () => Method,
+	Observation: () => Observation,
+	ObservationEvidence: () => ObservationEvidence,
+	OperationResult: () => OperationResult,
+	PlanOperation: () => PlanOperation,
+	Provider: () => Provider,
+	ProvisioningPlan: () => ProvisioningPlan,
+	Redirect: () => Redirect,
+	RemoveDomainResult: () => RemoveDomainResult,
+	ReusableConnection: () => ReusableConnection,
+	Service: () => Service,
+	Unsupported: () => Unsupported,
+	fromAsync: () => fromAsync,
+	fromDnsRecord: () => fromDnsRecord,
+	layerFromAsync: () => layerFromAsync,
+	toAsync: () => toAsync
+});
+/** A user-presentable failure at the application transport boundary. */
+var Failure = class extends Schema.TaggedError()("Failure", {
+	message: Schema.String,
+	operation: Schema.String,
+	retry: Schema.Literals([
+		"never",
+		"after-user-action",
+		"safe",
+		"unknown"
+	])
+}) {};
+const AuthenticationParameter = Schema.Struct({
+	description: Schema.optionalKey(Schema.String),
+	key: Schema.String,
+	label: Schema.String,
+	placeholder: Schema.optionalKey(Schema.String),
+	required: Schema.optionalKey(Schema.Boolean)
+});
+const AuthenticationMethod = Schema.TaggedUnion({
+	OAuth: { label: Schema.String },
+	Token: {
+		label: Schema.String,
+		parameters: Schema.optionalKey(Schema.Array(AuthenticationParameter)),
+		placeholder: Schema.optionalKey(Schema.String)
+	}
 });
-function discover(input) {
-	return Effect.runPromise(make$5(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({
-				cause,
-				message: cause instanceof globalThis.Error ? cause.message : String(cause),
-				operation: "ZoneDiscovery.listZones",
-				providerId: source.provider.id,
-				reason: "transport"
-			})
-		}),
-		provider: Service.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
+const Method = Data.taggedEnum();
+const Provider = Schema.Struct({
+	authentication: Schema.Array(AuthenticationMethod),
+	id: Schema.String,
+	name: Schema.String
+});
+const Connected = Schema.TaggedStruct("Connected", {
+	connectionId: Schema.String,
+	domain: Schema.String,
+	provider: Provider
+});
+const ReusableConnection = Schema.Struct({
+	connectionId: Schema.String,
+	label: Schema.String
+});
+const Disconnected = Schema.TaggedStruct("Disconnected", {
+	domain: Schema.String,
+	provider: Provider,
+	reusableConnection: Schema.optionalKey(ReusableConnection)
+});
+const Unsupported = Schema.TaggedStruct("Unsupported", { domain: Schema.String });
+const ConnectionSnapshot = Schema.Union([
+	Connected,
+	Disconnected,
+	Unsupported
+]).pipe(Schema.toTaggedUnion("_tag"));
+const Redirect = Schema.TaggedStruct("Redirect", { authorizationUrl: Schema.String });
+const ConnectionResult = Schema.Union([Connected, Redirect]).pipe(Schema.toTaggedUnion("_tag"));
+const RemoveDomainResult = Schema.TaggedStruct("Removed", {
+	connectionId: Schema.String,
+	domain: Schema.String,
+	remainingDomainCount: Schema.Int
+});
+/** A presentation projection of a DNS requirement. */
+const DnsRecord = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	priority: Schema.optionalKey(Schema.Int),
+	type: Schema.String,
+	value: Schema.String
+});
+/** Projects DomainKit's operational record into its application transport representation. */
+const fromDnsRecord = (id, record) => {
+	switch (record._tag) {
+		case "A":
+		case "AAAA": return {
+			id,
+			name: record.name,
+			type: record._tag,
+			value: record.address
+		};
+		case "CNAME":
+		case "NS": return {
+			id,
+			name: record.name,
+			type: record._tag,
+			value: record.target
+		};
+		case "TXT": return {
+			id,
+			name: record.name,
+			type: record._tag,
+			value: record.value
+		};
+		case "MX": return {
+			id,
+			name: record.name,
+			priority: record.priority,
+			type: record._tag,
+			value: record.exchange
+		};
+		case "CAA": return {
+			id,
+			name: record.name,
+			type: record._tag,
+			value: `${record.flags} ${record.tag} ${record.value}`
+		};
+		case "SRV": return {
+			id,
+			name: record.name,
+			priority: record.priority,
+			type: record._tag,
+			value: `${record.weight} ${record.port} ${record.target}`
 		};
-		case "SelectionRequired": return outcome;
 	}
-}
-function providerFailure(providerId, operation, cause) {
-	return cause instanceof Error ? cause : new Error({
-		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$1,
-	Srv: () => Srv,
-	Txt: () => Txt,
-	Type: () => Type,
-	data: () => data,
-	equals: () => equals,
-	parse: () => parse
+};
+const PlanOperation = Schema.TaggedUnion({
+	Conflict: {
+		id: Schema.String,
+		reason: Schema.String,
+		record: DnsRecord
+	},
+	Create: {
+		id: Schema.String,
+		record: DnsRecord
+	},
+	Noop: {
+		id: Schema.String,
+		record: DnsRecord
+	}
 });
-//#endregion
-//#region src/promise/domain-name.ts
-var domain_name_exports = /* @__PURE__ */ __exportAll({
-	Schema: () => Schema$2,
-	parse: () => parse$1
+const ProvisioningPlan = Schema.TaggedStruct("Plan", {
+	digest: Schema.String,
+	expiresAt: Schema.String,
+	operations: Schema.Array(PlanOperation)
 });
-//#endregion
-//#region src/promise/dns-plan.ts
-var dns_plan_exports = /* @__PURE__ */ __exportAll({
-	Authorization: () => Authorization,
-	Operation: () => Operation,
-	Receipt: () => Receipt,
-	Schema: () => Schema$5,
-	decode: () => decode,
-	decodeReceipt: () => decodeReceipt,
-	encode: () => encode$1,
-	encodeReceipt: () => encodeReceipt
+const OperationResult = Schema.TaggedUnion({
+	Applied: { operationId: Schema.String },
+	Failed: {
+		message: Schema.String,
+		operationId: Schema.String
+	},
+	Unchanged: { operationId: Schema.String }
 });
-function decode(input) {
-	return Effect.runPromise(decode$5(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$1,
-	Operation: () => Operation$1,
-	PartialError: () => PartialError,
-	Plan: () => Plan,
-	Receipt: () => Receipt$1,
-	apply: () => apply$1,
-	authorize: () => authorize$1,
-	create: () => create$1
+const ApplyOutcomeFields = {
+	operationId: Schema.String,
+	receiptId: Schema.String,
+	results: Schema.Array(OperationResult)
+};
+const ApplyResult = Schema.TaggedUnion({
+	Applied: ApplyOutcomeFields,
+	Partial: ApplyOutcomeFields,
+	Stale: { message: Schema.String }
 });
-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/provisioning.ts
-var provisioning_exports = /* @__PURE__ */ __exportAll({
-	CreateResult: () => CreateResult,
-	Target: () => Target,
-	apply: () => apply,
-	authorize: () => authorize,
-	authorizeForConnection: () => authorizeForConnection,
-	create: () => create,
-	renderManualInstructions: () => renderManualInstructions
+const ObservationEvidence = Schema.TaggedUnion({
+	Found: { recordId: Schema.String },
+	Mismatch: {
+		message: Schema.String,
+		recordId: Schema.String
+	},
+	Missing: { recordId: Schema.String },
+	Unavailable: {
+		message: Schema.String,
+		recordId: Schema.String
+	}
 });
-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$2, make$5(sources.map(toEffectSource))), webCryptoLayer))));
+const Observation = Schema.TaggedStruct("Observation", {
+	provider: Schema.Array(ObservationEvidence),
+	publicDns: Schema.Array(ObservationEvidence)
+});
+const CleanupOperation = Schema.TaggedUnion({
+	AlreadyAbsent: {
+		id: Schema.String,
+		record: DnsRecord
+	},
+	Blocked: {
+		id: Schema.String,
+		reason: Schema.String,
+		record: DnsRecord
+	},
+	Delete: {
+		id: Schema.String,
+		record: DnsRecord
 	}
-	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$1, make$4(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$2({
-			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$2({
-				message: "DNS query timed out",
-				reason: "timeout"
-			}));
-			case "failure": return Effect.fail(new Error$2({
-				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$1(options);
-}
-//#endregion
-//#region src/promise/doh.ts
-var doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$2 });
-function make$2(options) {
-	return toAsync$2(options);
-}
-//#endregion
-//#region src/promise/google-doh.ts
-var google_doh_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
-function make$1(options = {}) {
-	return toAsync$3(options);
-}
-//#endregion
-//#region src/promise/resolver-pool.ts
-var resolver_pool_exports = /* @__PURE__ */ __exportAll({
-	Observation: () => Observation,
-	Policy: () => Policy,
-	defaultMake: () => defaultMake,
-	make: () => make
+const CleanupPlan = Schema.TaggedStruct("CleanupPlan", {
+	digest: Schema.String,
+	expiresAt: Schema.String,
+	operations: Schema.Array(CleanupOperation)
+});
+const CleanupOutcomeFields = {
+	operationId: Schema.String,
+	results: Schema.Array(OperationResult)
+};
+const CleanupResult = Schema.TaggedUnion({
+	Cleaned: CleanupOutcomeFields,
+	Partial: CleanupOutcomeFields,
+	Stale: { message: Schema.String }
 });
-function make(entries) {
-	return toAsync(make$4(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$2({
-			cause,
+var Service = class extends Context.Service()("@domainkit/Transport") {};
+/** Converts a Promise-shaped host implementation into the canonical Effect service. */
+const fromAsync = (transport, options = {}) => {
+	const attempt = (operation, evaluate) => Effect.tryPromise({
+		try: evaluate,
+		catch: (cause) => options.onError?.(operation, cause) ?? (cause instanceof Failure ? cause : new Failure({
 			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$2({
-				message: "DNS query timed out",
-				reason: "timeout"
-			}));
-			case "failure": return Effect.fail(new Error$2({
-				message: resolution.message,
-				reason: "transport"
-			}));
-		}
-	})) };
-}
+			operation,
+			retry: "unknown"
+		}))
+	});
+	return Service.of({
+		cleanup: {
+			apply: (input) => attempt("cleanup.apply", () => transport.cleanup.apply(input)),
+			plan: (input) => attempt("cleanup.plan", () => transport.cleanup.plan(input))
+		},
+		connection: {
+			connect: (input) => attempt("connection.connect", () => transport.connection.connect(input)),
+			inspect: (input) => attempt("connection.inspect", () => transport.connection.inspect(input)),
+			removeDomain: (input) => attempt("connection.removeDomain", () => transport.connection.removeDomain(input)),
+			reuse: (input) => attempt("connection.reuse", () => transport.connection.reuse(input))
+		},
+		provisioning: {
+			apply: (input) => attempt("provisioning.apply", () => transport.provisioning.apply(input)),
+			plan: (input) => attempt("provisioning.plan", () => transport.provisioning.plan(input))
+		},
+		verification: { observe: (input) => attempt("verification.observe", () => transport.verification.observe(input)) }
+	});
+};
+const layerFromAsync = (transport, options) => Layer.succeed(Service, fromAsync(transport, options));
+/** Converts an environment-free Effect service into its Promise-shaped host seam. */
+const toAsync = (transport) => ({
+	cleanup: {
+		apply: (input) => Effect.runPromise(transport.cleanup.apply(input)),
+		plan: (input) => Effect.runPromise(transport.cleanup.plan(input))
+	},
+	connection: {
+		connect: (input) => Effect.runPromise(transport.connection.connect(input)),
+		inspect: (input) => Effect.runPromise(transport.connection.inspect(input)),
+		removeDomain: (input) => Effect.runPromise(transport.connection.removeDomain(input)),
+		reuse: (input) => Effect.runPromise(transport.connection.reuse(input))
+	},
+	provisioning: {
+		apply: (input) => Effect.runPromise(transport.provisioning.apply(input)),
+		plan: (input) => Effect.runPromise(transport.provisioning.plan(input))
+	},
+	verification: { observe: (input) => Effect.runPromise(transport.verification.observe(input)) }
+});
 //#endregion
 //#region src/index.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 };
+export { lifecycle_repository_exports as AuthorizationLifecycle, cloudflare_exports as Cloudflare, cloudflare_doh_exports as CloudflareDnsOverHttps, connection_api_exports as Connection, connection_authorization_exports as ConnectionAuthorization, deletion_exports as Deletion, diagnostic_exports as Diagnostic, canonical_json_exports as Digest, dns_data_exports as DnsData, doh_exports as DnsOverHttps, types_exports as DnsPlan, provider_exports as DnsProvider, dns_record_exports as DnsRecord, resolver_exports as DnsResolver, resolver_pool_exports as DnsResolverPool, domain_name_exports as DomainName, google_doh_exports as GoogleDnsOverHttps, invalid_input_exports as InvalidInput, manifest_exports as ProviderAuth, authorization_exports as ProviderAuthorization, provider_context_exports as ProviderContext, selection_exports as ProviderDiscovery, plan_exports as Provisioning, secret_exports as Secret, transport_exports as Transport, VERSION, vercel_exports as Vercel, verify_exports as Verification, zone_discovery_exports as ZoneDiscovery, zones_exports as Zones };
 
 //# sourceMappingURL=index.mjs.map