doomain 0.1.23 → 0.1.24

package/dist/lib/providers/namecheap/index.js

@@ -1,4 +1,7 @@
+import { Effect } from 'effect';
 import { XMLParser } from 'fast-xml-parser';
+import { trySync } from '../../effect.js';
+import { toDoomainError } from '../../errors.js';
 import { normalizeDomain } from '../../validate.js';
 import { ProviderError } from '../core/errors.js';
 import { assertNoConflicts, planDnsChanges } from '../core/planner.js';
@@ -131,6 +134,7 @@ export class NamecheapProvider {
     apiUser;
     baseUrl;
     clientIp;
+    transportErrorCode;
     username;
     constructor(context) {
         this.apiUser = context.credentials.apiUser;
@@ -138,131 +142,152 @@ export class NamecheapProvider {
         this.username = context.credentials.username || context.credentials.apiUser;
         this.clientIp = context.credentials.clientIp;
         this.baseUrl = bool(context.credentials.sandbox) ? NAMECHEAP_SANDBOX_URL : NAMECHEAP_PRODUCTION_URL;
+        this.transportErrorCode = context.transportErrorCode ?? 'PROVIDER_API_ERROR';
     }
-    async verifyCredentials() {
-        await this.listZones();
-        return { ok: true };
+    verifyCredentials() {
+        return this.listZones().pipe(Effect.as({ ok: true }));
     }
-    async listZones() {
-        const zones = [];
-        let currentPage = 1;
-        let totalItems = Number.POSITIVE_INFINITY;
-        while (zones.length < totalItems) {
-            const response = await this.request('namecheap.domains.getList', { Page: String(currentPage), PageSize: '100' });
-            const commandResponse = response.ApiResponse.CommandResponse;
-            const result = commandResponse.DomainGetListResult;
-            const domains = asArray(result.Domain);
-            for (const domain of domains) {
-                const zone = toZone(domain);
-                if (zone)
-                    zones.push(zone);
+    listZones() {
+        return Effect.gen(this, function* () {
+            const zones = [];
+            let currentPage = 1;
+            let totalItems = Number.POSITIVE_INFINITY;
+            while (zones.length < totalItems) {
+                const response = yield* this.request('namecheap.domains.getList', {
+                    Page: String(currentPage),
+                    PageSize: '100',
+                });
+                const commandResponse = response.ApiResponse.CommandResponse;
+                const result = commandResponse.DomainGetListResult;
+                const domains = asArray(result.Domain);
+                for (const domain of domains) {
+                    const zone = toZone(domain);
+                    if (zone)
+                        zones.push(zone);
+                }
+                totalItems = pagingTotal(commandResponse, result, zones.length);
+                if (domains.length === 0)
+                    break;
+                currentPage += 1;
             }
-            totalItems = pagingTotal(commandResponse, result, zones.length);
-            if (domains.length === 0)
-                break;
-            currentPage += 1;
-        }
-        return zones;
-    }
-    async getZone(domain) {
-        const normalized = normalizeDomain(domain);
-        const zones = await this.listZones();
-        return zones.find((zone) => zone.name === normalized) ?? null;
+            return zones;
+        });
     }
-    async listRecords(zone) {
-        const { sld, tld } = splitDomain(zone.name);
-        const response = await this.request('namecheap.domains.dns.getHosts', { SLD: sld, TLD: tld });
-        const hosts = asArray(response.ApiResponse.CommandResponse.DomainDNSGetHostsResult.host);
-        return hosts.flatMap((host) => {
-            const record = toDnsRecord(host);
-            return record ? [record] : [];
+    getZone(domain) {
+        return Effect.gen(this, function* () {
+            const normalized = yield* trySync(() => normalizeDomain(domain), 'INVALID_INPUT');
+            const zones = yield* this.listZones();
+            return zones.find((zone) => zone.name === normalized) ?? null;
         });
     }
-    async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({
-            desired,
-            existing: await this.listRecords(zone),
-            force: opts.force,
-            providerId: this.id,
-            zone,
+    listRecords(zone) {
+        return Effect.gen(this, function* () {
+            const { sld, tld } = yield* trySync(() => splitDomain(zone.name), 'PROVIDER_ZONE_NOT_FOUND');
+            const response = yield* this.request('namecheap.domains.dns.getHosts', { SLD: sld, TLD: tld });
+            const hosts = asArray(response.ApiResponse.CommandResponse.DomainDNSGetHostsResult.host);
+            return hosts.flatMap((host) => {
+                const record = toDnsRecord(host);
+                return record ? [record] : [];
+            });
         });
     }
-    async applyChanges(zone, plan) {
-        assertNoConflicts(this.id, plan);
-        const finalRecords = [...plan.existing];
-        const applied = [];
-        const skipped = [];
-        for (const change of plan.changes) {
-            if (change.action === 'skip') {
-                skipped.push(change.record);
-                continue;
-            }
-            if (change.action === 'delete') {
-                const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
-                if (index !== -1)
-                    finalRecords.splice(index, 1);
-            }
-            else if (change.action === 'update') {
-                const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
-                if (index !== -1)
-                    finalRecords[index] = { ...change.existing, ...change.record };
-            }
-            else {
-                finalRecords.push(inputToRecord(change.record));
+    planChanges(zone, desired, opts = {}) {
+        return this.listRecords(zone).pipe(Effect.map((existing) => planDnsChanges({ desired, existing, force: opts.force, providerId: this.id, zone })));
+    }
+    applyChanges(zone, plan) {
+        return Effect.gen(this, function* () {
+            yield* assertNoConflicts(this.id, plan);
+            const finalRecords = [...plan.existing];
+            const applied = [];
+            const skipped = [];
+            for (const change of plan.changes) {
+                if (change.action === 'skip') {
+                    skipped.push(change.record);
+                    continue;
+                }
+                if (change.action === 'delete') {
+                    const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
+                    if (index !== -1)
+                        finalRecords.splice(index, 1);
+                }
+                else if (change.action === 'update') {
+                    const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
+                    if (index !== -1)
+                        finalRecords[index] = { ...change.existing, ...change.record };
+                }
+                else {
+                    finalRecords.push(inputToRecord(change.record));
+                }
+                applied.push(change);
             }
-            applied.push(change);
-        }
-        if (applied.length > 0)
-            await this.setHosts(zone, finalRecords);
-        return { applied, skipped };
+            if (applied.length > 0)
+                yield* this.setHosts(zone, finalRecords);
+            return { applied, skipped };
+        });
     }
-    async upsertRecord(zone, record) {
-        const plan = await this.planChanges(zone, [record], { force: true });
-        await this.applyChanges(zone, plan);
-        return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+    upsertRecord(zone, record) {
+        return Effect.gen(this, function* () {
+            const plan = yield* this.planChanges(zone, [record], { force: true });
+            yield* this.applyChanges(zone, plan);
+            return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+        });
     }
-    async deleteRecord(zone, record) {
-        const records = (await this.listRecords(zone)).filter((item) => !sameRecord(item, record));
-        await this.setHosts(zone, records);
+    deleteRecord(zone, record) {
+        return Effect.gen(this, function* () {
+            const records = (yield* this.listRecords(zone)).filter((item) => !sameRecord(item, record));
+            yield* this.setHosts(zone, records);
+        });
     }
-    async setHosts(zone, records) {
-        const { sld, tld } = splitDomain(zone.name);
-        const response = await this.request('namecheap.domains.dns.setHosts', { SLD: sld, TLD: tld, ...hostParams(records) }, { method: 'POST' });
-        const result = response.ApiResponse.CommandResponse.DomainDNSSetHostsResult;
-        if (!bool(result?.IsSuccess)) {
-            throw new ProviderError('namecheap', 'PROVIDER_API_ERROR', 'Namecheap did not confirm DNS host records were updated.', result);
-        }
+    setHosts(zone, records) {
+        return Effect.gen(this, function* () {
+            const { sld, tld } = yield* trySync(() => splitDomain(zone.name), 'PROVIDER_ZONE_NOT_FOUND');
+            const response = yield* this.request('namecheap.domains.dns.setHosts', { SLD: sld, TLD: tld, ...hostParams(records) }, { method: 'POST' });
+            const result = response.ApiResponse.CommandResponse.DomainDNSSetHostsResult;
+            if (!bool(result?.IsSuccess)) {
+                return yield* Effect.fail(new ProviderError('namecheap', 'PROVIDER_API_ERROR', 'Namecheap did not confirm DNS host records were updated.', result));
+            }
+        });
     }
-    async request(command, params, opts = {}) {
+    request(command, params, opts = {}) {
         if (!this.clientIp) {
-            throw new ProviderError('namecheap', 'MISSING_CREDENTIALS', 'Namecheap requires a whitelisted IPv4 ClientIp credential.');
+            return Effect.fail(new ProviderError('namecheap', 'MISSING_CREDENTIALS', 'Namecheap requires a whitelisted IPv4 ClientIp credential.'));
         }
-        const query = new URLSearchParams({
-            ApiKey: this.apiKey,
-            ApiUser: this.apiUser,
-            ClientIp: this.clientIp,
-            Command: command,
-            UserName: this.username,
-            ...params,
-        });
-        const method = opts.method ?? 'GET';
-        const response = await fetch(method === 'POST' ? this.baseUrl : `${this.baseUrl}?${query.toString()}`, {
-            ...(method === 'POST'
-                ? { body: query.toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, method }
-                : {}),
+        return Effect.gen(this, function* () {
+            const query = new URLSearchParams({
+                ApiKey: this.apiKey,
+                ApiUser: this.apiUser,
+                ClientIp: this.clientIp,
+                Command: command,
+                UserName: this.username,
+                ...params,
+            });
+            const method = opts.method ?? 'GET';
+            const response = yield* Effect.tryPromise({
+                try: (signal) => fetch(method === 'POST' ? this.baseUrl : `${this.baseUrl}?${query.toString()}`, {
+                    ...(method === 'POST'
+                        ? { body: query.toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, method }
+                        : {}),
+                    signal,
+                }),
+                catch: (cause) => toDoomainError(cause, this.transportErrorCode),
+            });
+            if (!response.ok) {
+                return yield* Effect.fail(new ProviderError('namecheap', 'PROVIDER_API_ERROR', `Namecheap API error (${response.status}).`));
+            }
+            const text = yield* Effect.tryPromise({
+                try: () => response.text(),
+                catch: (cause) => new ProviderError('namecheap', 'PROVIDER_API_ERROR', 'Invalid Namecheap API response.', cause),
+            });
+            const data = yield* trySync(() => parser.parse(text), 'PROVIDER_API_ERROR');
+            const status = data.ApiResponse?.Status;
+            if (status !== 'OK') {
+                const message = getErrorMessage(asArray(data.ApiResponse?.Errors?.Error)[0] ?? 'Namecheap API error.');
+                const code = providerCodeFromNamecheapError(message);
+                const help = namecheapSetupHelp(code);
+                return yield* Effect.fail(new ProviderError('namecheap', code, help ? `${message} ${help}` : message, data.ApiResponse?.Errors));
+            }
+            return data;
         });
-        if (!response.ok) {
-            throw new ProviderError('namecheap', 'PROVIDER_API_ERROR', `Namecheap API error (${response.status}).`);
-        }
-        const data = parser.parse(await response.text());
-        const status = data.ApiResponse?.Status;
-        if (status !== 'OK') {
-            const message = getErrorMessage(asArray(data.ApiResponse?.Errors?.Error)[0] ?? 'Namecheap API error.');
-            const code = providerCodeFromNamecheapError(message);
-            const help = namecheapSetupHelp(code);
-            throw new ProviderError('namecheap', code, help ? `${message} ${help}` : message, data.ApiResponse?.Errors);
-        }
-        return data;
     }
 }
 export const namecheapProviderDefinition = {

package/dist/lib/providers/registry.d.ts

@@ -1,6 +1,6 @@
+import { type DoomainEffect } from '../effect.js';
+import { type ProviderAccountOptions } from './core/config.js';
 import type { DnsProvider, DnsProviderDefinition } from './types.js';
 export declare function listProviderDefinitions(): DnsProviderDefinition[];
 export declare function getProviderDefinition(id: string): DnsProviderDefinition;
-export declare function createProvider(id: string, opts?: {
-    account?: string;
-}): Promise<DnsProvider>;
+export declare function createProvider(id: string, opts?: ProviderAccountOptions): DoomainEffect<DnsProvider>;

package/dist/lib/providers/registry.js

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { trySync } from '../effect.js';
 import { DoomainError } from '../errors.js';
 import { ensureProviderId } from '../validate.js';
 import { cloudflareProviderDefinition } from './cloudflare/index.js';
@@ -21,7 +23,9 @@ export function getProviderDefinition(id) {
         throw new DoomainError('PROVIDER_NOT_FOUND', `Unsupported DNS provider: ${id}`);
     return definition;
 }
-export async function createProvider(id, opts = {}) {
-    const definition = getProviderDefinition(id);
-    return definition.create(await createProviderContext(definition, opts));
+export function createProvider(id, opts = {}) {
+    return Effect.gen(function* () {
+        const definition = yield* trySync(() => getProviderDefinition(id), 'PROVIDER_NOT_FOUND');
+        return definition.create(yield* createProviderContext(definition, opts));
+    });
 }

package/dist/lib/providers/spaceship/index.d.ts

@@ -1,3 +1,4 @@
+import { type DoomainEffect } from '../../effect.js';
 import type { DnsChangePlan, DnsProvider, DnsProviderDefinition, DnsRecord, DnsRecordInput, DnsZone, ProviderCapabilities, ProviderContext, ProviderHealth } from '../types.js';
 export declare class SpaceshipProvider implements DnsProvider {
     readonly capabilities: ProviderCapabilities;
@@ -5,18 +6,18 @@ export declare class SpaceshipProvider implements DnsProvider {
     readonly name = "Spaceship";
     private readonly http;
     constructor(context: ProviderContext);
-    verifyCredentials(): Promise<ProviderHealth>;
-    listZones(): Promise<DnsZone[]>;
-    getZone(domain: string): Promise<DnsZone | null>;
-    listRecords(zone: DnsZone): Promise<DnsRecord[]>;
+    verifyCredentials(): DoomainEffect<ProviderHealth>;
+    listZones(): DoomainEffect<DnsZone[]>;
+    getZone(domain: string): DoomainEffect<DnsZone | null>;
+    listRecords(zone: DnsZone): DoomainEffect<DnsRecord[]>;
     planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: {
         force?: boolean;
-    }): Promise<DnsChangePlan>;
-    applyChanges(zone: DnsZone, plan: DnsChangePlan): Promise<{
+    }): DoomainEffect<DnsChangePlan>;
+    applyChanges(zone: DnsZone, plan: DnsChangePlan): DoomainEffect<{
         applied: DnsChangePlan['changes'];
         skipped: DnsRecordInput[];
     }>;
-    upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
-    deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
+    upsertRecord(zone: DnsZone, record: DnsRecordInput): DoomainEffect<DnsRecord>;
+    deleteRecord(zone: DnsZone, record: DnsRecord): DoomainEffect<void>;
 }
 export declare const spaceshipProviderDefinition: DnsProviderDefinition;

package/dist/lib/providers/spaceship/index.js

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { trySync } from '../../effect.js';
 import { normalizeDomain } from '../../validate.js';
 import { createProviderHttpClient } from '../core/http.js';
 import { paginateBySkip } from '../core/pagination.js';
@@ -66,76 +68,75 @@ export class SpaceshipProvider {
             },
             providerId: this.id,
             signal: context.signal,
+            transportErrorCode: context.transportErrorCode,
         });
     }
-    async verifyCredentials() {
-        await this.listZones();
-        return { ok: true };
+    verifyCredentials() {
+        return this.listZones().pipe(Effect.as({ ok: true }));
     }
-    async listZones() {
-        const domains = await paginateBySkip({
+    listZones() {
+        return paginateBySkip({
             take: 100,
             fetchPage: ({ skip, take }) => this.http.request('/domains', {
                 query: { orderBy: 'name', skip, take },
             }),
-        });
-        return domains.flatMap((domain) => {
+        }).pipe(Effect.map((domains) => domains.flatMap((domain) => {
             const zone = toZone(domain);
             return zone ? [zone] : [];
-        });
+        })));
     }
-    async getZone(domain) {
-        const normalized = normalizeDomain(domain);
-        const zones = await this.listZones();
-        return zones.find((zone) => zone.name === normalized) ?? null;
+    getZone(domain) {
+        return Effect.gen(this, function* () {
+            const normalized = yield* trySync(() => normalizeDomain(domain), 'INVALID_INPUT');
+            const zones = yield* this.listZones();
+            return zones.find((zone) => zone.name === normalized) ?? null;
+        });
     }
-    async listRecords(zone) {
-        const records = await paginateBySkip({
+    listRecords(zone) {
+        return paginateBySkip({
             take: 500,
             fetchPage: ({ skip, take }) => this.http.request(`/dns/records/${zone.name}`, {
                 query: { skip, take },
             }),
-        });
-        return records.map(toDnsRecord);
+        }).pipe(Effect.map((records) => records.map(toDnsRecord)));
     }
-    async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({
-            desired,
-            existing: await this.listRecords(zone),
-            force: opts.force,
-            providerId: this.id,
-            zone,
-        });
+    planChanges(zone, desired, opts = {}) {
+        return this.listRecords(zone).pipe(Effect.map((existing) => planDnsChanges({ desired, existing, force: opts.force, providerId: this.id, zone })));
     }
-    async applyChanges(zone, plan) {
-        assertNoConflicts(this.id, plan);
-        const skipped = plan.changes.flatMap((change) => (change.action === 'skip' ? [change.record] : []));
-        const applied = plan.changes.filter((change) => change.action !== 'skip');
-        // Spaceship records do not have stable ids. Delete every old value before creating
-        // replacements so an API that processes accepted writes out of order cannot leave
-        // two address records in the same slot without the reconciler noticing and retrying.
-        for (const change of applied) {
-            if (change.action === 'delete' || change.action === 'update')
-                await this.deleteRecord(zone, change.existing);
-        }
-        for (const change of applied) {
-            if (change.action === 'create' || change.action === 'update')
-                await this.upsertRecord(zone, change.record);
-        }
-        return { applied, skipped };
+    applyChanges(zone, plan) {
+        return Effect.gen(this, function* () {
+            yield* assertNoConflicts(this.id, plan);
+            const skipped = plan.changes.flatMap((change) => (change.action === 'skip' ? [change.record] : []));
+            const applied = plan.changes.filter((change) => change.action !== 'skip');
+            // Spaceship records do not have stable ids. Delete every old value before creating
+            // replacements so an API that processes accepted writes out of order cannot leave
+            // two address records in the same slot without the reconciler noticing and retrying.
+            for (const change of applied) {
+                if (change.action === 'delete' || change.action === 'update')
+                    yield* this.deleteRecord(zone, change.existing);
+            }
+            for (const change of applied) {
+                if (change.action === 'create' || change.action === 'update')
+                    yield* this.upsertRecord(zone, change.record);
+            }
+            return { applied, skipped };
+        });
     }
-    async upsertRecord(zone, record) {
-        await this.http.request(`/dns/records/${zone.name}`, {
+    upsertRecord(zone, record) {
+        return this.http
+            .request(`/dns/records/${zone.name}`, {
             body: { force: true, items: [toSpaceshipItem(record)] },
             method: 'PUT',
-        });
-        return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+        })
+            .pipe(Effect.as({ ...record, ttl: record.ttl ?? capabilities.defaultTtl }));
     }
-    async deleteRecord(zone, record) {
-        await this.http.request(`/dns/records/${zone.name}`, {
+    deleteRecord(zone, record) {
+        return this.http
+            .request(`/dns/records/${zone.name}`, {
             body: [toSpaceshipItem(record)],
             method: 'DELETE',
-        });
+        })
+            .pipe(Effect.asVoid);
     }
 }
 export const spaceshipProviderDefinition = {

package/dist/lib/providers/status.d.ts

@@ -1,4 +1,5 @@
 import { type DoomainConfig } from '../config.js';
+import { type DoomainEffect } from '../effect.js';
 import type { DnsProviderDefinition } from './types.js';
 export interface ProviderStatus {
     account: string;
@@ -20,4 +21,4 @@ export declare function isProviderConfigured(definition: DnsProviderDefinition,
 }): boolean;
 export declare function listProviderStatuses(opts?: {
     verify?: boolean;
-}): Promise<ProviderStatus[]>;
+}): DoomainEffect<ProviderStatus[]>;

package/dist/lib/providers/status.js

@@ -1,44 +1,51 @@
+import { Effect } from 'effect';
 import { loadConfig } from '../config.js';
+import { trySync } from '../effect.js';
 import { DEFAULT_PROVIDER_ACCOUNT, isProviderAccountConfigured, listConfiguredProviderAccounts, normalizeProviderAccount, } from './core/config.js';
 import { createProvider, listProviderDefinitions } from './registry.js';
 export function isProviderConfigured(definition, config, opts = {}) {
     return isProviderAccountConfigured(definition, config, opts);
 }
-export async function listProviderStatuses(opts = {}) {
-    const config = await loadConfig();
-    const statuses = [];
-    for (const definition of listProviderDefinitions()) {
-        const accounts = listConfiguredProviderAccounts(config, definition);
-        const refs = accounts.length > 0
-            ? accounts
-            : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
-        for (const ref of refs) {
-            const account = normalizeProviderAccount(ref.account);
-            const configured = accounts.some((item) => item.account === account);
-            const status = {
-                account,
-                accountLabel: ref.isDefaultAccount ? `${definition.id}/default` : `${definition.id}/${account}`,
-                configured,
-                default: config.defaults?.provider === definition.id,
-                displayName: definition.displayName,
-                docsUrl: definition.docsUrl,
-                id: definition.id,
-                isDefaultAccount: ref.isDefaultAccount,
-                isPreferredProvider: config.defaults?.provider === definition.id,
-            };
-            if (configured && opts.verify) {
-                try {
-                    const zones = await (await createProvider(definition.id, { account })).listZones();
-                    status.domainCount = zones.length;
-                    status.verified = true;
-                }
-                catch (error) {
-                    status.error = error instanceof Error ? error.message : String(error);
-                    status.verified = false;
+export function listProviderStatuses(opts = {}) {
+    return Effect.gen(function* () {
+        const config = yield* loadConfig();
+        const statuses = [];
+        for (const definition of listProviderDefinitions()) {
+            const accounts = yield* trySync(() => listConfiguredProviderAccounts(config, definition), 'INVALID_INPUT');
+            const refs = accounts.length > 0
+                ? accounts
+                : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
+            for (const ref of refs) {
+                const account = yield* trySync(() => normalizeProviderAccount(ref.account), 'INVALID_INPUT');
+                const configured = accounts.some((item) => item.account === account);
+                const status = {
+                    account,
+                    accountLabel: ref.isDefaultAccount ? `${definition.id}/default` : `${definition.id}/${account}`,
+                    configured,
+                    default: config.defaults?.provider === definition.id,
+                    displayName: definition.displayName,
+                    docsUrl: definition.docsUrl,
+                    id: definition.id,
+                    isDefaultAccount: ref.isDefaultAccount,
+                    isPreferredProvider: config.defaults?.provider === definition.id,
+                };
+                if (configured && opts.verify) {
+                    const verified = yield* Effect.gen(function* () {
+                        const provider = yield* createProvider(definition.id, { account });
+                        return yield* provider.listZones();
+                    }).pipe(Effect.either);
+                    if (verified._tag === 'Right') {
+                        status.domainCount = verified.right.length;
+                        status.verified = true;
+                    }
+                    else {
+                        status.error = verified.left.message;
+                        status.verified = false;
+                    }
                 }
+                statuses.push(status);
             }
-            statuses.push(status);
         }
-    }
-    return statuses;
+        return statuses;
+    });
 }

package/dist/lib/public-ip.d.ts

@@ -0,0 +1,2 @@
+import type { DoomainEffect } from './effect.js';
+export declare function fetchPublicIp(): DoomainEffect<string | undefined, never>;

package/dist/lib/public-ip.js

@@ -0,0 +1,14 @@
+import { Effect } from 'effect';
+export function fetchPublicIp() {
+    return Effect.acquireUseRelease(Effect.sync(() => {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        return { controller, timeout };
+    }), ({ controller }) => Effect.tryPromise(async () => {
+        const response = await fetch('https://api.ipify.org', { signal: controller.signal });
+        if (!response.ok)
+            return undefined;
+        const ip = (await response.text()).trim();
+        return ip || undefined;
+    }).pipe(Effect.catchAll(() => Effect.succeed(undefined))), ({ timeout }) => Effect.sync(() => clearTimeout(timeout)));
+}

package/dist/lib/remove-domain.d.ts

@@ -1,5 +1,7 @@
 import { type DnsRecordSelector } from './dns-records.js';
 import { type ResolvedDnsTarget } from './domain-provider.js';
+import { type DoomainEffect } from './effect.js';
+import { type DoomainErrorCode } from './errors.js';
 import type { DnsProvider, DnsRecord, DnsRecordType } from './providers/types.js';
 export interface RemoveDomainInput {
     account?: string;
@@ -31,8 +33,9 @@ export interface RemoveDomainResult {
 interface RemoveDomainDependencies {
     createProvider: (provider: string, opts: {
         account?: string;
-    }) => Promise<DnsProvider>;
-    resolveTarget: (input: Pick<RemoveDomainInput, 'account' | 'domain' | 'provider'>) => Promise<ResolvedDnsTarget>;
+        transportErrorCode?: DoomainErrorCode;
+    }) => DoomainEffect<DnsProvider>;
+    resolveTarget: (input: Pick<RemoveDomainInput, 'account' | 'domain' | 'provider'>) => DoomainEffect<ResolvedDnsTarget>;
 }
-export declare function removeDomain(input: RemoveDomainInput, dependencies?: RemoveDomainDependencies): Promise<RemoveDomainResult>;
+export declare function removeDomain(input: RemoveDomainInput, dependencies?: RemoveDomainDependencies): DoomainEffect<RemoveDomainResult>;
 export {};