@expandai/sdk 0.19.0 → 0.20.0

package/src/AppendixMarkers.ts

@@ -0,0 +1,370 @@
+// Appendix omission markers as they appear in Fetch Markdown.
+//
+// Mirrors `packages/core/src/Fetch/AppendixMarkers.ts` (the SDK cannot depend
+// on core). Keep the grammar in sync with the Rust emitter in
+// `native/expand-snapshot/src/markdown/pruner/appendix_markers.rs`.
+//
+// A marker is placed wherever block content renders, so it can arrive with a
+// blockquote or list-item prefix (`> [appendix omitted: …]`). Marker-shaped
+// lines inside fenced code are page text, not markers, and are left alone.
+//
+//   [appendix omitted: 14 links · ~320 tokens] {612}
+//   [appendix omitted: navigation — Home, News, Sport, +11 more · 14 links · ~320 tokens] {612}
+//   [appendix omitted: 7 more blocks · 41 links · ~2100 tokens]        (trailing fold; id is the first folded block when bound)
+
+import { Schema } from 'effect'
+
+export const APPENDIX_MARKER_PREFIX = '[appendix omitted: '
+
+export const AppendixMarkerLevel = Schema.Literal('off', 'compact', 'detailed')
+export type AppendixMarkerLevel = typeof AppendixMarkerLevel.Type
+
+const MARKER_LINE =
+	/^\[appendix omitted: (?:(?<more>\d+) more blocks? · |(?<label>[a-z]+)(?: — (?<preview>.+?))? · )?(?<links>\d+) links? · ~(?<tokens>\d+) tokens\](?: \{(?<id>\d+)\})?$/u
+
+/** One blockquote or list-item prefix, as Markdown renders it. */
+const CONTAINER_PREFIX = /^(?:> ?|[*+-][ \t]|\d+[.)][ \t])/u
+
+const FENCE_LINE = /^(`{3,}|~{3,})/u
+
+/** A list bullet or ordered-list number introducing an item. */
+const LIST_MARKER = /^(?:[*+-]|\d+[.)])(?=[ \t]|$)/u
+
+/**
+ * A marker rendered inside a blockquote or a list item carries that container's
+ * prefix (`> `, `- `, `1. `, and nestings of those). The Rust emitter places
+ * markers wherever block content renders, so consumers have to see through
+ * those prefixes or the marker reads as page content.
+ */
+function markerBody(line: string): string {
+	let rest = line.trimStart()
+	while (!rest.startsWith(APPENDIX_MARKER_PREFIX)) {
+		const prefix = CONTAINER_PREFIX.exec(rest)
+		if (!prefix) return rest
+		rest = rest.slice(prefix[0].length).trimStart()
+	}
+	return rest
+}
+
+interface OpenFence {
+	/** Blockquote nesting the fence opened at. */
+	readonly depth: number
+	/**
+	 * Content column of the list item the fence opened inside. A line that
+	 * dedents out of that item ends the block, closed or not — an unclosed fence
+	 * must not outlive its container.
+	 */
+	readonly itemContentColumn: number
+	/**
+	 * Column the fence started at. A closing delimiter may be indented up to
+	 * three columns further.
+	 */
+	readonly indent: number
+	readonly fenceChar: string
+	readonly run: number
+}
+
+interface ContainerPrefix {
+	readonly depth: number
+	/** Spaces before any container marker on this line. */
+	readonly rawIndent: number
+	/**
+	 * Column just after the last container marker, or `undefined` when the line
+	 * opens no container. Indentation past it is indented code *inside* that
+	 * container.
+	 */
+	readonly afterMarkers: number | undefined
+	/**
+	 * Column the outermost list marker starts at, or `Number.MAX_SAFE_INTEGER`
+	 * when the line opens no item. A continuation line may dedent to here
+	 * without leaving the item.
+	 */
+	readonly markerColumn: number
+	/**
+	 * Every item this line opens, outermost first, as the quote depth in force
+	 * where its marker stood and the content column it starts. `10. * nested`
+	 * opens two; `10. > quote` opens one at depth zero even though the line ends
+	 * inside a quote.
+	 */
+	readonly openedItems: { depth: number; column: number }[]
+	/** Columns consumed by indentation and container markers together. */
+	readonly column: number
+	readonly sawListMarker: boolean
+	readonly rest: string
+}
+
+/**
+ * The container markers a line opens with, and where they leave it.
+ *
+ * Blockquotes and list items nest in either order (`- > ```rust`), so the two
+ * are stripped in turn rather than one after the other. A `>` takes one
+ * optional space with it, which is the quote marker rather than indentation.
+ * A closing delimiter is read with `allowListMarkers` false: a bullet on a line
+ * *inside* a block is code, and reading it as container syntax ends the block.
+ */
+function containerPrefix(line: string, allowListMarkers: boolean): ContainerPrefix {
+	const rawIndent = leadingIndent(line, 0).columns
+	let rest = line
+	let depth = 0
+	let column = 0
+	let markerColumn = Number.MAX_SAFE_INTEGER
+	let afterMarkers: number | undefined
+	const openedItems: { depth: number; column: number }[] = []
+	let sawListMarker = false
+	for (;;) {
+		const { bytes, columns } = leadingIndent(rest, column)
+		rest = rest.slice(bytes)
+		column += columns
+		if (rest.startsWith('>')) {
+			depth += 1
+			const after = rest.slice(1).startsWith(' ') ? rest.slice(2) : rest.slice(1)
+			column += rest.length - after.length
+			rest = after
+			afterMarkers = column
+			continue
+		}
+		const { width, content } = allowListMarkers ? listMarkerWidth(rest, column) : { width: 0, content: rest }
+		if (width > 0) {
+			sawListMarker = true
+			markerColumn = Math.min(markerColumn, column)
+			column += width
+			rest = content
+			afterMarkers = column
+			openedItems.push({ depth, column })
+			continue
+		}
+		return { depth, rawIndent, afterMarkers, markerColumn, openedItems, column, sawListMarker, rest }
+	}
+}
+
+/**
+ * The column a line begins at for container purposes: its own list marker when
+ * it opens an item, otherwise its content.
+ */
+function startsAt(prefix: ContainerPrefix): number {
+	return prefix.sawListMarker ? prefix.markerColumn : prefix.column
+}
+
+/**
+ * Whether a line's content is an indented code block — four columns past
+ * whatever contains it. That is either the enclosing list item, for the
+ * indentation before this line's own markers, or the innermost marker this line
+ * opens, for the indentation after them.
+ */
+function isIndentedCode(prefix: ContainerPrefix, contentColumn: number): boolean {
+	const inside = Math.max(contentColumn, prefix.afterMarkers ?? 0)
+	return prefix.rawIndent >= contentColumn + 4 || prefix.column >= inside + 4
+}
+
+/**
+ * Bytes and columns taken by leading whitespace. A tab advances to the next
+ * four-column stop, as CommonMark counts it — code bodies are full of them, and
+ * reading one as no indentation puts a line outside its own block.
+ */
+function leadingIndent(rest: string, startColumn: number): { bytes: number; columns: number } {
+	let bytes = 0
+	let column = startColumn
+	for (const character of rest) {
+		if (character === ' ') column += 1
+		// A tab stop is measured from where the line already is, not from the
+		// start of the run.
+		else if (character === '\t') column += 4 - (column % 4)
+		else break
+		bytes += 1
+	}
+	return { bytes, columns: column - startColumn }
+}
+
+/** A run of three or more backticks or tildes at the start of `content`. */
+function fenceRun(content: string): { fenceChar: string; run: number } | undefined {
+	const match = FENCE_LINE.exec(content)?.[1]
+	return match === undefined ? undefined : { fenceChar: match[0], run: match.length }
+}
+
+/** Columns taken by a leading list marker, and the content after it. */
+function listMarkerWidth(rest: string, startColumn: number): { width: number; content: string } {
+	const marker = LIST_MARKER.exec(rest)?.[0]
+	if (marker === undefined) return { width: 0, content: rest }
+	const afterMarker = rest.slice(marker.length)
+	const padding = leadingIndent(afterMarker, startColumn + marker.length)
+	// More than four columns of padding is an indented code block inside the
+	// item, not a wider marker: the item's content starts one column past it.
+	if (padding.columns > 4) return { width: marker.length, content: afterMarker }
+	return { width: marker.length + padding.columns, content: rest.slice(marker.length + padding.bytes) }
+}
+
+/**
+ * The fence a line opens, if any. The caller has already established that the
+ * line is not indented code.
+ */
+function opensFence(prefix: ContainerPrefix, itemContentColumn: number): OpenFence | undefined {
+	const run = fenceRun(prefix.rest)
+	if (run === undefined) return undefined
+	// A backtick fence's info string may not contain a backtick, so ``` `` ``` is
+	// a paragraph with inline code in it, not a block that swallows what follows.
+	if (run.fenceChar === '`' && prefix.rest.slice(run.run).includes('`')) return undefined
+	return { depth: prefix.depth, indent: prefix.column, itemContentColumn, ...run }
+}
+
+/**
+ * A fence closes on a run of the same character, at least as long as the open,
+ * at the same blockquote depth and no more than three columns further in, with
+ * nothing but whitespace after it. Everything else inside the block — an info
+ * string, a `>`, a list bullet — is code.
+ */
+function closesFence(line: string, open: OpenFence): boolean {
+	const prefix = containerPrefix(line, false)
+	if (prefix.depth !== open.depth || prefix.column > open.indent + 3) return false
+	const run = fenceRun(prefix.rest)
+	if (run === undefined || run.fenceChar !== open.fenceChar || run.run < open.run) return false
+	return prefix.rest.slice(run.run).trim() === ''
+}
+
+/**
+ * Whether a line has stepped out of the list item a fence opened inside, which
+ * ends the block whether or not a closing delimiter ever arrived.
+ */
+function leavesFenceContainer(line: string, open: OpenFence): boolean {
+	if (open.itemContentColumn === 0 && open.depth === 0) return false
+	const prefix = containerPrefix(line, true)
+	if (prefix.rest.trim() === '' && !prefix.sawListMarker) return false
+	return prefix.depth < open.depth || startsAt(prefix) < open.itemContentColumn
+}
+
+/**
+ * Walk a body's lines, reporting each with the marker it carries, if any.
+ *
+ * The list items a line sits inside are tracked as a stack of their content
+ * columns, because that is the whole difference between four spaces meaning an
+ * indented code block and four spaces meaning ordinary item content — and a
+ * delimiter that is a fence in one is code in the other.
+ */
+function eachLine(
+	markdown: string,
+	visit: (line: string, marker: AppendixMarker | undefined, fenced: boolean) => void,
+): void {
+	// Blockquote depth and content column of each open item, outermost first. The
+	// depth matters because an item inside a quote ends when the quote does,
+	// however its columns compare.
+	const openItems: { depth: number; column: number }[] = []
+	let fence: OpenFence | undefined
+	for (const raw of markdown.split('\n')) {
+		// `lines()` in the Rust twin drops the carriage return; a body captured
+		// with CRLF must classify the same either way.
+		const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw
+		if (fence !== undefined) {
+			// A line that steps out of the fence's list item is not part of the
+			// block — the block ended above it — so it still has to be read.
+			if (leavesFenceContainer(line, fence)) {
+				fence = undefined
+			} else {
+				const closing = closesFence(line, fence)
+				if (closing) fence = undefined
+				// The delimiters belong to the document; only the body between them
+				// is code a consumer may drop.
+				visit(raw, undefined, !closing)
+				continue
+			}
+		}
+		const prefix = containerPrefix(line, true)
+		// A blank line neither opens nor closes a container, and the items it sits
+		// inside continue after it. An empty list item (`10.` with its content on a
+		// later line) looks blank once its marker is stripped, and is not.
+		if (prefix.rest.trim() === '' && !prefix.sawListMarker) {
+			visit(raw, undefined, false)
+			continue
+		}
+		while (openItems.length > 0) {
+			const innermost = openItems[openItems.length - 1]
+			if (innermost.depth <= prefix.depth && startsAt(prefix) >= innermost.column) break
+			openItems.pop()
+		}
+		const contentColumn = openItems[openItems.length - 1]?.column ?? 0
+		// An indented code block is not a list item, not a fence, and not a
+		// marker — it is code, whatever it looks like.
+		if (isIndentedCode(prefix, contentColumn)) {
+			visit(raw, undefined, false)
+			continue
+		}
+		for (const opened of prefix.openedItems) openItems.push(opened)
+		const opening = opensFence(prefix, openItems[openItems.length - 1]?.column ?? 0)
+		if (opening !== undefined) {
+			fence = opening
+			visit(raw, undefined, false)
+			continue
+		}
+		visit(raw, parseAppendixMarkerLine(line), false)
+	}
+}
+
+/**
+ * A body with the *contents* of fenced code removed, delimiters kept. Evidence
+ * ids inside a code example are page text, not citations — but a code block's
+ * own id rides on its opening fence, so the delimiters have to stay.
+ */
+export function withoutFencedCode(markdown: string): string {
+	const kept: string[] = []
+	eachLine(markdown, (line, _marker, fenced) => {
+		if (!fenced) kept.push(line)
+	})
+	return kept.join('\n')
+}
+
+export interface AppendixMarker {
+	/** Evidence id of the first omitted block; on the trailing fold marker, the first block of the first folded run. */
+	readonly evidenceId?: number
+	readonly links: number
+	readonly approxTokens: number
+	readonly label?: string
+	readonly preview?: string
+	/** On the trailing fold marker: how many further omitted runs it stands for. */
+	readonly moreBlocks?: number
+}
+
+export function isAppendixMarkerLine(line: string): boolean {
+	const body = markerBody(line)
+	return body.startsWith(APPENDIX_MARKER_PREFIX) && MARKER_LINE.test(body.trimEnd())
+}
+
+export function parseAppendixMarkerLine(line: string): AppendixMarker | undefined {
+	const groups = MARKER_LINE.exec(markerBody(line).trimEnd())?.groups
+	if (!groups) return undefined
+	const links = Number(groups.links)
+	const approxTokens = Number(groups.tokens)
+	if (!Number.isSafeInteger(links) || !Number.isSafeInteger(approxTokens)) return undefined
+	const evidenceId = groups.id === undefined ? undefined : Number(groups.id)
+	const moreBlocks = groups.more === undefined ? undefined : Number(groups.more)
+	return {
+		evidenceId: evidenceId !== undefined && Number.isSafeInteger(evidenceId) ? evidenceId : undefined,
+		links,
+		approxTokens,
+		label: groups.label,
+		preview: groups.preview,
+		moreBlocks: moreBlocks !== undefined && Number.isSafeInteger(moreBlocks) ? moreBlocks : undefined,
+	}
+}
+
+/**
+ * Remove marker paragraphs from a Markdown body. Markers are synthetic: they
+ * are never search snippets, never citable, and never scored by quality evals.
+ */
+export function stripAppendixMarkers(markdown: string): string {
+	if (!markdown.includes(APPENDIX_MARKER_PREFIX)) return markdown
+	const kept: string[] = []
+	eachLine(markdown, (line, marker) => {
+		if (!marker) kept.push(line)
+	})
+	return kept
+		.join('\n')
+		.replace(/\n{3,}/g, '\n\n')
+		.replace(/\n+$/u, '\n')
+}
+
+/** Every marker in a Markdown body, in document order. */
+export function parseAppendixMarkers(markdown: string): AppendixMarker[] {
+	const markers: AppendixMarker[] = []
+	eachLine(markdown, (_line, marker) => {
+		if (marker) markers.push(marker)
+	})
+	return markers
+}

