@comms-id/asx 0.4.1 → 1.0.0

package/dist/refresh.d.ts

@@ -0,0 +1,126 @@
+import { Schema } from "effect";
+import { type AsxDataset } from "./snapshot.js";
+export declare const RefreshAttempt: Schema.Struct<{
+    readonly ticker: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"found">;
+        readonly observation: Schema.Struct<{
+            readonly company: Schema.Struct<{
+                readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly ticker: Schema.String;
+                readonly sourceId: Schema.String;
+                readonly companyName: Schema.String;
+                readonly address: Schema.NullOr<Schema.String>;
+                readonly tel: Schema.NullOr<Schema.String>;
+                readonly fax: Schema.NullOr<Schema.String>;
+                readonly website: Schema.NullOr<Schema.String>;
+                readonly description: Schema.NullOr<Schema.String>;
+                readonly issueType: Schema.NullOr<Schema.String>;
+                readonly foreignExempt: Schema.NullOr<Schema.Boolean>;
+                readonly people: Schema.$Array<Schema.Struct<{
+                    readonly sourceName: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly title: Schema.String;
+                    readonly sourceCategory: Schema.Literals<readonly ["directors", "secretaries"]>;
+                }>>;
+            }>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly lastChangedAt: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"missing">;
+        readonly startedAt: Schema.String;
+        readonly observedAt: Schema.String;
+        readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"AsxError">;
+        readonly code: Schema.Literals<readonly ["INVALID_INPUT", "PARSE_FAILED", "SOURCE_MISMATCH", "TRANSPORT_FAILED", "TIMEOUT", "RATE_LIMITED", "UPSTREAM_UNAVAILABLE", "CONFIGURATION_ERROR", "SNAPSHOT_UNAVAILABLE", "CANCELLED", "INTERNAL_ERROR", "ACCESS_DENIED", "UPSTREAM_REJECTED", "PERSISTENCE_FAILED", "PUBLICATION_CONFLICT", "COVERAGE_REJECTED"]>;
+    }>]>;
+    readonly enrichment: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"confirmed">;
+        readonly enrichment: Schema.Struct<{
+            readonly ticker: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly abn: Schema.String;
+            readonly acn: Schema.NullOr<Schema.String>;
+            readonly legalName: Schema.NonEmptyString;
+            readonly identityEvidence: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly sha256: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+            }>;
+            readonly abrEvidence: Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["abr-live", "abr-snapshot"]>;
+                readonly observedAt: Schema.String;
+            }>;
+            readonly website: Schema.NullOr<Schema.Struct<{
+                readonly url: Schema.String;
+                readonly evidence: Schema.Struct<{
+                    readonly url: Schema.String;
+                    readonly sha256: Schema.String;
+                    readonly observedAt: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+                }>;
+            }>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literal<"unresolved">;
+        readonly reason: Schema.Literals<readonly ["NO_EVIDENCE", "AMBIGUOUS", "INVALID_EVIDENCE", "IDENTITY_MISMATCH"]>;
+    }>]>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"AsxError">;
+        readonly code: Schema.Literals<readonly ["INVALID_INPUT", "PARSE_FAILED", "SOURCE_MISMATCH", "TRANSPORT_FAILED", "TIMEOUT", "RATE_LIMITED", "UPSTREAM_UNAVAILABLE", "CONFIGURATION_ERROR", "SNAPSHOT_UNAVAILABLE", "CANCELLED", "INTERNAL_ERROR", "ACCESS_DENIED", "UPSTREAM_REJECTED", "PERSISTENCE_FAILED", "PUBLICATION_CONFLICT", "COVERAGE_REJECTED"]>;
+    }>]>>;
+    readonly sources: Schema.optionalKey<Schema.Struct<{
+        readonly asx: Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+        readonly morningstar: Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+        readonly "google-finance": Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+    }>>;
+}>;
+export type RefreshAttempt = typeof RefreshAttempt.Type;
+export interface RefreshReport {
+    readonly attempted: number;
+    readonly found: number;
+    readonly missing: number;
+    readonly failed: number;
+    readonly retained: number;
+    readonly unavailable: number;
+    readonly removedFromDirectory: number;
+    readonly superseded: number;
+}
+/** Pure publication preparation. All directory members must have an explicit attempt. */
+export declare function applyRefresh(previousInput: unknown, directoryInput: unknown, attemptsInput: unknown): {
+    dataset: AsxDataset;
+    report: RefreshReport;
+};

package/dist/refresh.js

