@comms-id/asx 0.4.0 → 0.4.2

package/dist/contract/http-api.d.ts

@@ -0,0 +1,139 @@
+import { Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export declare const ASX_API_MAJOR = 1;
+export declare const ASX_API_PREFIX = "/asx/v1";
+export declare const AsxApi: HttpApi.HttpApi<"asx", HttpApiGroup.HttpApiGroup<"asx", HttpApiEndpoint.HttpApiEndpoint<"lookup", "POST", "/asx/v1/lookup", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly ticker: Schema.String;
+    readonly mode: Schema.optionalKey<Schema.Literals<readonly ["live", "snapshot", "live-first"]>>;
+}>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"found">;
+    readonly source: Schema.Literal<"live">;
+    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 source: Schema.Literal<"live">;
+    readonly startedAt: Schema.String;
+    readonly observedAt: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"found">;
+    readonly source: Schema.Literal<"snapshot">;
+    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;
+    }>;
+    readonly generation: Schema.String;
+    readonly enrichment: Schema.optionalKey<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"]>;
+            }>;
+        }>>;
+    }>>;
+    readonly requiresRecheck: Schema.Literal<true>;
+    readonly fallbackReason: Schema.optionalKey<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"]>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"missing">;
+    readonly source: Schema.Literal<"snapshot">;
+    readonly generation: Schema.String;
+}>]>>, Schema.toCodecJson<Schema.Struct<{
+    readonly code: Schema.Literals<readonly [string, ...string[]]>;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly requestId: Schema.String;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"suggest", "POST", "/asx/v1/suggest", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly mode: Schema.optionalKey<Schema.Literals<readonly ["live", "snapshot", "live-first"]>>;
+    readonly query: Schema.String;
+    readonly limit: Schema.optionalKey<Schema.Number>;
+}>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+    readonly source: Schema.Literal<"live">;
+    readonly directoryObservedAt: Schema.String;
+    readonly suggestions: Schema.$Array<Schema.Struct<{
+        readonly ticker: Schema.String;
+        readonly companyName: Schema.String;
+        readonly industryGroup: Schema.NullOr<Schema.String>;
+        readonly listingDate: Schema.NullOr<Schema.String>;
+        readonly marketCapitalisation: Schema.NullOr<Schema.Number>;
+    }>>;
+}>, Schema.Struct<{
+    readonly source: Schema.Literal<"snapshot">;
+    readonly generation: Schema.String;
+    readonly directoryObservedAt: Schema.String;
+    readonly requiresRecheck: Schema.Literal<true>;
+    readonly suggestions: Schema.$Array<Schema.Struct<{
+        readonly ticker: Schema.String;
+        readonly companyName: Schema.String;
+        readonly industryGroup: Schema.NullOr<Schema.String>;
+        readonly listingDate: Schema.NullOr<Schema.String>;
+        readonly marketCapitalisation: Schema.NullOr<Schema.Number>;
+    }>>;
+    readonly fallbackReason: Schema.optionalKey<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"]>>;
+}>]>>, Schema.toCodecJson<Schema.Struct<{
+    readonly code: Schema.Literals<readonly [string, ...string[]]>;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly requestId: Schema.String;
+}>>, never, never>, false>>;
+/** The OpenAPI document for the ASX contract. */
+export declare const asxOpenApiDocument: () => OpenApi.OpenAPISpec;

package/dist/contract/http-api.js

