doomain 0.1.22 → 0.1.24

package/dist/lib/command-schema.d.ts

@@ -1,3 +1,4 @@
+import type { DoomainEffect } from './effect.js';
 import { type ProviderStatus } from './providers/status.js';
 export type ProviderConnectionStatus = Pick<ProviderStatus, 'account' | 'accountLabel' | 'configured' | 'default' | 'displayName' | 'docsUrl' | 'id' | 'isDefaultAccount' | 'isPreferredProvider'>;
 export interface CommandSchema {
@@ -23,4 +24,4 @@ export interface CommandSchema {
 }
 export declare const commandSchemas: CommandSchema[];
 export declare function getCommandSchema(name?: string): CommandSchema[] | CommandSchema | undefined;
-export declare function getCommandSchemaForAgents(name?: string): Promise<CommandSchema[] | CommandSchema | undefined>;
+export declare function getCommandSchemaForAgents(name?: string): DoomainEffect<CommandSchema[] | CommandSchema | undefined>;

package/dist/lib/command-schema.js

@@ -1,3 +1,4 @@
+import { Effect } from 'effect';
 import { listProviderStatuses } from './providers/status.js';
 const dnsRemovalFlags = [
     { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
@@ -218,6 +219,13 @@ export const commandSchemas = [
         safeForAgents: true,
         flags: [{ name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' }],
     },
+    {
+        name: 'version',
+        description: 'Display the installed doomain version.',
+        examples: ['doomain version'],
+        safeForAgents: true,
+        flags: [],
+    },
     {
         name: 'update',
         description: 'Install the latest doomain version from npm without using the existing npm cache.',
@@ -442,8 +450,8 @@ export function getCommandSchema(name) {
         return commandSchemas;
     return commandSchemas.find((schema) => schema.name === name);
 }
-async function configuredProviders() {
-    return (await listProviderStatuses({ verify: false })).map((provider) => ({
+function configuredProviders() {
+    return listProviderStatuses({ verify: false }).pipe(Effect.map((providers) => providers.map((provider) => ({
         account: provider.account,
         accountLabel: provider.accountLabel,
         configured: provider.configured,
@@ -453,7 +461,7 @@ async function configuredProviders() {
         id: provider.id,
         isDefaultAccount: provider.isDefaultAccount,
         isPreferredProvider: provider.isPreferredProvider,
-    }));
+    }))));
 }
 function withProviderConnections(schema, providers) {
     if (schema.name !== 'link' &&
@@ -465,12 +473,11 @@ function withProviderConnections(schema, providers) {
         return schema;
     return { ...schema, configuredProviders: providers };
 }
-export async function getCommandSchemaForAgents(name) {
+export function getCommandSchemaForAgents(name) {
     const schema = getCommandSchema(name);
     if (!schema)
-        return undefined;
-    const providers = await configuredProviders();
-    if (Array.isArray(schema))
-        return schema.map((item) => withProviderConnections(item, providers));
-    return withProviderConnections(schema, providers);
+        return Effect.succeed(undefined);
+    return configuredProviders().pipe(Effect.map((providers) => Array.isArray(schema)
+        ? schema.map((item) => withProviderConnections(item, providers))
+        : withProviderConnections(schema, providers)));
 }

package/dist/lib/config.d.ts

@@ -1,3 +1,5 @@
+import { type DoomainEffect } from './effect.js';
+import { type DoomainErrorCode } from './errors.js';
 export declare function getConfigDir(): string;
 export declare function getConfigFile(): string;
 export declare const CONFIG_DIR: string;
@@ -35,9 +37,9 @@ export interface DoomainConfig {
         domain?: string;
     };
 }
-export declare function loadConfig(): Promise<DoomainConfig>;
-export declare function saveConfig(config: DoomainConfig): Promise<void>;
-export declare function updateConfig(updater: (config: DoomainConfig) => DoomainConfig): Promise<DoomainConfig>;
-export declare function clearConfig(): Promise<boolean>;
+export declare function loadConfig(): DoomainEffect<DoomainConfig, never>;
+export declare function saveConfig(config: DoomainConfig, errorCode?: DoomainErrorCode): DoomainEffect<void>;
+export declare function updateConfig(updater: (config: DoomainConfig) => DoomainConfig, errorCode?: DoomainErrorCode): DoomainEffect<DoomainConfig>;
+export declare function clearConfig(): DoomainEffect<boolean, never>;
 export declare function getConfigPath(): string;
 export declare function maskSecret(value?: string): string | undefined;

package/dist/lib/config.js

@@ -1,6 +1,9 @@
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { Effect } from 'effect';
+import { trySync } from './effect.js';
+import { toDoomainError } from './errors.js';
 export function getConfigDir() {
     return process.env.DOOMAIN_CONFIG_DIR || join(homedir(), '.doomain');
 }
@@ -9,33 +12,32 @@ export function getConfigFile() {
 }
 export const CONFIG_DIR = getConfigDir();
 export const CONFIG_FILE = getConfigFile();
-export async function loadConfig() {
-    try {
-        const data = await readFile(getConfigFile(), 'utf8');
-        return JSON.parse(data);
-    }
-    catch {
-        return {};
-    }
-}
-export async function saveConfig(config) {
-    const configFile = getConfigFile();
-    await mkdir(dirname(configFile), { recursive: true });
-    await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
-}
-export async function updateConfig(updater) {
-    const next = updater(await loadConfig());
-    await saveConfig(next);
-    return next;
-}
-export async function clearConfig() {
-    try {
-        await unlink(getConfigFile());
-        return true;
-    }
-    catch {
-        return false;
-    }
+export function loadConfig() {
+    return Effect.tryPromise(() => readFile(getConfigFile(), 'utf8')).pipe(Effect.flatMap((data) => Effect.try(() => JSON.parse(data))), Effect.catchAll(() => Effect.succeed({})));
+}
+export function saveConfig(config, errorCode = 'CONFIG_NOT_FOUND') {
+    return Effect.gen(function* () {
+        const configFile = getConfigFile();
+        yield* Effect.tryPromise({
+            try: () => mkdir(dirname(configFile), { recursive: true }),
+            catch: (cause) => toDoomainError(cause, errorCode),
+        });
+        yield* Effect.tryPromise({
+            try: () => writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 }),
+            catch: (cause) => toDoomainError(cause, errorCode),
+        });
+    });
+}
+export function updateConfig(updater, errorCode = 'CONFIG_NOT_FOUND') {
+    return Effect.gen(function* () {
+        const current = yield* loadConfig();
+        const next = yield* trySync(() => updater(current), errorCode);
+        yield* saveConfig(next, errorCode);
+        return next;
+    });
+}
+export function clearConfig() {
+    return Effect.tryPromise(() => unlink(getConfigFile())).pipe(Effect.as(true), Effect.catchAll(() => Effect.succeed(false)));
 }
 export function getConfigPath() {
     return getConfigFile();

package/dist/lib/diagnose-dns.d.ts

@@ -1,5 +1,7 @@
 import { type DnsResolverObservation } from './dns-propagation.js';
 import { type ResolvedDnsTarget } from './domain-provider.js';
+import { type DoomainEffect } from './effect.js';
+import { type DoomainErrorCode } from './errors.js';
 import type { DnsProvider, DnsRecord, DnsRecordInput, DnsRecordType } from './providers/types.js';
 export type DnsDiagnosisStatus = 'consistent' | 'local_or_vpn_cache_stale' | 'provider_not_updated' | 'public_propagation_pending' | 'system_resolver_unavailable';
 export interface DiagnoseDnsInput {
@@ -44,10 +46,11 @@ export interface DiagnoseDnsResult {
 interface DiagnoseDnsDependencies {
     createProvider: (provider: string, opts: {
         account?: string;
-    }) => Promise<DnsProvider>;
-    observeDns: (fqdn: string, target: Pick<DnsRecordInput, 'type' | 'value'>, elapsedMs: number) => Promise<DnsResolverObservation[]>;
-    resolveTarget: (input: Pick<DiagnoseDnsInput, 'account' | 'domain' | 'provider'>) => Promise<ResolvedDnsTarget>;
-    macOsResolvers?: () => Promise<MacOsResolverMetadata[]>;
+        transportErrorCode?: DoomainErrorCode;
+    }) => DoomainEffect<DnsProvider>;
+    observeDns: (fqdn: string, target: Pick<DnsRecordInput, 'type' | 'value'>, elapsedMs: number) => DoomainEffect<DnsResolverObservation[]>;
+    resolveTarget: (input: Pick<DiagnoseDnsInput, 'account' | 'domain' | 'provider'>) => DoomainEffect<ResolvedDnsTarget>;
+    macOsResolvers?: () => DoomainEffect<MacOsResolverMetadata[], never>;
 }
-export declare function diagnoseDns(input: DiagnoseDnsInput, dependencies?: DiagnoseDnsDependencies): Promise<DiagnoseDnsResult>;
+export declare function diagnoseDns(input: DiagnoseDnsInput, dependencies?: DiagnoseDnsDependencies): DoomainEffect<DiagnoseDnsResult>;
 export {};

package/dist/lib/diagnose-dns.js

@@ -2,46 +2,45 @@ import { execFile } from 'node:child_process';
 import { getServers } from 'node:dns';
 import { networkInterfaces, platform } from 'node:os';
 import { promisify } from 'node:util';
+import { Effect } from 'effect';
 import { classifyDnsPropagation, isNegativeDnsObservation, observeDnsRecord, } from './dns-propagation.js';
 import { desiredSlotPostcondition, dnsRecordNamesEqual, inferAddressRecordType, normalizeAddressRecordTarget, normalizeDnsValue, } from './dns-records.js';
 import { resolveProviderTarget } from './domain-provider.js';
+import { trySync } from './effect.js';
 import { DoomainError } from './errors.js';
 import { createProvider } from './providers/registry.js';
 const execFileAsync = promisify(execFile);
-async function readMacOsResolvers() {
+function readMacOsResolvers() {
     if (platform() !== 'darwin')
-        return [];
-    try {
-        const { stdout } = await execFileAsync('scutil', ['--dns'], { maxBuffer: 1024 * 1024 });
-        return String(stdout)
-            .split(/\n(?=resolver #\d+)/)
-            .flatMap((block) => {
-            const resolver = block.match(/resolver #(\d+)/)?.[1];
-            if (!resolver)
-                return [];
-            const interfaceMatch = block.match(/if_index\s*:\s*(\d+)(?:\s*\(([^)]+)\))?/);
-            const nameservers = [...block.matchAll(/nameserver\[\d+\]\s*:\s*(\S+)/g)].map((match) => match[1]);
-            const flags = block.match(/flags\s*:\s*(.+)/)?.[1]?.trim();
-            return [
-                {
-                    ...(flags ? { flags } : {}),
-                    ...(interfaceMatch ? { interfaceIndex: Number(interfaceMatch[1]) } : {}),
-                    ...(interfaceMatch?.[2] ? { interfaceName: interfaceMatch[2] } : {}),
-                    nameservers,
-                    resolver: Number(resolver),
-                },
-            ];
-        });
-    }
-    catch {
-        return [];
-    }
+        return Effect.succeed([]);
+    return Effect.tryPromise(() => execFileAsync('scutil', ['--dns'], { maxBuffer: 1024 * 1024 })).pipe(Effect.map(({ stdout }) => String(stdout)
+        .split(/\n(?=resolver #\d+)/)
+        .flatMap((block) => {
+        const resolver = block.match(/resolver #(\d+)/)?.[1];
+        if (!resolver)
+            return [];
+        const interfaceMatch = block.match(/if_index\s*:\s*(\d+)(?:\s*\(([^)]+)\))?/);
+        const nameservers = [...block.matchAll(/nameserver\[\d+\]\s*:\s*(\S+)/g)].map((match) => match[1]);
+        const flags = block.match(/flags\s*:\s*(.+)/)?.[1]?.trim();
+        return [
+            {
+                ...(flags ? { flags } : {}),
+                ...(interfaceMatch ? { interfaceIndex: Number(interfaceMatch[1]) } : {}),
+                ...(interfaceMatch?.[2] ? { interfaceName: interfaceMatch[2] } : {}),
+                nameservers,
+                resolver: Number(resolver),
+            },
+        ];
+    })), Effect.catchAll(() => Effect.succeed([])));
 }
 const defaultDependencies = {
     createProvider,
     macOsResolvers: readMacOsResolvers,
     observeDns: (fqdn, target, elapsedMs) => observeDnsRecord(fqdn, target, undefined, elapsedMs),
-    resolveTarget: (input) => resolveProviderTarget(input, { tolerateProviderAccountErrors: true }),
+    resolveTarget: (input) => resolveProviderTarget(input, {
+        tolerateProviderAccountErrors: true,
+        transportErrorCode: 'DNS_DIAGNOSE_FAILED',
+    }),
 };
 function recordConflicts(records) {
     const conflicts = [];
@@ -88,69 +87,68 @@ function diagnosisResolutionError(error, input) {
         suggestedCommands: ['doomain providers connect', retry],
     });
 }
-export async function diagnoseDns(input, dependencies = defaultDependencies) {
-    const recordType = input.recordType ?? (input.target ? inferAddressRecordType(input.target.trim()) : undefined) ?? 'A';
-    const requestedTarget = input.target === undefined ? undefined : normalizeAddressRecordTarget(recordType, input.target);
-    let resolved;
-    try {
-        resolved = await dependencies.resolveTarget(input);
-    }
-    catch (error) {
-        if (error instanceof DoomainError)
-            throw diagnosisResolutionError(error, input);
-        throw error;
-    }
-    const provider = await dependencies.createProvider(resolved.provider, { account: resolved.account });
-    const zone = await provider.getZone(resolved.target.zoneDomain);
-    if (!zone) {
-        throw diagnosisResolutionError(new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`), input);
-    }
-    const allRecords = await provider.listRecords(zone);
-    const providerRecords = allRecords.filter((record) => dnsRecordNamesEqual(record.name, resolved.target.recordName));
-    const recordsOfType = providerRecords.filter((record) => record.type === recordType);
-    const expected = requestedTarget ?? (recordsOfType.length === 1 ? recordsOfType[0].value : undefined);
-    const queryTarget = { type: recordType, value: expected ?? recordsOfType[0]?.value ?? '' };
-    const observations = await dependencies.observeDns(resolved.target.fullDomain, queryTarget, 0);
-    const macOsResolvers = await dependencies.macOsResolvers?.();
-    let status;
-    if (expected) {
-        const postcondition = desiredSlotPostcondition(allRecords, {
-            name: resolved.target.recordName,
-            type: recordType,
-            value: expected,
+export function diagnoseDns(input, dependencies = defaultDependencies) {
+    return Effect.gen(function* () {
+        const recordType = yield* trySync(() => input.recordType ?? (input.target ? inferAddressRecordType(input.target.trim()) : undefined) ?? 'A', 'INVALID_INPUT');
+        const requestedTarget = yield* trySync(() => (input.target === undefined ? undefined : normalizeAddressRecordTarget(recordType, input.target)), 'INVALID_INPUT');
+        const resolved = yield* dependencies
+            .resolveTarget(input)
+            .pipe(Effect.mapError((error) => diagnosisResolutionError(error, input)));
+        const provider = yield* dependencies.createProvider(resolved.provider, {
+            account: resolved.account,
+            transportErrorCode: 'DNS_DIAGNOSE_FAILED',
         });
-        status = postcondition.reconciled ? diagnosisStatus(classifyDnsPropagation(observations)) : 'provider_not_updated';
-    }
-    else {
-        const providerValues = new Set(recordsOfType.map((record) => normalizeDnsValue(record.value)));
-        const compared = observations.map((observation) => ({
-            ...observation,
-            matches: providerValues.size === 0
-                ? observation.answers.length === 0 && isNegativeDnsObservation(observation)
-                : observation.answers.length === providerValues.size &&
-                    observation.answers.every((answer) => providerValues.has(normalizeDnsValue(answer.value))),
-        }));
-        observations.splice(0, observations.length, ...compared);
-        status = diagnosisStatus(classifyDnsPropagation(observations));
-    }
-    return {
-        account: resolved.account,
-        accountInferred: resolved.accountInferred,
-        conflicts: recordConflicts(providerRecords),
-        domain: resolved.target.fullDomain,
-        ...(expected === undefined ? {} : { expected }),
-        interfaces: activeInterfaceNames(),
-        isDefaultAccount: resolved.isDefaultAccount,
-        ...(macOsResolvers && macOsResolvers.length > 0 ? { macOsResolvers } : {}),
-        observations,
-        platform: platform(),
-        provider: resolved.provider,
-        providerInferred: resolved.providerInferred,
-        providerRecords,
-        recordType,
-        status,
-        systemResolverServers: getServers(),
-        warnings: resolved.warnings,
-        zoneDomain: resolved.target.zoneDomain,
-    };
+        const zone = yield* provider.getZone(resolved.target.zoneDomain);
+        if (!zone) {
+            return yield* Effect.fail(diagnosisResolutionError(new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`), input));
+        }
+        const allRecords = yield* provider.listRecords(zone);
+        const providerRecords = allRecords.filter((record) => dnsRecordNamesEqual(record.name, resolved.target.recordName));
+        const recordsOfType = providerRecords.filter((record) => record.type === recordType);
+        const expected = requestedTarget ?? (recordsOfType.length === 1 ? recordsOfType[0].value : undefined);
+        const queryTarget = { type: recordType, value: expected ?? recordsOfType[0]?.value ?? '' };
+        const observations = yield* dependencies.observeDns(resolved.target.fullDomain, queryTarget, 0);
+        const macOsResolvers = dependencies.macOsResolvers ? yield* dependencies.macOsResolvers() : undefined;
+        let status;
+        if (expected) {
+            const postcondition = desiredSlotPostcondition(allRecords, {
+                name: resolved.target.recordName,
+                type: recordType,
+                value: expected,
+            });
+            status = postcondition.reconciled ? diagnosisStatus(classifyDnsPropagation(observations)) : 'provider_not_updated';
+        }
+        else {
+            const providerValues = new Set(recordsOfType.map((record) => normalizeDnsValue(record.value)));
+            const compared = observations.map((observation) => ({
+                ...observation,
+                matches: providerValues.size === 0
+                    ? observation.answers.length === 0 && isNegativeDnsObservation(observation)
+                    : observation.answers.length === providerValues.size &&
+                        observation.answers.every((answer) => providerValues.has(normalizeDnsValue(answer.value))),
+            }));
+            observations.splice(0, observations.length, ...compared);
+            status = diagnosisStatus(classifyDnsPropagation(observations));
+        }
+        return {
+            account: resolved.account,
+            accountInferred: resolved.accountInferred,
+            conflicts: recordConflicts(providerRecords),
+            domain: resolved.target.fullDomain,
+            ...(expected === undefined ? {} : { expected }),
+            interfaces: activeInterfaceNames(),
+            isDefaultAccount: resolved.isDefaultAccount,
+            ...(macOsResolvers && macOsResolvers.length > 0 ? { macOsResolvers } : {}),
+            observations,
+            platform: platform(),
+            provider: resolved.provider,
+            providerInferred: resolved.providerInferred,
+            providerRecords,
+            recordType,
+            status,
+            systemResolverServers: getServers(),
+            warnings: resolved.warnings,
+            zoneDomain: resolved.target.zoneDomain,
+        };
+    });
 }

package/dist/lib/dns-propagation.d.ts

@@ -1,3 +1,4 @@
+import type { DoomainEffect } from './effect.js';
 import type { DnsRecordInput, DnsRecordType } from './providers/types.js';
 export interface DnsAnswer {
     ttl?: number | null;
@@ -32,14 +33,14 @@ export interface DnsResolverSpec {
 export declare const defaultDnsResolvers: DnsResolverSpec[];
 export declare function isNegativeDnsObservation(observation: DnsResolverObservation): boolean;
 type ResolveTarget = Pick<DnsRecordInput, 'type' | 'value'>;
-export declare function observeDnsRecord(fqdn: string, target: ResolveTarget, specs?: DnsResolverSpec[], elapsedMs?: number): Promise<DnsResolverObservation[]>;
+export declare function observeDnsRecord(fqdn: string, target: ResolveTarget, specs?: DnsResolverSpec[], elapsedMs?: number): DoomainEffect<DnsResolverObservation[], never>;
 export declare function classifyDnsPropagation(observations: DnsResolverObservation[]): DnsPropagationStatus;
 export declare function waitForDnsPropagation(input: {
     fqdn: string;
     record: ResolveTarget;
     timeoutSeconds: number;
-    observe?: (fqdn: string, target: ResolveTarget, elapsedMs: number) => Promise<DnsResolverObservation[]>;
+    observe?: (fqdn: string, target: ResolveTarget, elapsedMs: number) => DoomainEffect<DnsResolverObservation[]>;
     now?: () => number;
-    sleep?: (milliseconds: number) => Promise<void>;
-}): Promise<DnsPropagationResult>;
+    sleep?: (milliseconds: number) => DoomainEffect<void, never>;
+}): DoomainEffect<DnsPropagationResult>;
 export {};

package/dist/lib/dns-propagation.js

@@ -1,5 +1,7 @@
 import { getServers, Resolver, resolve4, resolve6, resolveCname } from 'node:dns/promises';
+import { Effect } from 'effect';
 import { normalizeDnsValue } from './dns-records.js';
+import { DoomainError } from './errors.js';
 export const defaultDnsResolvers = [
     { kind: 'system', name: 'system' },
     { kind: 'public', name: 'cloudflare', servers: ['1.1.1.1', '1.0.0.1'] },
@@ -16,30 +18,51 @@ function resolverFor(spec) {
     resolver.setServers(spec.servers);
     return resolver;
 }
-async function queryResolver(fqdn, type, resolver) {
-    if (type === 'A') {
-        const answers = resolver ? await resolver.resolve4(fqdn, { ttl: true }) : await resolve4(fqdn, { ttl: true });
-        return answers.map((answer) => ({ ttl: answer.ttl, value: answer.address }));
-    }
-    if (type === 'AAAA') {
-        const answers = resolver ? await resolver.resolve6(fqdn, { ttl: true }) : await resolve6(fqdn, { ttl: true });
-        return answers.map((answer) => ({ ttl: answer.ttl, value: answer.address }));
-    }
-    if (type === 'CNAME') {
-        const answers = resolver ? await resolver.resolveCname(fqdn) : await resolveCname(fqdn);
-        return answers.map((value) => ({
-            ttl: null,
-            ttlUnavailableReason: 'resolver_api_does_not_expose_cname_ttl',
-            value,
-        }));
-    }
-    throw new Error(`Resolver observation is not supported for ${type} records.`);
+function resolverErrorCode(error) {
+    const cause = error instanceof DoomainError ? error.details : error;
+    return cause && typeof cause === 'object' && 'code' in cause && typeof cause.code === 'string'
+        ? cause.code
+        : undefined;
 }
-export async function observeDnsRecord(fqdn, target, specs = defaultDnsResolvers, elapsedMs = 0) {
-    return Promise.all(specs.map(async (spec) => {
+function queryResolver(fqdn, type, resolver) {
+    return Effect.gen(function* () {
+        if (type === 'A') {
+            const answers = yield* Effect.tryPromise({
+                try: () => (resolver ? resolver.resolve4(fqdn, { ttl: true }) : resolve4(fqdn, { ttl: true })),
+                catch: (cause) => new DoomainError('DNS_DIAGNOSE_FAILED', String(cause), cause),
+            });
+            return answers.map((answer) => ({ ttl: answer.ttl, value: answer.address }));
+        }
+        if (type === 'AAAA') {
+            const answers = yield* Effect.tryPromise({
+                try: () => (resolver ? resolver.resolve6(fqdn, { ttl: true }) : resolve6(fqdn, { ttl: true })),
+                catch: (cause) => new DoomainError('DNS_DIAGNOSE_FAILED', String(cause), cause),
+            });
+            return answers.map((answer) => ({ ttl: answer.ttl, value: answer.address }));
+        }
+        if (type === 'CNAME') {
+            const answers = yield* Effect.tryPromise({
+                try: () => (resolver ? resolver.resolveCname(fqdn) : resolveCname(fqdn)),
+                catch: (cause) => new DoomainError('DNS_DIAGNOSE_FAILED', String(cause), cause),
+            });
+            return answers.map((value) => ({
+                ttl: null,
+                ttlUnavailableReason: 'resolver_api_does_not_expose_cname_ttl',
+                value,
+            }));
+        }
+        return yield* Effect.fail(new DoomainError('DNS_DIAGNOSE_FAILED', `Resolver observation is not supported for ${type} records.`));
+    });
+}
+export function observeDnsRecord(fqdn, target, specs = defaultDnsResolvers, elapsedMs = 0) {
+    return Effect.all(specs.map((spec) => Effect.gen(function* () {
         const servers = spec.servers ?? getServers();
-        try {
-            const answers = await queryResolver(fqdn, target.type, resolverFor(spec));
+        const result = yield* Effect.try({
+            try: () => resolverFor(spec),
+            catch: (cause) => new DoomainError('DNS_DIAGNOSE_FAILED', String(cause), cause),
+        }).pipe(Effect.flatMap((resolver) => queryResolver(fqdn, target.type, resolver)), Effect.either);
+        if (result._tag === 'Right') {
+            const answers = result.right;
             return {
                 answers,
                 elapsedMs,
@@ -52,10 +75,9 @@ export async function observeDnsRecord(fqdn, target, specs = defaultDnsResolvers
                 type: target.type,
             };
         }
-        catch (error) {
-            const errorCode = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
-                ? error.code
-                : undefined;
+        else {
+            const error = result.left;
+            const errorCode = resolverErrorCode(error);
             return {
                 answers: [],
                 elapsedMs,
@@ -69,7 +91,7 @@ export async function observeDnsRecord(fqdn, target, specs = defaultDnsResolvers
                 type: target.type,
             };
         }
-    }));
+    })), { concurrency: 'unbounded' });
 }
 export function classifyDnsPropagation(observations) {
     const publicResults = observations.filter((observation) => observation.kind === 'public' && (!observation.error || isNegativeDnsObservation(observation)));
@@ -83,32 +105,36 @@ export function classifyDnsPropagation(observations) {
         return 'local_or_vpn_cache_stale';
     return 'propagated';
 }
-const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-export async function waitForDnsPropagation(input) {
-    const now = input.now ?? Date.now;
-    const wait = input.sleep ?? sleep;
-    const started = now();
-    const deadline = started + input.timeoutSeconds * 1000;
-    let observations = [];
-    while (true) {
-        const elapsedMs = now() - started;
-        observations = input.observe
-            ? await input.observe(input.fqdn, input.record, elapsedMs)
-            : await observeDnsRecord(input.fqdn, input.record, defaultDnsResolvers, elapsedMs);
-        const status = classifyDnsPropagation(observations);
-        if (status === 'propagated' || status === 'local_or_vpn_cache_stale' || status === 'system_resolver_unavailable') {
-            return { elapsedMs, expected: input.record.value, observations, status };
-        }
-        const remaining = deadline - now();
-        if (remaining <= 0) {
-            return {
-                elapsedMs: now() - started,
-                expected: input.record.value,
-                observations,
-                status,
-                timeoutReason: 'public_resolvers_did_not_match_before_timeout',
-            };
+const sleep = (milliseconds) => Effect.sleep(milliseconds);
+export function waitForDnsPropagation(input) {
+    return Effect.gen(function* () {
+        const now = input.now ?? Date.now;
+        const wait = input.sleep ?? sleep;
+        const started = now();
+        const deadline = started + input.timeoutSeconds * 1000;
+        let observations = [];
+        while (true) {
+            const elapsedMs = now() - started;
+            observations = input.observe
+                ? yield* input.observe(input.fqdn, input.record, elapsedMs)
+                : yield* observeDnsRecord(input.fqdn, input.record, defaultDnsResolvers, elapsedMs);
+            const status = classifyDnsPropagation(observations);
+            if (status === 'propagated' ||
+                status === 'local_or_vpn_cache_stale' ||
+                status === 'system_resolver_unavailable') {
+                return { elapsedMs, expected: input.record.value, observations, status };
+            }
+            const remaining = deadline - now();
+            if (remaining <= 0) {
+                return {
+                    elapsedMs: now() - started,
+                    expected: input.record.value,
+                    observations,
+                    status,
+                    timeoutReason: 'public_resolvers_did_not_match_before_timeout',
+                };
+            }
+            yield* wait(Math.min(5000, remaining));
         }
-        await wait(Math.min(5000, remaining));
-    }
+    });
 }

package/dist/lib/dns-reconciliation.d.ts

@@ -1,8 +1,9 @@
 import { type DnsRecordSelector } from './dns-records.js';
+import type { DoomainEffect } from './effect.js';
 import type { DnsProvider, DnsRecord, DnsRecordInput, DnsZone } from './providers/types.js';
 interface RetryDependencies {
     now?: () => number;
-    sleep?: (milliseconds: number) => Promise<void>;
+    sleep?: (milliseconds: number) => DoomainEffect<void, never>;
 }
 export interface ReconciliationResult {
     appliedChanges: number;
@@ -18,7 +19,7 @@ export declare function reconcileDesiredRecord(input: {
     zone: DnsZone;
     progress?: (message: string) => void;
     dependencies?: RetryDependencies;
-}): Promise<ReconciliationResult>;
+}): DoomainEffect<ReconciliationResult>;
 export declare function reconcileRecordRemoval(input: {
     intervalMs?: number;
     provider: DnsProvider;
@@ -27,5 +28,5 @@ export declare function reconcileRecordRemoval(input: {
     zone: DnsZone;
     progress?: (message: string) => void;
     dependencies?: RetryDependencies;
-}): Promise<ReconciliationResult>;
+}): DoomainEffect<ReconciliationResult>;
 export {};