@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/lib/browser.ts

@@ -1,150 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import { paths } from '../state/index'
-import { run } from './proc'
-
-/**
- * `astrale browser` is a thin orchestrator over `agent-browser`
- * (https://github.com/vercel-labs/agent-browser) — the Rust browser-automation
- * CLI that AI agents drive. We own only the *session*: resolve the active
- * instance's GUI origin, pin a persistent per-instance profile so the WorkOS
- * login cookie survives across runs, and verify auth. Driving (snapshot/click/
- * eval/…) is agent-browser's job, invoked directly by the agent afterward.
- *
- * Why a profile and not an injected token: the GUI session is an httpOnly
- * sealed cookie (`astrale_router_session`) with no token-injection path, so the
- * only way to "use my session" is to drive a browser whose profile already
- * holds the cookie — minted once via interactive login, reused thereafter.
- */
-
-export const BROWSER_DIR = join(paths.home, 'browser')
-export const BROWSER_SESSION_PATH = join(paths.home, 'browser.json')
-export const AGENT_BROWSER_REPO = 'vercel-labs/agent-browser'
-
-/** Per-instance persistent profile dir handed to `agent-browser --profile`. */
-export function profileDirFor(host: string): string {
-  return join(BROWSER_DIR, host)
-}
-
-/** The last-connected browser session, read by agents to know how to drive. */
-export type BrowserSession = {
-  /** GUI origin, e.g. `https://alpha1.eu.astrale.ai`. */
-  url: string
-  host: string
-  /** Profile dir, or null when attached to an external Chrome over CDP. */
-  profile: string | null
-  /** CDP endpoint (`9222` or a ws URL) when in attach mode. */
-  cdp: string | null
-  email?: string
-  updatedAt: string
-}
-
-export async function readSession(): Promise<BrowserSession | null> {
-  try {
-    return JSON.parse(await readFile(BROWSER_SESSION_PATH, 'utf8')) as BrowserSession
-  } catch {
-    return null
-  }
-}
-
-export async function saveSession(session: BrowserSession): Promise<void> {
-  await mkdir(paths.home, { recursive: true })
-  await writeFile(BROWSER_SESSION_PATH, `${JSON.stringify(session, null, 2)}\n`)
-}
-
-/** Resolve `agent-browser` on PATH; null when not installed. */
-export async function findAgentBrowser(): Promise<string | null> {
-  // `command -v` is a POSIX shell builtin (no `command` executable exists on
-  // Windows), so resolve via `where` on Windows and a shell on Unix.
-  const lookup =
-    process.platform === 'win32'
-      ? run('where', ['agent-browser'])
-      : run('sh', ['-c', 'command -v agent-browser'])
-  const res = await lookup.catch(() => null)
-  if (!res || res.code !== 0) return null
-  const path = res.stdout.split(/\r?\n/)[0]?.trim()
-  return path || null
-}
-
-export type AbResult = {
-  ok: boolean
-  data: unknown
-  error: string | null
-}
-
-/**
- * Connection target for an agent-browser invocation: either a persistent
- * profile dir or a CDP endpoint (mutually exclusive).
- */
-export type AbTarget = { profile?: string; cdp?: string }
-
-/**
- * Run an `agent-browser` command with `--json` and parse its envelope
- * (`{success, data, error}`). Global flags (`--profile`/`--cdp`/`--headed`)
- * precede the subcommand; `--json` trails the args, matching the CLI's parser.
- */
-export async function ab(
-  args: string[],
-  opts: AbTarget & { headed?: boolean } = {},
-): Promise<AbResult> {
-  const argv = ['agent-browser']
-  if (opts.profile) argv.push('--profile', opts.profile)
-  if (opts.cdp) argv.push('--cdp', opts.cdp)
-  if (opts.headed) argv.push('--headed')
-  argv.push(...args, '--json')
-
-  const { code, stdout, stderr } = await run(argv[0], argv.slice(1))
-
-  try {
-    const parsed = JSON.parse(stdout) as { success?: boolean; data?: unknown; error?: string }
-    if (parsed && typeof parsed === 'object' && 'success' in parsed) {
-      return { ok: !!parsed.success, data: parsed.data ?? null, error: parsed.error ?? null }
-    }
-  } catch {
-    // fall through to exit-code interpretation
-  }
-  return { ok: code === 0, data: null, error: stderr.trim() || null }
-}
-
-// Reads the GUI session from whatever origin the page currently sits on. During
-// an interactive login the page is on the IdP origin, where `/auth/me` 404s and
-// the fetch rejects → {authed:false}; once the router redirects back to the GUI
-// it resolves to the authenticated user. Returned as a value (not top-level
-// await — agent-browser's `eval` forbids it) so page.evaluate auto-resolves it.
-const AUTH_EVAL =
-  "fetch('/auth/me',{credentials:'include'})" +
-  '.then(r=>r.json())' +
-  '.then(j=>({authed:!!j.authenticated,email:j.user&&j.user.email}))' +
-  '.catch(()=>({authed:false}))'
-
-export type AuthState = { authed: boolean; email?: string }
-
-function readAuthResult(res: AbResult): AuthState {
-  const result = (res.data as { result?: unknown } | null)?.result
-  if (result && typeof result === 'object') {
-    const r = result as { authed?: boolean; email?: string }
-    return { authed: !!r.authed, email: r.email }
-  }
-  return { authed: false }
-}
-
-/**
- * Poll auth on the current page (no navigation — safe during login redirects).
- * Pass `headed:true` while a sign-in window is open: agent-browser defaults to
- * headless, so an unflagged command flips the live window back to headless and
- * closes it.
- */
-export async function pollAuth(target: AbTarget & { headed?: boolean }): Promise<AuthState> {
-  return readAuthResult(await ab(['eval', AUTH_EVAL], target))
-}
-
-/** Navigate to the GUI, then read auth (used for the silent reuse check). */
-export async function navigateAndCheck(
-  url: string,
-  target: AbTarget & { headed?: boolean },
-): Promise<AuthState> {
-  const opened = await ab(['open', url], target)
-  if (!opened.ok) return { authed: false }
-  return pollAuth(target)
-}