@@ -0,0 +1,153 @@
+import { Result, Schema } from "effect";
+import { DirectoryEntry, failure, Failure, isTimestamp, LiveOutcome, Ticker, validObservation, } from "./model.js";
+import { decodeDataset } from "./snapshot.js";
+import { EnrichmentResult, validEnrichment } from "./enrichment.js";
+import { CompanySources, mergeCompanySources } from "./source-record.js";
+const DirectoryObservation = Schema.Struct({
+    entries: Schema.Array(DirectoryEntry),
+    observedAt: Schema.String,
+});
+export const RefreshAttempt = Schema.Struct({
+    ticker: Ticker,
+    outcome: Schema.Union([LiveOutcome, Failure]),
+    enrichment: Schema.optionalKey(Schema.Union([EnrichmentResult, Failure])),
+    sources: Schema.optionalKey(CompanySources),
+});
+/** Pure publication preparation. All directory members must have an explicit attempt. */
+export function applyRefresh(previousInput, directoryInput, attemptsInput) {
+    const previous = previousInput === null ? null : decodeDataset(previousInput);
+    const directoryResult = Schema.decodeUnknownResult(DirectoryObservation)(directoryInput);
+    const attemptsResult = Schema.decodeUnknownResult(Schema.Array(RefreshAttempt))(attemptsInput);
+    if (Result.isFailure(directoryResult) || Result.isFailure(attemptsResult))
+        throw failure("PARSE_FAILED");
+    const directory = directoryResult.success;
+    if (!isTimestamp(directory.observedAt) ||
+        (previous && directory.observedAt < previous.directoryObservedAt))
+        throw failure("SOURCE_MISMATCH");
+    const attempts = new Map(attemptsResult.success.map((attempt) => [attempt.ticker, attempt]));
+    const directoryTickers = new Set(directory.entries.map((entry) => entry.ticker));
+    if (directory.entries.length === 0 ||
+        directory.entries.length > 20_000 ||
+        directoryTickers.size !== directory.entries.length ||
+        attempts.size !== attemptsResult.success.length ||
+        attempts.size !== directory.entries.length ||
+        [...attempts.keys()].some((ticker) => !directoryTickers.has(ticker)))
+        throw failure("PARSE_FAILED");
+    const old = new Map(previous?.records.map((record) => [record.directory.ticker, record]) ?? []);
+    const report = {
+        attempted: attempts.size,
+        found: 0,
+        missing: 0,
+        failed: 0,
+        retained: 0,
+        unavailable: 0,
+        removedFromDirectory: [...old.keys()].filter((ticker) => !directoryTickers.has(ticker)).length,
+        superseded: 0,
+    };
+    const records = directory.entries.map((entry) => {
+        const attempt = attempts.get(entry.ticker);
+        if (!attempt)
+            throw failure("PARSE_FAILED");
+        const { outcome } = attempt;
+        if (attempt.enrichment !== undefined) {
+            if ("_tag" in outcome || outcome.status !== "found")
+                throw failure("SOURCE_MISMATCH");
+            if (!("_tag" in attempt.enrichment) &&
+                attempt.enrichment.status === "confirmed" &&
+                !validEnrichment(attempt.enrichment.enrichment, outcome.observation.company))
+                throw failure("SOURCE_MISMATCH");
+        }
+        const prior = old.get(entry.ticker);
+        let acceptedProfile = false;
+        let observation = null;
+        let missingAt = prior?.missingAt;
+        if ("_tag" in outcome) {
+            report.failed += 1;
+            // A changed directory name cannot establish continuity of a reused ticker.
+            if (outcome.code !== "SOURCE_MISMATCH" &&
+                prior?.directory.companyName === entry.companyName &&
+                prior.observation) {
+                observation = prior.observation;
+                report.retained += 1;
+            }
+        }
+        else if (outcome.status === "missing") {
+            if (!isTimestamp(outcome.observedAt) ||
+                !isTimestamp(outcome.startedAt) ||
+                outcome.startedAt > outcome.observedAt)
+                throw failure("PARSE_FAILED");
+            report.missing += 1;
+            if (prior?.observation &&
+                outcome.startedAt < prior.observation.startedAt &&
+                prior.directory.companyName === entry.companyName) {
+                observation = prior.observation;
+                report.superseded += 1;
+            }
+            else if (!missingAt || outcome.startedAt >= missingAt.startedAt) {
+                missingAt = { startedAt: outcome.startedAt, observedAt: outcome.observedAt };
+            }
+        }
+        else {
+            if (!validObservation(outcome.observation) ||
+                outcome.observation.company.ticker !== entry.ticker)
+                throw failure("SOURCE_MISMATCH");
+            report.found += 1;
+            observation = outcome.observation;
+            acceptedProfile = true;
+            const oldObservation = prior?.observation;
+            if (missingAt && observation.startedAt <= missingAt.startedAt) {
+                observation = null;
+                acceptedProfile = false;
+                report.superseded += 1;
+            }
+            else if (oldObservation) {
+                missingAt = undefined;
+                if (observation.startedAt < oldObservation.startedAt) {
+                    acceptedProfile = false;
+                    observation = prior?.directory.companyName === entry.companyName ? oldObservation : null;
+                    report.superseded += 1;
+                }
+                else if (observation.company.sourceId === oldObservation.company.sourceId &&
+                    JSON.stringify(observation.company) === JSON.stringify(oldObservation.company)) {
+                    observation = { ...observation, lastChangedAt: oldObservation.lastChangedAt };
+                }
+            }
+            else {
+                missingAt = undefined;
+            }
+        }
+        if (observation === null)
+            report.unavailable += 1;
+        let enrichment = observation && prior?.enrichment && validEnrichment(prior.enrichment, observation.company)
+            ? prior.enrichment
+            : undefined;
+        if (acceptedProfile && attempt.enrichment && !("_tag" in attempt.enrichment)) {
+            // A completed check can remove an automatic match; transport failure cannot.
+            enrichment =
+                attempt.enrichment.status === "confirmed" ? attempt.enrichment.enrichment : undefined;
+        }
+        return {
+            directory: entry,
+            observation,
+            ...(attempt.sources || prior?.sources
+                ? {
+                    sources: mergeCompanySources(entry.ticker, prior?.directory.companyName === entry.companyName &&
+                        (!observation ||
+                            prior.observation?.company.sourceId === observation.company.sourceId)
+                        ? (prior.sources ?? {})
+                        : {}, attempt.sources ?? {}),
+                }
+                : {}),
+            ...(missingAt ? { missingAt } : {}),
+            ...(enrichment ? { enrichment } : {}),
+        };
+    });
+    return {
+        dataset: decodeDataset({
+            formatVersion: 1,
+            directoryObservedAt: directory.observedAt,
+            records,
+        }),
+        report,
+    };
+}

