@comms-id/asx 0.4.0 → 0.4.2

package/dist/collection.js

@@ -0,0 +1,194 @@
+import { Effect, Result, Schema } from "effect";
+import { DirectoryEntry, failure, Failure, LiveOutcome, Timestamp } from "./model.js";
+import { EnrichmentResult } from "./enrichment.js";
+import { applyRefresh, RefreshAttempt } from "./refresh.js";
+import { asxSourceObservation, decodeCompanySources, mergeCompanySources, } from "./source-record.js";
+const Checkpoint = Schema.Struct({
+    formatVersion: Schema.Literal(1),
+    runId: Schema.String.check(Schema.isPattern(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/)),
+    baseGeneration: Schema.NullOr(Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/))),
+    directory: Schema.Struct({ entries: Schema.Array(DirectoryEntry), observedAt: Timestamp }),
+    attempts: Schema.Array(RefreshAttempt),
+});
+/** Validate persisted progress before resuming; the directory and completed prefix cannot diverge. */
+export function decodeRefreshCheckpoint(input) {
+    const decoded = Schema.decodeUnknownResult(Checkpoint)(input);
+    if (Result.isFailure(decoded))
+        throw failure("PARSE_FAILED");
+    const checkpoint = decoded.success;
+    if (checkpoint.attempts.length > checkpoint.directory.entries.length ||
+        checkpoint.attempts.some((attempt, index) => attempt.ticker !== checkpoint.directory.entries[index].ticker))
+        throw failure("SOURCE_MISMATCH");
+    // The same publication validation owns both complete and unfinished passes.
+    applyRefresh(null, checkpoint.directory, [
+        ...checkpoint.attempts,
+        ...checkpoint.directory.entries
+            .slice(checkpoint.attempts.length)
+            .map((entry) => ({ ticker: entry.ticker, outcome: failure("UPSTREAM_UNAVAILABLE") })),
+    ]);
+    return structuredClone(checkpoint);
+}
+const sourceError = (error) => Schema.is(Failure)(error) ? failure(error.code) : failure("TRANSPORT_FAILED");
+const begin = Effect.fn("ASX.collection.begin")(function* (source, baseGeneration) {
+    if (baseGeneration !== null && !/^[a-f0-9]{64}$/.test(baseGeneration))
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    const directory = yield* Effect.tryPromise({ try: source.directory, catch: sourceError });
+    return yield* Effect.try({
+        try: () => decodeRefreshCheckpoint({
+            formatVersion: 1,
+            runId: crypto.randomUUID(),
+            baseGeneration,
+            directory,
+            attempts: [],
+        }),
+        catch: (error) => (Schema.is(Failure)(error) ? error : failure("PARSE_FAILED")),
+    });
+});
+const batch = Effect.fn("ASX.collection.batch")(function* (source, input, batchSize, intervalMs) {
+    if (!Number.isInteger(batchSize) ||
+        batchSize < 1 ||
+        batchSize > 100 ||
+        !Number.isInteger(intervalMs) ||
+        intervalMs < 0 ||
+        intervalMs > 60_000)
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    const checkpoint = yield* Effect.try({
+        try: () => decodeRefreshCheckpoint(input),
+        catch: sourceError,
+    });
+    const attempts = [...checkpoint.attempts];
+    const entries = checkpoint.directory.entries.slice(attempts.length, attempts.length + batchSize);
+    for (const entry of entries) {
+        // Delay before each call also bounds consecutive resumed batches. Host chooses the permitted rate.
+        if (intervalMs > 0)
+            yield* Effect.sleep(intervalMs);
+        const profile = Effect.tryPromise({
+            try: (signal) => source.lookup(entry.ticker, signal),
+            catch: sourceError,
+        }).pipe(Effect.result);
+        const collectSources = source.collectSources;
+        const [result, collectedSources] = yield* Effect.all([
+            profile,
+            collectSources
+                ? Effect.tryPromise({
+                    try: async (signal) => decodeCompanySources(await collectSources(entry, signal), entry.ticker),
+                    catch: sourceError,
+                }).pipe(Effect.result)
+                : Effect.succeed(Result.succeed({})),
+        ], { concurrency: 2 });
+        // Profile-source acquisition failures do not discard ASX or block the next issuer.
+        let sources = collectSources && Result.isSuccess(collectedSources) ? collectedSources.success : undefined;
+        let outcome;
+        if (Result.isFailure(result)) {
+            // Permission/configuration failures stop collection instead of producing thousands of failed calls.
+            if ([
+                "ACCESS_DENIED",
+                "CONFIGURATION_ERROR",
+                "CANCELLED",
+                "UPSTREAM_REJECTED",
+                "RATE_LIMITED",
+            ].includes(result.failure.code))
+                return { checkpoint: { ...checkpoint, attempts }, complete: false, halted: result.failure };
+            outcome = result.failure;
+        }
+        else {
+            const decoded = Schema.decodeUnknownResult(LiveOutcome)(result.success);
+            outcome = Result.isFailure(decoded) ? failure("PARSE_FAILED") : decoded.success;
+            // Validate each result at the existing publication boundary; bad identity cannot be retained as success.
+            try {
+                applyRefresh(null, { entries: [entry], observedAt: checkpoint.directory.observedAt }, [
+                    { ticker: entry.ticker, outcome },
+                ]);
+            }
+            catch (error) {
+                outcome = Schema.is(Failure)(error) ? failure(error.code) : failure("PARSE_FAILED");
+            }
+        }
+        if (!("_tag" in outcome) &&
+            (outcome.status === "found" ? outcome.observation.company.raw : outcome.raw)) {
+            sources = mergeCompanySources(entry.ticker, sources ?? {}, {
+                asx: asxSourceObservation(entry.ticker, outcome),
+            });
+        }
+        let enrichment;
+        const storeSources = source.storeSources;
+        if (sources && storeSources) {
+            const observations = sources;
+            yield* Effect.tryPromise({
+                try: (signal) => storeSources(entry, observations, signal),
+                catch: sourceError,
+            });
+        }
+        if (source.enrich && !("_tag" in outcome) && outcome.status === "found") {
+            const company = outcome.observation.company;
+            const enrich = source.enrich;
+            const result = yield* Effect.tryPromise({
+                try: (signal) => enrich(company, signal, sources),
+                catch: sourceError,
+            }).pipe(Effect.result);
+            if (Result.isFailure(result)) {
+                if ([
+                    "ACCESS_DENIED",
+                    "CONFIGURATION_ERROR",
+                    "CANCELLED",
+                    "UPSTREAM_REJECTED",
+                    "RATE_LIMITED",
+                ].includes(result.failure.code))
+                    return {
+                        checkpoint: { ...checkpoint, attempts },
+                        complete: false,
+                        halted: result.failure,
+                    };
+                enrichment = result.failure;
+            }
+            else {
+                const decoded = Schema.decodeUnknownResult(EnrichmentResult)(result.success);
+                enrichment = Result.isFailure(decoded)
+                    ? { status: "unresolved", reason: "INVALID_EVIDENCE" }
+                    : decoded.success;
+                try {
+                    applyRefresh(null, { entries: [entry], observedAt: checkpoint.directory.observedAt }, [
+                        { ticker: entry.ticker, outcome, enrichment },
+                    ]);
+                }
+                catch {
+                    enrichment = { status: "unresolved", reason: "INVALID_EVIDENCE" };
+                }
+            }
+        }
+        attempts.push({
+            ticker: entry.ticker,
+            outcome,
+            ...(enrichment ? { enrichment } : {}),
+            ...(sources && !storeSources ? { sources } : {}),
+        });
+    }
+    const next = { ...checkpoint, attempts };
+    return {
+        checkpoint: next,
+        complete: attempts.length === checkpoint.directory.entries.length,
+        halted: null,
+    };
+});
+async function run(program, signal) {
+    try {
+        const result = await Effect.runPromise(Effect.result(program), { signal });
+        if (Result.isFailure(result))
+            throw result.failure;
+        return result.success;
+    }
+    catch (error) {
+        throw signal?.aborted
+            ? failure("CANCELLED")
+            : Schema.is(Failure)(error)
+                ? error
+                : failure("INTERNAL_ERROR");
+    }
+}
+/** The host owns source permission, durable checkpoints, scheduling and publication after completion. */
+export function createRefreshCollector(source) {
+    return {
+        begin: (baseGeneration, signal) => run(begin(source, baseGeneration), signal),
+        batch: (checkpoint, options) => run(batch(source, checkpoint, options.batchSize, options.intervalMs), options.signal),
+    };
+}