package/src/lib/ca-fetch.ts

@@ -1,133 +0,0 @@
-import type { IncomingHttpHeaders, request as httpRequest } from 'node:http'
-
-import { Buffer } from 'node:buffer'
-import { readFileSync } from 'node:fs'
-import { request as httpsRequest } from 'node:https'
-import { rootCertificates } from 'node:tls'
-
-/** Create a Fetch capability whose HTTPS requests trust one CLI-selected CA file. */
-export function fetchWithCaFile(
-  caFile: string,
-  fallback: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> = globalThis.fetch,
-): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
-  const ca = readFileSync(caFile)
-  const fallbackFetch = fallback.bind(globalThis)
-
-  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const url = requestUrl(input)
-    if (url.protocol !== 'https:') return fallbackFetch(input, init)
-    return fetchWithNode(url, init, ca)
-  }
-}
-
-function requestUrl(input: RequestInfo | URL): URL {
-  if (input instanceof URL) return input
-  if (typeof input === 'string') return new URL(input)
-  return new URL(input.url)
-}
-
-function fetchWithNode(url: URL, init: RequestInit | undefined, ca: Buffer): Promise<Response> {
-  return new Promise((resolve, reject) => {
-    const request = httpsRequest(
-      url,
-      {
-        method: init?.method ?? 'GET',
-        headers: headersInitToRecord(init?.headers),
-        // `ca` replaces Node's default trust set. Retain public roots because one
-        // Client Session may reach both a private Kernel and a public Domain issuer.
-        ca: [...rootCertificates, ca],
-      },
-      (response) => {
-        const chunks: Buffer[] = []
-        response.on('data', (chunk) =>
-          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)),
-        )
-        response.on('end', () => {
-          const status = response.statusCode ?? 0
-          const body =
-            status === 204 || status === 205 || status === 304 ? null : Buffer.concat(chunks)
-          const result = new Response(body, {
-            status,
-            statusText: response.statusMessage,
-            headers: responseHeaders(response.headers),
-          })
-          // Synthetic Responses have no URL list. This transport does not follow
-          // redirects, so the exact request URL is also the final response URL.
-          Object.defineProperty(result, 'url', { value: url.toString() })
-          resolve(result)
-        })
-      },
-    )
-
-    request.on('error', reject)
-    if (init?.signal) {
-      if (init.signal.aborted) {
-        request.destroy(abortError(init.signal.reason))
-      } else {
-        init.signal.addEventListener(
-          'abort',
-          () => request.destroy(abortError(init.signal?.reason)),
-          {
-            once: true,
-          },
-        )
-      }
-    }
-
-    writeBody(request, init?.body)
-      .then(() => request.end())
-      .catch((error) => request.destroy(error))
-  })
-}
-
-function abortError(reason: unknown): Error {
-  return reason instanceof Error
-    ? reason
-    : new DOMException('The operation was aborted.', 'AbortError')
-}
-
-async function writeBody(
-  request: ReturnType<typeof httpRequest>,
-  body: BodyInit | null | undefined,
-): Promise<void> {
-  if (body === undefined || body === null) return
-  if (typeof body === 'string' || body instanceof Uint8Array) {
-    request.write(body)
-    return
-  }
-  if (body instanceof ArrayBuffer) {
-    request.write(Buffer.from(body))
-    return
-  }
-  if (body instanceof Blob) {
-    request.write(Buffer.from(await body.arrayBuffer()))
-    return
-  }
-  throw new Error('Unsupported request body type for CA-backed fetch')
-}
-
-function headersInitToRecord(headers: HeadersInit | undefined): Record<string, string> {
-  if (!headers) return {}
-  if (headers instanceof Headers) {
-    const out: Record<string, string> = {}
-    headers.forEach((value, key) => {
-      out[key] = value
-    })
-    return out
-  }
-  if (Array.isArray(headers)) return Object.fromEntries(headers)
-  return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]))
-}
-
-function responseHeaders(headers: IncomingHttpHeaders): Headers {
-  const out = new Headers()
-  for (const [key, value] of Object.entries(headers)) {
-    if (value === undefined) continue
-    if (Array.isArray(value)) {
-      for (const entry of value) out.append(key, entry)
-    } else {
-      out.set(key, value)
-    }
-  }
-  return out
-}