@@ -0,0 +1,100 @@
+import { Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi, } from "effect/unstable/httpapi";
+import { LookupResponse, SuggestionsResponse } from "../client-replies.js";
+import { AsxLookupRequestSchema, AsxSuggestRequestSchema } from "../requests.js";
+// The ASX HTTP contract (ADR-0052, platform #515 wave 3, T2), built from the package's own
+// request and reply schemas.
+const errorBody = (name, codes, status, description) => Schema.Struct({
+    code: Schema.Literals(codes),
+    message: Schema.String,
+    retryable: Schema.Boolean,
+    requestId: Schema.String.annotate({ description: "The request's id, for support." }),
+})
+    .annotate({ identifier: `AsxError_${name}`, description })
+    .pipe(HttpApiSchema.status(status));
+const ERRORS = [
+    errorBody("INVALID_INPUT", ["INVALID_INPUT"], 400, "The body is not valid for this operation."),
+    errorBody("UNAUTHORIZED", ["UNAUTHORIZED"], 401, "The request carries no identified caller (ADR-0018)."),
+    errorBody("VERSION_RETIRED", ["VERSION_RETIRED"], 410, "This major version is retired (ADR-0050)."),
+    errorBody("FAIR_USE_CEILING", ["FAIR_USE_CEILING"], 429, "The fair-use ceiling is reached; retry after Retry-After."),
+    errorBody("UPSTREAM", ["UPSTREAM_REJECTED", "PARSE_FAILED", "SOURCE_MISMATCH"], 502, "ASX answered, but its answer could not be used."),
+    errorBody("UNAVAILABLE", [
+        "TRANSPORT_FAILED",
+        "RATE_LIMITED",
+        "UPSTREAM_UNAVAILABLE",
+        "ACCESS_DENIED",
+        "CONFIGURATION_ERROR",
+        "SNAPSHOT_UNAVAILABLE",
+        "PERSISTENCE_FAILED",
+    ], 503, "The source is unavailable."),
+    errorBody("TIMEOUT", ["TIMEOUT"], 504, "The operation did not finish within its deadline."),
+];
+export const ASX_API_MAJOR = 1;
+export const ASX_API_PREFIX = `/asx/v${ASX_API_MAJOR}`;
+const naming = (method) => ({
+    "x-fern-sdk-group-name": "asx",
+    "x-fern-sdk-method-name": method,
+    "x-fern-availability": "beta",
+    "x-comms-id-safe-to-retry": true,
+    "x-comms-id-auth": { audience: "asx-lookup", scope: "asx" },
+});
+const LOOKUP_EXAMPLE = Schema.decodeUnknownSync(LookupResponse)({
+    status: "missing",
+    source: "live",
+    startedAt: "2026-10-03T00:00:00.000Z",
+    observedAt: "2026-10-03T00:00:01.000Z",
+});
+const SUGGEST_EXAMPLE = Schema.decodeUnknownSync(SuggestionsResponse)({
+    source: "live",
+    directoryObservedAt: "2026-10-03T00:00:00.000Z",
+    suggestions: [],
+});
+// Request examples, decoded once through their schemas so an invalid one fails at load.
+const exampleOf = (schema, value) => {
+    Schema.decodeUnknownSync(schema)(value);
+    return value;
+};
+const REQUEST_EXAMPLES = {
+    lookup: exampleOf(AsxLookupRequestSchema, { ticker: "BHP" }),
+    suggest: exampleOf(AsxSuggestRequestSchema, { query: "BH", limit: 5 }),
+};
+export const AsxApi = HttpApi.make("asx")
+    .add(HttpApiGroup.make("asx")
+    .add(HttpApiEndpoint.post("lookup", `${ASX_API_PREFIX}/lookup`, {
+    payload: AsxLookupRequestSchema,
+    success: LookupResponse.annotate({ examples: [LOOKUP_EXAMPLE] }),
+    error: ERRORS,
+})
+    .annotate(OpenApi.Description, "Look up an ASX-listed company by ticker, live or from the stored directory.")
+    .annotate(OpenApi.Override, naming("lookup")))
+    .add(HttpApiEndpoint.post("suggest", `${ASX_API_PREFIX}/suggest`, {
+    payload: AsxSuggestRequestSchema,
+    success: SuggestionsResponse.annotate({ examples: [SUGGEST_EXAMPLE] }),
+    error: ERRORS,
+})
+    .annotate(OpenApi.Description, "Suggest ASX-listed companies for a ticker or name prefix, at most ten.")
+    .annotate(OpenApi.Override, naming("suggest"))))
+    .annotate(OpenApi.Title, "Comms.ID ASX")
+    .annotate(OpenApi.Version, `${ASX_API_MAJOR}.0.0`)
+    // The Sydney front door (TLS terminates in Australia). Its pool routes /asx/* here and
+    // strips the prefix; the worker accepts /asx/v1/* and /v1/* alike.
+    .annotate(OpenApi.Servers, [
+    {
+        url: "https://o5tejx16gc.execute-api.ap-southeast-2.amazonaws.com",
+        description: "Sydney front door (TLS terminates in Australia)",
+    },
+])
+    // The request examples go in the named map of each request media type (the convention of
+    // every Comms.ID contract).
+    .annotate(OpenApi.Transform, (spec) => {
+    const { paths } = spec;
+    for (const [operation, value] of Object.entries(REQUEST_EXAMPLES)) {
+        const media = paths[`${ASX_API_PREFIX}/${operation}`]?.post?.requestBody?.content["application/json"];
+        if (media !== undefined) {
+            media.examples = { default: { value } };
+        }
+    }
+    return spec;
+});
+/** The OpenAPI document for the ASX contract. */
+export const asxOpenApiDocument = () => OpenApi.fromApi(AsxApi);