package/dist/company-events.d.ts

@@ -0,0 +1,2 @@
+import type { CompanyEvent, CompanyStreamMode } from "./company-stream.js";
+export declare function decodeCompanyEvent(input: unknown, ticker: string, mode: CompanyStreamMode): CompanyEvent;

package/dist/company-events.js

@@ -0,0 +1,48 @@
+import { Result, Schema } from "effect";
+import { failure, Failure, Ticker, validObservation } from "./model.js";
+import { CompanyRecord } from "./snapshot.js";
+import { SourceName, SourceObservation, decodeCompanySources, decodeSourceObservation, } from "./source-record.js";
+const Event = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("snapshot"),
+        source: Schema.Literal("snapshot"),
+        ticker: Ticker,
+        generation: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)),
+        record: Schema.NullOr(CompanyRecord),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("source"),
+        source: SourceName,
+        ticker: Ticker,
+        observation: SourceObservation,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("error"),
+        source: Schema.Union([SourceName, Schema.Literal("snapshot")]),
+        ticker: Ticker,
+        operation: Schema.Literals(["read", "persist"]),
+        error: Failure,
+    }),
+    Schema.Struct({ type: Schema.Literal("complete"), ticker: Ticker }),
+]);
+export function decodeCompanyEvent(input, ticker, mode) {
+    const decoded = Schema.decodeUnknownResult(Event)(input);
+    if (Result.isFailure(decoded))
+        throw failure("PARSE_FAILED");
+    const event = decoded.success;
+    if (event.ticker !== ticker ||
+        (mode === "snapshot" && event.type !== "complete" && event.source !== "snapshot"))
+        throw failure("SOURCE_MISMATCH");
+    if (event.type === "source")
+        decodeSourceObservation(event.observation, ticker, event.source);
+    if (event.type === "snapshot" && event.record) {
+        const record = event.record;
+        if (record.directory.ticker !== ticker ||
+            (record.observation &&
+                (record.observation.company.ticker !== ticker || !validObservation(record.observation))))
+            throw failure("SOURCE_MISMATCH");
+        if (record.sources)
+            decodeCompanySources(record.sources, ticker);
+    }
+    return event;
+}