package/src/lib/command-dx.ts

@@ -1,191 +0,0 @@
-import type { Command, CommanderError } from 'commander'
-
-import chalk from 'chalk'
-
-export type CommandCatalogEntry = {
-  path: string[]
-  usage: string
-}
-
-export function collectCommandCatalog(program: Command): CommandCatalogEntry[] {
-  const out: CommandCatalogEntry[] = []
-
-  function walk(command: Command, path: string[]): void {
-    for (const child of command.commands) {
-      const childPath = [...path, child.name()]
-      if (child.commands.length === 0) {
-        out.push({ path: childPath, usage: usageFor(childPath, child) })
-      }
-      walk(child, childPath)
-    }
-  }
-
-  walk(program, [])
-  return out
-}
-
-export function renderCommanderError(
-  program: Command,
-  error: CommanderError,
-  argv = process.argv.slice(2),
-  machine = argv.some((token) => token === '--ci' || token === '--json' || token === '--raw') ||
-    !(process.stdout.isTTY ?? false),
-): string {
-  const tokens = stripOptions(argv)
-  const catalog = collectCommandCatalog(program)
-  const matched = matchRegisteredPrefix(program, tokens)
-
-  if (matched.path.length === 0 && tokens.length > 0) {
-    return maybeMachine(renderUnknownCommand(tokens, catalog), machine)
-  }
-
-  if (error.code === 'commander.missingArgument') {
-    const usage = usageFor(matched.path, matched.command)
-    return maybeMachine(
-      [
-        `Missing required argument for ${chalk.bold(`astrale ${matched.path.join(' ')}`)}`,
-        '',
-        'Usage:',
-        `  astrale ${usage}`,
-      ].join('\n'),
-      machine,
-    )
-  }
-
-  if (error.code === 'commander.excessArguments') {
-    const usage = usageFor(matched.path, matched.command)
-    const extra = tokens.slice(matched.path.length).join(' ')
-    return maybeMachine(
-      [
-        `Unexpected argument${extra.includes(' ') ? 's' : ''} for ${chalk.bold(
-          `astrale ${matched.path.join(' ')}`,
-        )}${extra ? `: ${extra}` : ''}`,
-        '',
-        'Usage:',
-        `  astrale ${usage}`,
-      ].join('\n'),
-      machine,
-    )
-  }
-
-  const suggestions = nearestCommands(tokens.join(' '), catalog)
-  return maybeMachine(
-    [
-      error.message,
-      ...(suggestions.length > 0
-        ? ['', 'Did you mean:', ...suggestions.map((s) => `  astrale ${s}`)]
-        : []),
-    ].join('\n'),
-    machine,
-  )
-}
-
-const RETIRED_COMMANDS: Record<string, string> = {
-  ls: 'astrale query <source> --edge <class>',
-  describe: 'astrale get <target>',
-}
-
-function renderUnknownCommand(tokens: string[], catalog: CommandCatalogEntry[]): string {
-  const command = tokens.join(' ')
-  const first = tokens[0]
-  const retired = first === undefined ? undefined : RETIRED_COMMANDS[first]
-  if (retired !== undefined) {
-    return [
-      `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-      '',
-      `\`astrale ${first}\` was removed. Use ${chalk.bold(retired)} instead.`,
-    ].join('\n')
-  }
-  const namespaceMatches = catalog.filter((entry) => entry.path.at(-1) === first)
-  if (namespaceMatches.length > 0) {
-    return [
-      `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-      '',
-      `"${first}" is available under:`,
-      ...namespaceMatches.map((entry) => `  astrale ${entry.usage}`),
-    ].join('\n')
-  }
-
-  const suggestions = nearestCommands(command, catalog)
-  return [
-    `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-    ...(suggestions.length > 0
-      ? ['', 'Did you mean:', ...suggestions.map((s) => `  astrale ${s}`)]
-      : []),
-  ].join('\n')
-}
-
-function matchRegisteredPrefix(
-  program: Command,
-  tokens: string[],
-): { command: Command; path: string[] } {
-  let current = program
-  const path: string[] = []
-  for (const token of tokens) {
-    const next = current.commands.find(
-      (cmd) => cmd.name() === token || cmd.aliases().includes(token),
-    )
-    if (!next) break
-    current = next
-    path.push(current.name())
-  }
-  return { command: current, path }
-}
-
-function usageFor(path: string[], command: Command): string {
-  const suffix = command
-    .usage()
-    .replace(/\[options\]\s*/g, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-  return [path.join(' '), suffix].filter(Boolean).join(' ')
-}
-
-const ANSI_RE = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g')
-
-function maybeMachine(text: string, machine: boolean): string {
-  if (!machine) return text
-  const plain = text.replace(ANSI_RE, '')
-  const first = plain.split('\n').find((line) => line.trim().length > 0) ?? plain
-  return JSON.stringify({ error: 'USAGE_ERROR', message: first, detail: plain })
-}
-
-function stripOptions(argv: string[]): string[] {
-  const out: string[] = []
-  for (const token of argv) {
-    if (token === '--') break
-    if (token.startsWith('-')) continue
-    out.push(token)
-  }
-  return out
-}
-
-function nearestCommands(input: string, catalog: CommandCatalogEntry[]): string[] {
-  if (!input) return []
-  return catalog
-    .map((entry) => ({ usage: entry.usage, score: similarity(input, entry.path.join(' ')) }))
-    .filter((entry) => entry.score >= 0.45)
-    .sort((a, b) => b.score - a.score || a.usage.localeCompare(b.usage))
-    .slice(0, 3)
-    .map((entry) => entry.usage)
-}
-
-function similarity(a: string, b: string): number {
-  const max = Math.max(a.length, b.length)
-  if (max === 0) return 1
-  return 1 - levenshtein(a, b) / max
-}
-
-function levenshtein(a: string, b: string): number {
-  const prev = Array.from({ length: b.length + 1 }, (_, i) => i)
-  const curr = Array.from({ length: b.length + 1 }, () => 0)
-  for (let i = 1; i <= a.length; i += 1) {
-    curr[0] = i
-    for (let j = 1; j <= b.length; j += 1) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1
-      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost)
-    }
-    prev.splice(0, prev.length, ...curr)
-  }
-  return prev[b.length] ?? 0
-}