package/dist/directory-search.d.ts

@@ -0,0 +1,2 @@
+import { type DirectoryEntry } from "./model.js";
+export declare function suggestDirectory(entries: readonly DirectoryEntry[], query: string, limit: number): readonly DirectoryEntry[];

package/dist/directory-search.js

@@ -0,0 +1,33 @@
+import { failure } from "./model.js";
+export function suggestDirectory(entries, query, limit) {
+    if (typeof query !== "string" ||
+        query.length > 200 ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        limit > 10)
+        throw failure("INVALID_INPUT");
+    const normalized = query.trim().toUpperCase();
+    if (normalized.length < 2)
+        return [];
+    const tokens = normalized.split(/\s+/);
+    return entries
+        .map((directory) => {
+        const name = directory.companyName.toUpperCase();
+        const score = directory.ticker === normalized
+            ? 0
+            : directory.ticker.startsWith(normalized)
+                ? 1
+                : name.startsWith(normalized)
+                    ? 2
+                    : tokens.every((token) => name.includes(token))
+                        ? 3
+                        : 4;
+        return { directory, score };
+    })
+        .filter(({ score }) => score < 4)
+        .sort((a, b) => a.score - b.score ||
+        a.directory.companyName.localeCompare(b.directory.companyName, "en") ||
+        a.directory.ticker.localeCompare(b.directory.ticker, "en"))
+        .slice(0, limit)
+        .map(({ directory }) => structuredClone(directory));
+}

package/dist/enrichment.d.ts

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+import { Company } from "./model.js";
+export declare function validAbn(abn: string): boolean;
+export declare const Evidence: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly sha256: Schema.String;
+    readonly observedAt: Schema.String;
+    readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+}>;
+export interface Evidence extends Schema.Schema.Type<typeof Evidence> {
+}
+export declare const ConfirmedEnrichment: 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"]>;
+        }>;
+    }>>;
+}>;
+export interface ConfirmedEnrichment extends Schema.Schema.Type<typeof ConfirmedEnrichment> {
+}
+export declare const EnrichmentResult: 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"]>;
+}>]>;
+export type EnrichmentResult = typeof EnrichmentResult.Type;
+/** Inputs are accepted primary-source observations from trusted collectors, never public request data. */
+export declare function confirmEnrichment(companyInput: unknown, issuerCandidates: unknown, abrInput: unknown): EnrichmentResult;
+export declare function validEnrichment(value: ConfirmedEnrichment, company: Company): boolean;

package/dist/enrichment.js