package/dist/company-record.d.ts

@@ -0,0 +1,4 @@
+import type { CompanyRecord } from "./snapshot.js";
+import { type CompanySources } from "./source-record.js";
+/** Reconcile a newer saved ASX result before exposing a row or using outage fallback. */
+export declare function mergeCompanyRecord(record: CompanyRecord, incoming: CompanySources): CompanyRecord;

package/dist/company-record.js

@@ -0,0 +1,60 @@
+import { validEnrichment } from "./enrichment.js";
+import { failure } from "./model.js";
+import { parseCompany } from "./parse.js";
+import { mergeCompanySources } from "./source-record.js";
+/** Reconcile a newer saved ASX result before exposing a row or using outage fallback. */
+export function mergeCompanyRecord(record, incoming) {
+    const ticker = record.directory.ticker;
+    const sources = mergeCompanySources(ticker, record.sources ?? {}, incoming);
+    const asx = sources.asx;
+    const prior = record.observation ?? record.missingAt;
+    if (!asx ||
+        (prior &&
+            (asx.startedAt < prior.startedAt ||
+                (asx.startedAt === prior.startedAt && asx.observedAt <= prior.observedAt)))) {
+        if (asx?.status === "found" &&
+            record.observation &&
+            asx.sourceId !== record.observation.company.sourceId) {
+            return Object.assign({}, structuredClone(record), { sources: {} });
+        }
+        return Object.assign({}, structuredClone(record), { sources });
+    }
+    if (asx.status === "missing")
+        return {
+            directory: structuredClone(record.directory),
+            sources,
+            observation: null,
+            missingAt: { startedAt: asx.startedAt, observedAt: asx.observedAt },
+            ...(record.abnNameMatch ? { abnNameMatch: structuredClone(record.abnNameMatch) } : {}),
+        };
+    const company = parseCompany(ticker, asx.payload);
+    if (company.sourceId !== asx.sourceId)
+        throw failure("SOURCE_MISMATCH");
+    const changedIssuer = record.observation && record.observation.company.sourceId !== company.sourceId;
+    const currentSources = changedIssuer
+        ? {
+            asx,
+            ...(sources.morningstar && sources.morningstar.startedAt >= asx.startedAt
+                ? { morningstar: sources.morningstar }
+                : {}),
+            ...(sources["google-finance"] && sources["google-finance"].startedAt >= asx.startedAt
+                ? { "google-finance": sources["google-finance"] }
+                : {}),
+        }
+        : sources;
+    const unchanged = record.observation && JSON.stringify(company) === JSON.stringify(record.observation.company);
+    return {
+        directory: structuredClone(record.directory),
+        sources: currentSources,
+        observation: {
+            company,
+            startedAt: asx.startedAt,
+            observedAt: asx.observedAt,
+            lastChangedAt: unchanged && record.observation ? record.observation.lastChangedAt : asx.observedAt,
+        },
+        ...(record.enrichment && validEnrichment(record.enrichment, company)
+            ? { enrichment: structuredClone(record.enrichment) }
+            : {}),
+        ...(record.abnNameMatch ? { abnNameMatch: structuredClone(record.abnNameMatch) } : {}),
+    };
+}