package/src/lib/concurrency.ts

@@ -1,31 +0,0 @@
-/**
- * Minimal bounded-concurrency map. No external dependency (the repo
- * hand-rolls with `Promise.all`); a tiny worker pool is enough for the
- * `domain dev up` fan-out.
- */
-
-/**
- * Run `fn` over `items` with at most `limit` in flight at once. Results
- * are returned in input order regardless of completion order. The first
- * rejection rejects the returned promise (in-flight work still settles).
- */
-export async function mapBounded<T, R>(
-  items: readonly T[],
-  limit: number,
-  fn: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  const results: R[] = []
-  const bound = Math.max(1, Math.min(limit, items.length))
-  let next = 0
-
-  async function worker(): Promise<void> {
-    while (true) {
-      const i = next++
-      if (i >= items.length) return
-      results[i] = await fn(items[i] as T, i)
-    }
-  }
-
-  await Promise.all(Array.from({ length: bound }, () => worker()))
-  return results
-}

package/src/lib/config.ts

@@ -1,57 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { dirname } from 'node:path'
-import { z } from 'zod'
-
-import { CONFIG_PATH } from '../state/index'
-import { AdminTargetConfigSchema, DEFAULT_ADMIN_TARGET_CONFIG } from './admin-target'
-import { log } from './log'
-
-/** A retention bound, or undefined when absent or nonsensical. A bad value must
- *  fall back to the default rather than take the whole config down with it —
- *  and must never read as "no limit". */
-const bound = z.number().positive().finite().optional().catch(undefined)
-
-export const AstraleConfigSchema = z.object({
-  issuer: z.string().url().default('https://unregistered.invalid'),
-  admin: AdminTargetConfigSchema.default(DEFAULT_ADMIN_TARGET_CONFIG),
-  // The retention bounds live in the schema, not just in the readers that
-  // consume them: zod strips unknown keys, so a config the CLI rewrites (see
-  // setup/steps/admin.ts) would silently drop anything declared elsewhere.
-  telemetry: z
-    .object({ enabled: z.boolean().default(true), maxAgeDays: bound, maxBytes: bound })
-    .default({ enabled: true }),
-  browser: z.object({ maxCacheBytes: bound, maxProfileAgeDays: bound }).default({}),
-})
-
-export type AstraleConfig = z.infer<typeof AstraleConfigSchema>
-
-export const DEFAULT_CONFIG: AstraleConfig = AstraleConfigSchema.parse({})
-
-export async function readConfig(): Promise<AstraleConfig> {
-  try {
-    const raw = await readFile(CONFIG_PATH, 'utf-8')
-    return AstraleConfigSchema.parse(JSON.parse(raw))
-  } catch (e) {
-    // A present-but-broken config (invalid JSON or failed validation) should
-    // surface; a missing file (readFile ENOENT) stays silent — that's the
-    // normal first-run case and defaults are expected.
-    if (e instanceof z.ZodError || e instanceof SyntaxError) {
-      log.warn(`Invalid config at ${CONFIG_PATH} — using defaults`)
-    }
-    return DEFAULT_CONFIG
-  }
-}
-
-export async function writeConfig(config: AstraleConfig): Promise<void> {
-  await mkdir(dirname(CONFIG_PATH), { recursive: true })
-  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
-}
-
-export async function configExists(): Promise<boolean> {
-  try {
-    await readFile(CONFIG_PATH)
-    return true
-  } catch {
-    return false
-  }
-}