@@ -0,0 +1,114 @@
+import { Result, Schema } from "effect";
+import { Company, isTimestamp, Timestamp, Ticker } from "./model.js";
+// ABR's published modulus-89 rule; checksum validity alone never proves issuer identity.
+export function validAbn(abn) {
+    if (!/^\d{11}$/.test(abn))
+        return false;
+    const weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    return (Array.from(abn).reduce((sum, digit, index) => sum + (Number(digit) - (index === 0 ? 1 : 0)) * weights[index], 0) %
+        89 ===
+        0);
+}
+const ABN = Schema.String.check(Schema.makeFilter(validAbn));
+const ACN = Schema.NullOr(Schema.String.check(Schema.isPattern(/^\d{9}$/)));
+const HttpsUrl = Schema.String.check(Schema.makeFilter((value) => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "https:" &&
+            !url.username &&
+            !url.password &&
+            !!url.hostname &&
+            value.length <= 2048);
+    }
+    catch {
+        return false;
+    }
+}));
+export const Evidence = Schema.Struct({
+    url: HttpsUrl,
+    sha256: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)),
+    observedAt: Timestamp,
+    kind: Schema.Literals(["issuer-filing", "issuer-website"]),
+});
+export const ConfirmedEnrichment = Schema.Struct({
+    ticker: Ticker,
+    sourceId: Schema.NonEmptyString,
+    abn: ABN,
+    acn: ACN,
+    legalName: Schema.NonEmptyString,
+    identityEvidence: Evidence,
+    abrEvidence: Schema.Struct({
+        source: Schema.Literals(["abr-live", "abr-snapshot"]),
+        observedAt: Timestamp,
+    }),
+    website: Schema.NullOr(Schema.Struct({ url: HttpsUrl, evidence: Evidence })),
+});
+const IssuerEvidence = Schema.Struct({
+    ticker: Ticker,
+    sourceId: Schema.NonEmptyString,
+    issuerName: Schema.NonEmptyString,
+    abn: ABN,
+    acn: ACN,
+    evidence: Evidence,
+    website: Schema.NullOr(Schema.Struct({ url: HttpsUrl, evidence: Evidence })),
+});
+const AbrEvidence = Schema.Struct({
+    abn: ABN,
+    acn: ACN,
+    legalName: Schema.NonEmptyString,
+    source: Schema.Literals(["abr-live", "abr-snapshot"]),
+    observedAt: Timestamp,
+});
+export const EnrichmentResult = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("confirmed"), enrichment: ConfirmedEnrichment }),
+    Schema.Struct({
+        status: Schema.Literal("unresolved"),
+        reason: Schema.Literals(["NO_EVIDENCE", "AMBIGUOUS", "INVALID_EVIDENCE", "IDENTITY_MISMATCH"]),
+    }),
+]);
+const nameKey = (value) => value.trim().toUpperCase().replace(/\s+/g, " ");
+/** Inputs are accepted primary-source observations from trusted collectors, never public request data. */
+export function confirmEnrichment(companyInput, issuerCandidates, abrInput) {
+    const company = Schema.decodeUnknownResult(Company)(companyInput);
+    const candidates = Schema.decodeUnknownResult(Schema.Array(IssuerEvidence))(issuerCandidates);
+    const abr = Schema.decodeUnknownResult(AbrEvidence)(abrInput);
+    if (Result.isFailure(company) || Result.isFailure(candidates) || Result.isFailure(abr))
+        return { status: "unresolved", reason: "INVALID_EVIDENCE" };
+    if (candidates.success.length === 0)
+        return { status: "unresolved", reason: "NO_EVIDENCE" };
+    if (candidates.success.length !== 1)
+        return { status: "unresolved", reason: "AMBIGUOUS" };
+    const issuer = candidates.success[0];
+    if (!isTimestamp(issuer.evidence.observedAt) ||
+        !isTimestamp(abr.success.observedAt) ||
+        (issuer.website && !isTimestamp(issuer.website.evidence.observedAt)))
+        return { status: "unresolved", reason: "INVALID_EVIDENCE" };
+    if (issuer.sourceId !== company.success.sourceId ||
+        issuer.ticker !== company.success.ticker ||
+        nameKey(issuer.issuerName) !== nameKey(company.success.companyName) ||
+        nameKey(issuer.issuerName) !== nameKey(abr.success.legalName) ||
+        issuer.abn !== abr.success.abn ||
+        (issuer.acn !== null && issuer.acn !== abr.success.acn))
+        return { status: "unresolved", reason: "IDENTITY_MISMATCH" };
+    return {
+        status: "confirmed",
+        enrichment: {
+            ticker: issuer.ticker,
+            sourceId: issuer.sourceId,
+            abn: issuer.abn,
+            acn: abr.success.acn,
+            legalName: abr.success.legalName,
+            identityEvidence: issuer.evidence,
+            abrEvidence: { source: abr.success.source, observedAt: abr.success.observedAt },
+            website: issuer.website,
+        },
+    };
+}
+export function validEnrichment(value, company) {
+    return (value.sourceId === company.sourceId &&
+        value.ticker === company.ticker &&
+        nameKey(value.legalName) === nameKey(company.companyName) &&
+        isTimestamp(value.identityEvidence.observedAt) &&
+        isTimestamp(value.abrEvidence.observedAt) &&
+        (value.website === null || isTimestamp(value.website.evidence.observedAt)));
+}