package/dist/runtime/http.js

@@ -142,7 +142,9 @@ const prepare = (operation, input) => {
 /** Sends one operation and returns its decoded reply, or throws a CommsIdError. */
 export const call = async (transport, operation, input, options = {}) => {
     const body = prepare(operation, input);
-    const deadline = AbortSignal.timeout(options.deadlineMs ?? transport.deadlineMs ?? DEFAULT_DEADLINE_MS);
+    const deadlineMs = options.deadlineMs ?? transport.deadlineMs ?? DEFAULT_DEADLINE_MS;
+    const startedAt = performance.now();
+    const deadline = AbortSignal.timeout(deadlineMs);
     const signal = options.signal === undefined ? deadline : AbortSignal.any([options.signal, deadline]);
     const maxRetries = operation.safeToRetry ? (transport.maxRetries ?? DEFAULT_MAX_RETRIES) : 0;
     const sleep = transport.sleep ?? defaultSleep;
@@ -155,6 +157,11 @@ export const call = async (transport, operation, input, options = {}) => {
             throw result.error;
         }
         const delay = result.retryAfterMs ?? Math.min(BASE_DELAY_MS * 2 ** attempt, MAX_DELAY_MS);
+        // A retry that cannot start within this call's budget must not replace a real
+        // service failure (notably 429) with a later timeout or violate Retry-After.
+        if (delay >= deadlineMs - (performance.now() - startedAt)) {
+            throw result.error;
+        }
         try {
             await sleep(delay, signal);
         }

package/dist/search-service.d.ts

@@ -0,0 +1,16 @@
+import { type SuggestionsReply } from "./client-replies.js";
+import type { LookupMode } from "./service.js";
+type Source = (query: string, limit: number, signal: AbortSignal) => Promise<unknown>;
+export interface AsxSearchSources {
+    readonly live?: Source;
+    readonly snapshot?: Source;
+}
+/** Read-only search composition. Live-first acquires saved evidence only after an eligible outage. */
+export declare function createAsxSearchService(sources: AsxSearchSources): {
+    suggest: (query: string, options?: {
+        mode?: LookupMode;
+        limit?: number;
+        signal?: AbortSignal;
+    }) => Promise<SuggestionsReply>;
+};
+export {};

package/dist/search-service.js

@@ -0,0 +1,64 @@
+import { Effect, Result, Schema } from "effect";
+import { SuggestionsResponse } from "./client-replies.js";
+import { suggestDirectory } from "./directory-search.js";
+import { failure, Failure, isFallbackEligible, isTimestamp } from "./model.js";
+const searchSource = Effect.fn("ASX.searchSource")(function* (sources, source, query, limit) {
+    const read = sources[source];
+    if (!read)
+        return yield* Effect.fail(failure(source === "live" ? "CONFIGURATION_ERROR" : "SNAPSHOT_UNAVAILABLE"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => read(query, limit, signal),
+        catch: (error) => source === "snapshot"
+            ? failure("SNAPSHOT_UNAVAILABLE")
+            : Schema.is(Failure)(error)
+                ? failure(error.code)
+                : failure("TRANSPORT_FAILED"),
+    });
+    const reply = yield* Schema.decodeUnknownEffect(SuggestionsResponse)(input).pipe(Effect.mapError(() => failure(source === "snapshot" ? "SNAPSHOT_UNAVAILABLE" : "PARSE_FAILED")));
+    if (reply.source !== source)
+        return yield* Effect.fail(failure("SOURCE_MISMATCH"));
+    if (!isTimestamp(reply.directoryObservedAt) ||
+        reply.suggestions.length > limit ||
+        new Set(reply.suggestions.map((entry) => entry.ticker)).size !== reply.suggestions.length ||
+        reply.suggestions.some((entry) => !entry.companyName.trim()) ||
+        (reply.source === "snapshot" && reply.fallbackReason !== undefined))
+        return yield* Effect.fail(failure(source === "snapshot" ? "SNAPSHOT_UNAVAILABLE" : "PARSE_FAILED"));
+    return reply;
+});
+const search = Effect.fn("ASX.search")(function* (sources, query, limit, mode) {
+    yield* Effect.try({
+        try: () => suggestDirectory([], query, limit),
+        catch: () => failure("INVALID_INPUT"),
+    });
+    if (!["live", "snapshot", "live-first"].includes(mode))
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    if (mode === "snapshot")
+        return yield* searchSource(sources, "snapshot", query, limit);
+    const live = yield* searchSource(sources, "live", query, limit).pipe(Effect.result);
+    if (Result.isSuccess(live))
+        return live.success;
+    if (mode === "live" || !isFallbackEligible(live.failure.code))
+        return yield* Effect.fail(live.failure);
+    const saved = yield* searchSource(sources, "snapshot", query, limit);
+    return { ...saved, fallbackReason: live.failure.code };
+});
+/** Read-only search composition. Live-first acquires saved evidence only after an eligible outage. */
+export function createAsxSearchService(sources) {
+    return {
+        suggest: async (query, options = {}) => {
+            try {
+                const result = await Effect.runPromise(Effect.result(search(sources, query, options.limit ?? 8, options.mode ?? "snapshot")), { signal: options.signal });
+                if (Result.isFailure(result))
+                    throw result.failure;
+                return result.success;
+            }
+            catch (error) {
+                throw options.signal?.aborted
+                    ? failure("CANCELLED")
+                    : Schema.is(Failure)(error)
+                        ? failure(error.code)
+                        : failure("INTERNAL_ERROR");
+            }
+        },
+    };
+}

package/dist/service.d.ts

@@ -0,0 +1,35 @@
+import { type AsxError, Observation } from "./model.js";
+import { type ConfirmedEnrichment } from "./enrichment.js";
+export type LookupMode = "live" | "snapshot" | "live-first";
+export type LookupReply = {
+    readonly status: "found";
+    readonly source: "live";
+    readonly observation: Observation;
+} | {
+    readonly status: "missing";
+    readonly source: "live";
+    readonly startedAt: string;
+    readonly observedAt: string;
+} | {
+    readonly status: "found";
+    readonly source: "snapshot";
+    readonly observation: Observation;
+    readonly generation: string;
+    readonly enrichment?: ConfirmedEnrichment;
+    readonly requiresRecheck: true;
+    readonly fallbackReason?: AsxError["code"];
+} | {
+    readonly status: "missing";
+    readonly source: "snapshot";
+    readonly generation: string;
+};
+export interface AsxSources {
+    readonly live?: (ticker: string, signal: AbortSignal) => Promise<unknown>;
+    readonly snapshot?: (ticker: string, signal: AbortSignal) => Promise<unknown>;
+}
+export declare function createAsxService(sources: AsxSources): {
+    lookup: (ticker: string, options?: {
+        mode?: LookupMode;
+        signal?: AbortSignal;
+    }) => Promise<LookupReply>;
+};

package/dist/service.js

@@ -0,0 +1,99 @@
+import { Effect, Fiber, Result, Schema } from "effect";
+import { failure, Failure, isFallbackEligible, isTimestamp, LiveOutcome, Observation, validObservation, } from "./model.js";
+import { normalizeTicker } from "./parse.js";
+import { SnapshotOutcome } from "./snapshot.js";
+import { validEnrichment } from "./enrichment.js";
+function safeError(error, fallback) {
+    return Schema.is(Failure)(error) ? failure(error.code) : failure(fallback);
+}
+const liveLookup = Effect.fn("ASX.live")(function* (sources, ticker) {
+    const live = sources.live;
+    if (!live)
+        return yield* Effect.fail(failure("CONFIGURATION_ERROR"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => live(ticker, signal),
+        catch: (error) => safeError(error, "TRANSPORT_FAILED"),
+    });
+    const decoded = yield* Schema.decodeUnknownEffect(LiveOutcome)(input).pipe(Effect.mapError(() => failure("PARSE_FAILED")));
+    if (decoded.status === "missing") {
+        if (!isTimestamp(decoded.observedAt) ||
+            !isTimestamp(decoded.startedAt) ||
+            decoded.startedAt > decoded.observedAt)
+            return yield* Effect.fail(failure("PARSE_FAILED"));
+    }
+    else {
+        if (!validObservation(decoded.observation))
+            return yield* Effect.fail(failure("PARSE_FAILED"));
+        if (decoded.observation.company.ticker !== ticker)
+            return yield* Effect.fail(failure("SOURCE_MISMATCH"));
+    }
+    return decoded;
+});
+const snapshotLookup = Effect.fn("ASX.snapshot")(function* (sources, ticker) {
+    const snapshot = sources.snapshot;
+    if (!snapshot)
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => snapshot(ticker, signal),
+        catch: () => failure("SNAPSHOT_UNAVAILABLE"),
+    });
+    const reply = yield* Schema.decodeUnknownEffect(SnapshotOutcome)(input).pipe(Effect.mapError(() => failure("SNAPSHOT_UNAVAILABLE")));
+    if (!/^[a-f0-9]{64}$/.test(reply.generation) || reply.status === "unavailable")
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    if (reply.status === "found" &&
+        (!Schema.is(Observation)(reply.observation) ||
+            !validObservation(reply.observation) ||
+            reply.observation.company.ticker !== ticker ||
+            (reply.enrichment !== undefined &&
+                !validEnrichment(reply.enrichment, reply.observation.company))))
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    return reply;
+});
+const lookup = Effect.fn("ASX.lookup")(function* (sources, input, mode) {
+    const ticker = yield* Effect.try({
+        try: () => normalizeTicker(input),
+        catch: () => failure("INVALID_INPUT"),
+    });
+    if (!["live", "snapshot", "live-first"].includes(mode))
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    if (mode === "snapshot") {
+        const saved = yield* snapshotLookup(sources, ticker);
+        return saved.status === "missing"
+            ? { ...saved, source: "snapshot" }
+            : { ...saved, source: "snapshot", requiresRecheck: true };
+    }
+    const saved = mode === "live-first" && sources.snapshot
+        ? yield* snapshotLookup(sources, ticker).pipe(Effect.result, Effect.forkChild({ startImmediately: true }))
+        : undefined;
+    const live = yield* liveLookup(sources, ticker).pipe(Effect.result);
+    if (Result.isSuccess(live))
+        return { ...live.success, source: "live" };
+    if (!isFallbackEligible(live.failure.code) || !saved)
+        return yield* Effect.fail(live.failure);
+    const result = yield* Fiber.join(saved);
+    if (Result.isFailure(result))
+        return yield* Effect.fail(result.failure);
+    if (result.success.status === "missing")
+        return yield* Effect.fail(live.failure);
+    return {
+        ...result.success,
+        source: "snapshot",
+        requiresRecheck: true,
+        fallbackReason: live.failure.code,
+    };
+});
+export function createAsxService(sources) {
+    return {
+        lookup: async (ticker, options = {}) => {
+            try {
+                const result = await Effect.runPromise(Effect.result(lookup(sources, ticker, options.mode ?? "live-first")), { signal: options.signal });
+                if (Result.isFailure(result))
+                    throw result.failure;
+                return result.success;
+            }
+            catch (error) {
+                throw options.signal?.aborted ? failure("CANCELLED") : safeError(error, "INTERNAL_ERROR");
+            }
+        },
+    };
+}