package/src/Client.ts

@@ -1,4 +1,12 @@
+import { Undici } from '@effect/platform-node'
 import { Effect, Either, Exit, Layer } from 'effect'
+import {
+	type CrawlProjectionOptions,
+	type CrawlsClient,
+	makeCrawlProjectionsClient,
+	makeCrawlsClient,
+} from './Crawls.js'
+import { ExpandClientError } from './Error.js'
 import { InternalClient } from './Internal.js'
 import {
 	type BatchedParams,
@@ -13,11 +21,14 @@ import {
 	type FetchParams,
 	type FetchRequestOptions,
 	type FetchResponse,
-	type FetchSearchParams,
-	type FetchSearchResponse,
 	type GetBatchedParams,
 	type GetBatchedResponse,
 	type RequestOptions,
+	type SnapshotCatalog,
+	type SnapshotCatalogParams,
+	type SnapshotGetParams,
+	type SnapshotHighlightsParams,
+	type SnapshotHighlightsResponse,
 } from './Service.js'
 
 export type {
@@ -31,15 +42,55 @@ export type {
 	FetchParams,
 	FetchRequestOptions,
 	FetchResponse,
-	FetchSearchParams,
-	FetchSearchResponse,
 	GetBatchedParams,
 	GetBatchedResponse,
+	SnapshotCatalog,
+	SnapshotCatalogParams,
+	SnapshotGetParams,
+	SnapshotHighlightsParams,
+	SnapshotHighlightsResponse,
 } from './Service.js'
 
 /** Options for constructing an {@link ExpandClient}. Same shape as `ExpandServiceOptions`. */
 export type ExpandClientOptions = ExpandServiceOptions
 
+export class SnapshotService {
+	constructor(
+		private readonly baseUrl: string,
+		private readonly readSnapshot: (
+			params: SnapshotGetParams,
+			options?: RequestOptions,
+		) => Promise<SnapshotCatalog | SnapshotHighlightsResponse>,
+	) {}
+
+	/** Read the public catalog, or request authenticated, billed Highlights from this Snapshot. */
+	get(params: SnapshotHighlightsParams, options?: RequestOptions): Promise<SnapshotHighlightsResponse>
+	get(params: SnapshotCatalogParams, options?: RequestOptions): Promise<SnapshotCatalog>
+	get(params: SnapshotGetParams, options?: RequestOptions): Promise<SnapshotCatalog | SnapshotHighlightsResponse>
+	get(params: SnapshotGetParams, options: RequestOptions = {}): Promise<SnapshotCatalog | SnapshotHighlightsResponse> {
+		return this.readSnapshot(params, options)
+	}
+
+	async network(params: { readonly snapshotId: string; readonly q?: string }): Promise<unknown> {
+		return this.request(`${params.snapshotId}/network${params.q ? `?q=${encodeURIComponent(params.q)}` : ''}`)
+	}
+
+	async preview(params: {
+		readonly snapshotId: string
+		readonly artifactId: string
+		readonly maxBytes?: number
+	}): Promise<unknown> {
+		const suffix = `/artifacts/${encodeURIComponent(params.artifactId)}/preview${params.maxBytes !== undefined ? `?maxBytes=${params.maxBytes}` : ''}`
+		return this.request(`${params.snapshotId}${suffix}`)
+	}
+
+	private async request<T>(path: string): Promise<T> {
+		const response = await globalThis.fetch(`${this.baseUrl.replace(/\/+$/u, '')}/v1/public/snapshots/${path}`)
+		if (!response.ok) throw new Error(`Snapshot request failed with HTTP ${response.status}`)
+		return (await response.json()) as T
+	}
+}
+
 /**
  * Promise-based client for the Expand API. Holds an {@link InternalClient} layer and runs Effects
  * against it, translating typed failures into the `ExpandClient*Error` hierarchy that async/await
@@ -53,6 +104,18 @@ export type ExpandClientOptions = ExpandServiceOptions
  */
 export class ExpandClient {
 	private readonly layer: Layer.Layer<InternalClient>
+	private readonly lifetime = new AbortController()
+	private readonly activeRequests = new Set<Promise<unknown>>()
+	private dispatcher?: Undici.EnvHttpProxyAgent
+	private closePromise?: Promise<void>
+	/** Create, list and control crawls, and read their event streams. */
+	readonly crawls: CrawlsClient
+	/** Read stored crawl captures: Markdown, HTML, State JSON and evidence. */
+	readonly captures: ReturnType<typeof makeCrawlProjectionsClient>['captures']
+	/** Read a crawled page's versions and diffs. */
+	readonly pages: ReturnType<typeof makeCrawlProjectionsClient>['pages']
+	readonly snapshots: SnapshotService
+	private readonly projections: ReturnType<typeof makeCrawlProjectionsClient>
 
 	constructor(options: ExpandClientOptions = {}) {
 		// Eagerly validate so the Promise constructor matches the documented sync-throw contract.
@@ -65,6 +128,47 @@ export class ExpandClient {
 		// Layer.orDie narrows the error channel to `never` while keeping a die fallback as a defensive
 		// net (translateCause picks up dies via Cause.dieOption and converts via toPublicError).
 		this.layer = InternalClient.layer(options).pipe(Layer.orDie)
+		const apiKey = options.apiKey ?? process.env.EXPAND_API_KEY
+		if (apiKey === undefined) throw new Error('Missing Expand API key.')
+		const proxyAwareFetch: typeof globalThis.fetch = (input, init) => {
+			if (this.lifetime.signal.aborted) {
+				const reason: unknown = this.lifetime.signal.reason
+				return Promise.reject(reason instanceof Error ? reason : new ExpandClientError('The Expand client is closed.'))
+			}
+			this.dispatcher ??= new Undici.EnvHttpProxyAgent()
+			const requestSignal = init?.signal === undefined && input instanceof Request ? input.signal : init?.signal
+			const signal = AbortSignal.any([this.lifetime.signal, ...(requestSignal == null ? [] : [requestSignal])])
+			const proxyInit: RequestInit & { readonly dispatcher: Undici.Dispatcher } = {
+				...init,
+				signal,
+				dispatcher: this.dispatcher,
+			}
+			return globalThis.fetch(input, proxyInit)
+		}
+		const transport = {
+			apiKey,
+			baseUrl: options.baseUrl ?? 'https://api.expand.ai',
+			fetch: proxyAwareFetch,
+			timeoutMs: options.timeoutMs,
+			maxRetries: options.maxRetries,
+			signal: this.lifetime.signal,
+		}
+		this.crawls = makeCrawlsClient(transport)
+		this.projections = makeCrawlProjectionsClient(transport)
+		this.captures = this.projections.captures
+		this.pages = this.projections.pages
+		this.snapshots = new SnapshotService(options.baseUrl ?? 'https://api.expand.ai', (params, requestOptions) =>
+			this.run((client) => client.getSnapshot(params, requestOptions)),
+		)
+	}
+
+	/** Abort active requests and release this client's HTTP connections. Repeated calls are safe. */
+	close(): Promise<void> {
+		if (!this.lifetime.signal.aborted) this.lifetime.abort(new ExpandClientError('The Expand client is closed.'))
+		this.closePromise ??= Promise.all([...this.activeRequests, this.dispatcher?.destroy() ?? Promise.resolve()]).then(
+			() => undefined,
+		)
+		return this.closePromise
 	}
 
 	/**
@@ -83,18 +187,18 @@ export class ExpandClient {
 	 * Fetch a URL through the object-mode endpoint.
 	 *
 	 * Returns `{ meta, markdown, json }`; use {@link fetch} for the raw markdown document.
+	 * A string argument instead reads an existing JSON projection from this API without starting a capture.
 	 */
-	async fetchJson(params: FetchJsonParams, options: FetchJsonRequestOptions = {}): Promise<FetchJsonResponse> {
+	fetchJson(params: FetchJsonParams, options?: FetchJsonRequestOptions): Promise<FetchJsonResponse>
+	fetchJson(url: string, options?: CrawlProjectionOptions): Promise<unknown>
+	async fetchJson(
+		params: FetchJsonParams | string,
+		options: FetchJsonRequestOptions & CrawlProjectionOptions = {},
+	): Promise<unknown> {
+		if (typeof params === 'string') return this.projections.fetchJson(params, options)
 		return this.run((client) => client.fetchJson(params, options))
 	}
 
-	/**
-	 * Search a previous Fetch response by `snapshotId` without starting a new capture.
-	 */
-	async fetchSearch(params: FetchSearchParams, options: RequestOptions = {}): Promise<FetchSearchResponse> {
-		return this.run((client) => client.fetchSearch(params, options))
-	}
-
 	/**
 	 * Kick off an asynchronous batched fetch over one or more URLs. Returns a batched-run ID that can
 	 * be polled via {@link getBatched}.
@@ -132,10 +236,21 @@ export class ExpandClient {
 	}
 
 	private async run<A>(body: (ic: InternalClient) => Effect.Effect<A, Error>): Promise<A> {
-		const exit = await Effect.runPromiseExit(InternalClient.use(body).pipe(Effect.provide(this.layer)))
-		if (Exit.isSuccess(exit)) {
-			return exit.value
+		this.lifetime.signal.throwIfAborted()
+		const running = Effect.runPromiseExit(InternalClient.use(body).pipe(Effect.provide(this.layer)), {
+			signal: this.lifetime.signal,
+		})
+		this.activeRequests.add(running)
+		try {
+			const exit = await running
+			this.lifetime.signal.throwIfAborted()
+			if (Exit.isSuccess(exit)) return exit.value
+			throw InternalClient.translateCause(exit.cause)
+		} finally {
+			this.activeRequests.delete(running)
 		}
-		throw InternalClient.translateCause(exit.cause)
 	}
 }
+
+/** Concise public name used by the Crawl API examples. */
+export class Expand extends ExpandClient {}