package/dist/http.d.ts

@@ -0,0 +1 @@
+export declare function boundedText(response: Response, limit: number, signal: AbortSignal): Promise<string>;

package/dist/http.js

@@ -0,0 +1,49 @@
+import { failure } from "./model.js";
+export async function boundedText(response, limit, signal) {
+    if (!response.body)
+        throw failure("PARSE_FAILED");
+    const reader = response.body.getReader();
+    let length = 0;
+    let body = "";
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+    const decode = (bytes) => {
+        try {
+            return decoder.decode(bytes, { stream: bytes !== undefined });
+        }
+        catch {
+            throw failure("PARSE_FAILED");
+        }
+    };
+    const abort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+        while (true) {
+            if (signal.aborted)
+                throw failure("CANCELLED");
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            const bytes = chunk.value;
+            if (!(bytes instanceof Uint8Array))
+                throw failure("PARSE_FAILED");
+            length += bytes.byteLength;
+            if (length > limit)
+                throw failure("PARSE_FAILED");
+            body += decode(bytes);
+        }
+        if (signal.aborted)
+            throw failure("CANCELLED");
+        return body + decode();
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        try {
+            await reader.cancel();
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/live.d.ts

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+import { type DirectoryEntry } from "./model.js";
+export interface AsxLiveConfig {
+    /** Host transport owns network routing; must honour AbortSignal. */
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
+}
+/** No persistence, source composition, background work or network call at construction. */
+export declare function createAsxLive(config?: AsxLiveConfig): {
+    source: (input: string, signal?: AbortSignal) => Promise<import("./source-record.js").SourceObservation>;
+    lookup: (ticker: string, signal?: AbortSignal) => Promise<{
+        readonly status: "found";
+        readonly observation: {
+            readonly company: {
+                readonly raw?: {
+                    readonly [x: string]: Schema.Json;
+                } | undefined;
+                readonly ticker: string;
+                readonly sourceId: string;
+                readonly companyName: string;
+                readonly address: string | null;
+                readonly tel: string | null;
+                readonly fax: string | null;
+                readonly website: string | null;
+                readonly description: string | null;
+                readonly issueType: string | null;
+                readonly foreignExempt: boolean | null;
+                readonly people: readonly {
+                    readonly sourceName: string;
+                    readonly displayName: string;
+                    readonly title: string;
+                    readonly sourceCategory: "directors" | "secretaries";
+                }[];
+            };
+            readonly startedAt: string;
+            readonly observedAt: string;
+            readonly lastChangedAt: string;
+        };
+    } | {
+        readonly status: "missing";
+        readonly startedAt: string;
+        readonly observedAt: string;
+        readonly raw?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+    }>;
+    directory: (signal?: AbortSignal) => Promise<{
+        entries: readonly DirectoryEntry[];
+        observedAt: string;
+    }>;
+    suggest: (query: string, limit?: number, signal?: AbortSignal) => Promise<{
+        source: "live";
+        directoryObservedAt: string;
+        suggestions: readonly DirectoryEntry[];
+    }>;
+};