package/dist/company-stream-client.d.ts

@@ -0,0 +1,4 @@
+import type { AsxClientConfig } from "./client.js";
+import type { CompanyEvent, CompanyStreamOptions } from "./company-stream.js";
+/** NDJSON facade: each validated event is yielded as soon as it arrives. */
+export declare function createCompanyStreamClient(config: AsxClientConfig, base: URL): (input: string, options?: CompanyStreamOptions) => AsyncGenerator<CompanyEvent>;

package/dist/company-stream-client.js

@@ -0,0 +1,139 @@
+import { Effect, Result, Schema } from "effect";
+import { failure, Failure } from "./model.js";
+import { normalizeTicker } from "./parse.js";
+import { decodeCompanyEvent } from "./company-events.js";
+/** NDJSON facade: each validated event is yielded as soon as it arrives. */
+export function createCompanyStreamClient(config, base) {
+    return async function* observe(input, options = {}) {
+        const ticker = normalizeTicker(input);
+        const mode = options.mode ?? "revalidate";
+        if (!["snapshot", "revalidate", "all-live"].includes(mode))
+            throw failure("INVALID_INPUT");
+        const cancelled = new AbortController();
+        const deadline = AbortSignal.timeout(config.timeoutMs ?? 60_000);
+        const signal = AbortSignal.any([
+            cancelled.signal,
+            deadline,
+            ...(options.signal ? [options.signal] : []),
+        ]);
+        let reader;
+        const abort = () => {
+            void reader?.cancel().catch(() => undefined);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+            signal.throwIfAborted();
+            const opened = await Effect.runPromise(Effect.result(Effect.tryPromise({
+                try: async (requestSignal) => {
+                    const combined = AbortSignal.any([signal, requestSignal]);
+                    const token = await config.capability(combined);
+                    combined.throwIfAborted();
+                    if (typeof token !== "string" ||
+                        !token.trim() ||
+                        token.length > 8192 ||
+                        /\s/.test(token.trim()))
+                        throw failure("CONFIGURATION_ERROR");
+                    return (config.fetch ?? globalThis.fetch)(new URL("company/stream", base), {
+                        method: "POST",
+                        body: JSON.stringify({ ticker, mode }),
+                        signal: combined,
+                        redirect: "manual",
+                        cache: "no-store",
+                        headers: {
+                            authorization: `Bearer ${token.trim()}`,
+                            "content-type": "application/json",
+                            accept: "application/x-ndjson",
+                        },
+                    });
+                },
+                catch: (error) => (Schema.is(Failure)(error) ? error : failure("TRANSPORT_FAILED")),
+            }).pipe(Effect.timeoutOrElse({
+                duration: config.timeoutMs ?? 60_000,
+                orElse: () => Effect.fail(failure("TIMEOUT")),
+            }))), { signal });
+            if (Result.isFailure(opened))
+                throw opened.failure;
+            const response = opened.success;
+            if (!response.ok ||
+                !response.headers.get("content-type")?.startsWith("application/x-ndjson") ||
+                !response.body) {
+                await response.body?.cancel();
+                throw failure(response.status === 401 || response.status === 403
+                    ? "ACCESS_DENIED"
+                    : response.status === 429
+                        ? "RATE_LIMITED"
+                        : "UPSTREAM_UNAVAILABLE");
+            }
+            reader = response.body.getReader();
+            const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+            let buffer = "";
+            let bytes = 0;
+            let count = 0;
+            let complete = false;
+            const seen = new Set();
+            for (;;) {
+                signal.throwIfAborted();
+                const next = await reader.read();
+                signal.throwIfAborted();
+                if (next.done)
+                    break;
+                bytes += next.value.byteLength;
+                if (bytes > 16 * 1024 * 1024)
+                    throw failure("PARSE_FAILED");
+                buffer += decoder.decode(next.value, { stream: true });
+                let end;
+                while ((end = buffer.indexOf("\n")) !== -1) {
+                    const line = buffer.slice(0, end);
+                    buffer = buffer.slice(end + 1);
+                    if (complete || !line || ++count > 12 || line.length > 4 * 1024 * 1024)
+                        throw failure("PARSE_FAILED");
+                    let payload;
+                    try {
+                        payload = JSON.parse(line);
+                    }
+                    catch {
+                        throw failure("PARSE_FAILED");
+                    }
+                    const event = decodeCompanyEvent(payload, ticker, mode);
+                    const key = event.type === "source"
+                        ? `source:${event.source}`
+                        : event.type === "snapshot"
+                            ? "snapshot"
+                            : null;
+                    if (key && seen.has(key))
+                        throw failure("PARSE_FAILED");
+                    if (key)
+                        seen.add(key);
+                    complete = event.type === "complete";
+                    yield event;
+                }
+                if (buffer.length > 4 * 1024 * 1024)
+                    throw failure("PARSE_FAILED");
+            }
+            buffer += decoder.decode();
+            if (!complete || buffer.length)
+                throw failure("PARSE_FAILED");
+        }
+        catch (error) {
+            throw options.signal?.aborted
+                ? failure("CANCELLED")
+                : deadline.aborted
+                    ? failure("TIMEOUT")
+                    : Schema.is(Failure)(error)
+                        ? error
+                        : failure("TRANSPORT_FAILED");
+        }
+        finally {
+            signal.removeEventListener("abort", abort);
+            cancelled.abort();
+            if (reader) {
+                try {
+                    await reader.cancel();
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+        }
+    };
+}

package/dist/company-stream.d.ts

@@ -0,0 +1,46 @@
+import { type AsxError } from "./model.js";
+import { CompanyRecord } from "./snapshot.js";
+import { type SourceName, type SourceObservation } from "./source-record.js";
+export type CompanyStreamMode = "snapshot" | "revalidate" | "all-live";
+export type CompanyEvent = {
+    readonly type: "snapshot";
+    readonly source: "snapshot";
+    readonly ticker: string;
+    readonly generation: string;
+    readonly record: CompanyRecord | null;
+} | {
+    readonly type: "source";
+    readonly source: SourceName;
+    readonly ticker: string;
+    readonly observation: SourceObservation;
+} | {
+    readonly type: "error";
+    readonly source: SourceName | "snapshot";
+    readonly ticker: string;
+    readonly operation: "read" | "persist";
+    readonly error: AsxError;
+} | {
+    readonly type: "complete";
+    readonly ticker: string;
+};
+export interface CompanyStreamSources {
+    readonly snapshot: (ticker: string, signal: AbortSignal) => Promise<{
+        readonly generation: string;
+        readonly record: CompanyRecord | null;
+    }>;
+    readonly live: Partial<Record<SourceName, (ticker: string, signal: AbortSignal) => Promise<unknown>>>;
+    /** Host-owned conditional merge. A completed live result is emitted before this is awaited. */
+    readonly persist?: (observation: SourceObservation, signal: AbortSignal) => Promise<void>;
+}
+export interface CompanyStreamOptions {
+    readonly mode?: CompanyStreamMode;
+    readonly signal?: AbortSignal;
+}
+/** Independent source streams; completion order never establishes field precedence. */
+export declare function createCompanyStream(sources: CompanyStreamSources, config?: {
+    readonly timeoutMs?: number;
+    readonly refreshAfterMs?: number;
+    readonly now?: () => number;
+}): {
+    observe(this: void, input: string, options?: CompanyStreamOptions): AsyncIterable<CompanyEvent>;
+};

package/dist/company-stream.js

@@ -0,0 +1,117 @@
+import { Effect, Result, Schema, Stream } from "effect";
+import { failure, Failure, validObservation } from "./model.js";
+import { normalizeTicker } from "./parse.js";
+import { CompanyRecord } from "./snapshot.js";
+import { decodeCompanySources, decodeSourceObservation, SOURCE_NAMES, } from "./source-record.js";
+const safe = (error) => Schema.is(Failure)(error) ? failure(error.code) : failure("TRANSPORT_FAILED");
+/** Independent source streams; completion order never establishes field precedence. */
+export function createCompanyStream(sources, config = {}) {
+    const timeoutMs = config.timeoutMs ?? 15_000;
+    const refreshAfterMs = config.refreshAfterMs ?? 86_400_000;
+    const now = config.now ?? Date.now;
+    if (!Number.isInteger(timeoutMs) ||
+        timeoutMs < 1 ||
+        timeoutMs > 60_000 ||
+        !Number.isInteger(refreshAfterMs) ||
+        refreshAfterMs < 1)
+        throw failure("CONFIGURATION_ERROR");
+    const io = (operation) => Effect.tryPromise({ try: operation, catch: safe }).pipe(Effect.timeoutOrElse({ duration: timeoutMs, orElse: () => Effect.fail(failure("TIMEOUT")) }));
+    return {
+        observe(input, options = {}) {
+            const ticker = normalizeTicker(input);
+            const mode = options.mode ?? "revalidate";
+            if (!["snapshot", "revalidate", "all-live"].includes(mode))
+                throw failure("INVALID_INPUT");
+            if (options.signal?.aborted)
+                throw failure("CANCELLED");
+            const stream = Stream.unwrap(Effect.gen(function* () {
+                const saved = yield* Effect.cached(io(async (signal) => {
+                    const saved = await sources.snapshot(ticker, signal).catch((error) => {
+                        throw Schema.is(Failure)(error) ? error : failure("SNAPSHOT_UNAVAILABLE");
+                    });
+                    if (!/^[a-f0-9]{64}$/.test(saved.generation))
+                        throw failure("SNAPSHOT_UNAVAILABLE");
+                    const record = saved.record;
+                    if (record === null)
+                        return { generation: saved.generation, record: null };
+                    const result = Schema.decodeUnknownResult(CompanyRecord)(record);
+                    if (Result.isFailure(result))
+                        throw failure("SNAPSHOT_UNAVAILABLE");
+                    if (result.success.directory.ticker !== ticker ||
+                        (result.success.observation &&
+                            (!validObservation(result.success.observation) ||
+                                result.success.observation.company.ticker !== ticker)))
+                        throw failure("SOURCE_MISMATCH");
+                    if (result.success.sources)
+                        decodeCompanySources(result.success.sources, ticker);
+                    return { generation: saved.generation, record: structuredClone(result.success) };
+                }).pipe(Effect.result));
+                const snapshot = Stream.fromEffect(saved).pipe(Stream.map((result) => Result.isSuccess(result)
+                    ? { type: "snapshot", source: "snapshot", ticker, ...result.success }
+                    : {
+                        type: "error",
+                        source: "snapshot",
+                        ticker,
+                        operation: "read",
+                        error: result.failure,
+                    }));
+                if (mode === "snapshot")
+                    return snapshot;
+                const live = SOURCE_NAMES.map((source) => Stream.unwrap(Effect.gen(function* () {
+                    if (mode === "revalidate" && source !== "asx") {
+                        const result = yield* saved;
+                        const prior = Result.isSuccess(result)
+                            ? result.success.record?.sources?.[source]
+                            : undefined;
+                        const age = prior ? now() - Date.parse(prior.observedAt) : Infinity;
+                        if (age >= 0 && age < refreshAfterMs)
+                            return Stream.empty;
+                    }
+                    const lookup = sources.live[source];
+                    const result = yield* (lookup
+                        ? io(async (signal) => decodeSourceObservation(await lookup(ticker, signal), ticker, source))
+                        : Effect.fail(failure("CONFIGURATION_ERROR"))).pipe(Effect.result);
+                    if (Result.isFailure(result))
+                        return Stream.succeed({
+                            type: "error",
+                            source,
+                            ticker,
+                            operation: "read",
+                            error: result.failure,
+                        });
+                    const observation = result.success;
+                    const reply = Stream.succeed({
+                        type: "source",
+                        source,
+                        ticker,
+                        observation,
+                    });
+                    const persist = sources.persist;
+                    if (!persist)
+                        return reply;
+                    return Stream.concat(reply, Stream.fromEffect(io((signal) => persist(observation, signal)).pipe(Effect.result)).pipe(Stream.flatMap((result) => Result.isSuccess(result)
+                        ? Stream.empty
+                        : Stream.succeed({
+                            type: "error",
+                            source,
+                            ticker,
+                            operation: "persist",
+                            error: failure("PERSISTENCE_FAILED"),
+                        }))));
+                })));
+                return Stream.mergeAll([snapshot, ...live], { concurrency: 4 });
+            })).pipe(Stream.concat(Stream.succeed({ type: "complete", ticker })));
+            const signal = options.signal;
+            const abort = Effect.callback((resume) => {
+                if (!signal)
+                    return;
+                const stop = () => resume(Effect.void);
+                signal.addEventListener("abort", stop, { once: true });
+                if (signal.aborted)
+                    stop();
+                return Effect.sync(() => signal.removeEventListener("abort", stop));
+            });
+            return Stream.toAsyncIterable(signal ? stream.pipe(Stream.interruptWhen(abort)) : stream);
+        },
+    };
+}