package/src/lib/credential-lifetime.ts

@@ -1,24 +0,0 @@
-/** Whole seconds safely available after second-boundary rounding and carrier handoff. */
-export function remainingCredentialLifetimeSeconds(
-  expiresAtEpochSeconds: number,
-  nowEpochSeconds = Math.ceil(Date.now() / 1_000),
-): number {
-  if (!Number.isSafeInteger(expiresAtEpochSeconds) || !Number.isSafeInteger(nowEpochSeconds)) {
-    throw new TypeError('Credential expiration and current time must be safe epoch seconds.')
-  }
-  return expiresAtEpochSeconds - nowEpochSeconds - 1
-}
-
-export function credentialLifetimeCovers(
-  expiresAtEpochSeconds: number,
-  minimumRemainingSeconds: number,
-  nowEpochSeconds?: number,
-): boolean {
-  if (!Number.isSafeInteger(minimumRemainingSeconds) || minimumRemainingSeconds < 1) {
-    throw new TypeError('Credential minimum lifetime must be a positive safe integer.')
-  }
-  return (
-    remainingCredentialLifetimeSeconds(expiresAtEpochSeconds, nowEpochSeconds) >=
-    minimumRemainingSeconds
-  )
-}

package/src/lib/domain-publication.ts

@@ -1,104 +0,0 @@
-import { publication } from '@astrale-os/sdk/publication'
-
-const MAXIMUM_PUBLICATION_BYTES = 1024 * 1024
-type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-/** Fetch and admit one canonical Domain Publication without following its bundle. */
-export async function fetchDomainPublication(
-  input: string,
-  signal?: AbortSignal,
-  fetchImpl: FetchLike = globalThis.fetch,
-): Promise<publication.Publication> {
-  const url = domainPublicationUrl(input)
-  const response = await fetchImpl(url, {
-    redirect: 'error',
-    ...(signal === undefined ? {} : { signal }),
-  })
-  if (!response.ok) {
-    await cancel(response.body)
-    throw new Error(`GET ${url.href} → ${response.status}`)
-  }
-  const bytes = await readBounded(response, url)
-  try {
-    const source = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
-    return publication.accept(JSON.parse(source) as unknown)
-  } catch (cause) {
-    throw new Error(`GET ${url.href} returned an invalid Domain Publication`, { cause })
-  }
-}
-
-async function readBounded(response: Response, url: URL): Promise<Uint8Array> {
-  const declared = response.headers.get('content-length')
-  if (
-    declared !== null &&
-    (!/^\d+$/u.test(declared) ||
-      !Number.isSafeInteger(Number(declared)) ||
-      Number(declared) > MAXIMUM_PUBLICATION_BYTES)
-  ) {
-    await cancel(response.body)
-    throw sizeError(url)
-  }
-  if (response.body === null) return new Uint8Array()
-
-  const reader = response.body.getReader()
-  const chunks: Uint8Array[] = []
-  let size = 0
-  let complete = false
-  try {
-    for (;;) {
-      const next = await reader.read()
-      if (next.done) {
-        complete = true
-        break
-      }
-      if (next.value.byteLength === 0) continue
-      if (next.value.byteLength > MAXIMUM_PUBLICATION_BYTES - size) {
-        throw sizeError(url)
-      }
-      chunks.push(next.value)
-      size += next.value.byteLength
-    }
-  } finally {
-    if (!complete) await reader.cancel().catch(() => undefined)
-    reader.releaseLock()
-  }
-
-  const bytes = new Uint8Array(size)
-  let offset = 0
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset)
-    offset += chunk.byteLength
-  }
-  return bytes
-}
-
-function sizeError(url: URL): Error {
-  return new Error(`GET ${url.href} exceeded ${MAXIMUM_PUBLICATION_BYTES} bytes`)
-}
-
-async function cancel(body: ReadableStream<Uint8Array> | null): Promise<void> {
-  if (body !== null) await body.cancel().catch(() => undefined)
-}
-
-/** Canonical discovery document for a Domain origin or exact Publication URL. */
-export function domainPublicationUrl(input: string): URL {
-  let url: URL
-  try {
-    url = new URL(input)
-  } catch {
-    throw new TypeError(`Domain deployment URL is invalid: ${input}`)
-  }
-  if (
-    !['http:', 'https:'].includes(url.protocol) ||
-    url.username !== '' ||
-    url.password !== '' ||
-    url.search !== '' ||
-    url.hash !== '' ||
-    !['', '/', publication.PATH].includes(url.pathname)
-  ) {
-    throw new TypeError(
-      `Domain deployment URL must be an HTTP(S) origin or canonical Publication URL: ${input}`,
-    )
-  }
-  return new URL(publication.PATH, url.origin)
-}