@mark1russell7/netdiag 0.1.0 → 0.1.1

package/build/index.d.ts

@@ -1,152 +1,10 @@
-import { A as LAYERS, C as Strength, D as expand, E as diagnose, M as isLayer, N as layerRank, O as explain, S as STRENGTHS, T as compileCatalog, _ as NONE, a as Catalog, b as Prediction, c as Contribution, d as Evidence, f as Expectation, g as Hypothesis, h as Feature, i as STANDARD_FEATURES, j as Layer, k as predictive, l as Diagnosis, m as Fault, n as STANDARD_CATALOG_SPEC, o as CatalogSpec, p as FLOOR, r as STANDARD_FAULTS, s as Cause, t as STANDARD_CATALOG, u as Distribution, v as PARTS, w as UNKNOWN, x as Reach, y as Part } from "./index-CP1hzELI.js";
+import { i as layerRank, n as Layer, r as isLayer, t as LAYERS } from "./layer-BNg0VYuK.js";
+import { $ as HostKind, A as TRACE_OUTCOMES, B as ProbeContext, C as PathTrace, D as TCP_CONNECT, E as ReportHop, F as TraceHop, G as FactSource, H as defineProbe, I as TraceOutcome, J as ValueOf, K as FactTime, L as Trust, M as TcpConnect, N as TlsCertificate, O as TLS_HANDSHAKE, P as TlsHandshake, Q as observe, R as Availability, S as PathReport, T as RecordType, U as Fact, V as ProbeMode, W as FactKind, X as factsOf, Y as defineFactKind, Z as isFactOf, _ as ICMP_ECHO, a as DNS_ANSWER, at as sameTarget, b as PATH_REPORT, c as DnsOutcome, d as HANDSHAKE_OUTCOMES, et as Target, f as HTTP_OUTCOMES, g as HttpResponse, h as HttpOutcome, i as ConnectOutcome, it as parseTarget, j as TRUSTS, k as TOOL_KINDS, l as ECHO_OUTCOMES, m as HandshakeOutcome, n as CONNECT_OUTCOMES, nt as formatTarget, o as DNS_OUTCOMES, ot as target, p as HTTP_RESPONSE, q as Observation, r as CertProblem, rt as hostKind, s as DnsAnswer, t as CERT_PROBLEMS, tt as canonicalHost, u as EchoOutcome, v as IcmpEcho, w as RECORD_TYPES, x as PATH_TRACE, y as NATIVE_KINDS, z as Probe } from "./kinds-_NShfZpU.js";
+import { ADDRESS_CLASSES, AddressClass, AddressFamily, Cidr, CidrSet, addressClass, addressFamily, addressKind, canonicalAddress, cidrContains, cidrSet, formatCidr, parseCidr } from "./address.js";
+import { A as Part, B as predictive, C as Expectation, D as Hypothesis, E as Feature, F as UNKNOWN, I as compileCatalog, L as diagnose, M as Reach, N as STRENGTHS, O as NONE, P as Strength, R as expand, S as Evidence, T as Fault, _ as CatalogSpec, a as LabRecord, b as Diagnosis, c as LabVerdict, d as scoreLab, f as STANDARD_CATALOG, g as Catalog, h as STANDARD_FEATURES, i as LabGate, j as Prediction, k as PARTS, l as labGate, m as STANDARD_FAULTS, n as LabBars, o as LabScore, p as STANDARD_CATALOG_SPEC, r as LabCause, s as LabStatus, t as LAB_RECORD_FORMAT, u as labRecordOf, v as Cause, w as FLOOR, x as Distribution, y as Contribution, z as explain } from "./index-K2dGiYxW.js";
+import { Socket, TcpNetConnectOpts } from "node:net";
 import { Result } from "@mark1russell7/optional";
 import { Clock } from "@mark1russell7/algebra/clock";
-/** The kind of the host of a target: a DNS name, an IPv4 address or an IPv6 address. */
-type HostKind = "name" | "ipv4" | "ipv6";
-/**
- * A host that a probe examines, and an optional port.
- *
- * The host is in its canonical form: lower case, with no final dot and no brackets around an IPv6 address.
- */
-interface Target {
-  readonly host: string;
-  readonly kind: HostKind;
-  readonly port?: number | undefined;
-}
-/** This function gives the kind of a host in its canonical form. */
-export declare function hostKind(host: string): HostKind;
-/** This function gives the canonical form of a host: lower case, with no final dot and no brackets. */
-export declare function canonicalHost(host: string): string;
-/** This function makes a target from a host and an optional port. */
-export declare function target(host: string, port?: number): Target;
-/** This function gives the text of a target: `host`, `host:port`, or `[address]:port` for an IPv6 address. */
-export declare function formatTarget(t: Target): string;
-/** This function tells if two targets have the same host and the same port. */
-export declare function sameTarget(a: Target, b: Target): boolean;
-/**
- * This function reads a target from the text that a user gives.
- *
- * It accepts a URL (`https://example.com/a`), a host (`example.com`) and a host with a port (`example.com:8443`).
- * It also accepts an IPv4 address, and an IPv6 address in brackets with a port (`[2001:db8::1]:443`).
- * A URL with a known scheme and no port gets the port of its scheme.
- */
-export declare function parseTarget(text: string): Result<Target, string>;
-/**
- * The time of a fact, in milliseconds on the monotonic clock of the runner.
- *
- * The field `origin` of the runner gives the wall-clock time of one monotonic time. Thus each fact time has a wall-clock time.
- */
-interface FactTime {
-  readonly start: number;
-  readonly end: number;
-}
-/** The source of a fact: the probe and its version, and the outside tool when the probe starts one. */
-interface FactSource {
-  readonly probe: string;
-  readonly version: string;
-  readonly tool?: string | undefined;
-}
-/**
- * A typed fact of one layer of the network stack.
- *
- * A fact has a layer, a time, a source and a value. Its kind names the type of its value, for example `tcp.connect`.
- * The subject is the target of the fact. A fact is plain data, so a record of facts is JSON.
- */
-interface Fact<V = unknown> {
-  /** The id is unique in the facts of one runner, for example `f12`. */
-  readonly id: string;
-  readonly kind: string;
-  readonly layer: Layer;
-  readonly subject: Target;
-  readonly time: FactTime;
-  readonly source: FactSource;
-  readonly value: V;
-}
-/**
- * The definition of a kind of fact: its name, its layer and the check of its value.
- *
- * The check is the contract of the value. The runner refuses a value that does not pass it, thus each fact of a kind has a
- * value of the type `V`.
- */
-interface FactKind<V> {
-  readonly kind: string;
-  readonly layer: Layer;
-  readonly summary: string;
-  readonly check: (value: unknown) => value is V;
-}
-/** The value type of a fact kind. */
-type ValueOf<K> = K extends FactKind<infer V> ? V : never;
-/** This function makes a fact kind. The name has lower-case words with dots, for example `tls.handshake`. */
-export declare function defineFactKind<V>(spec: FactKind<V>): FactKind<V>;
-/** This function tells if a fact is of a kind, and if its value passes the check of the kind. */
-export declare function isFactOf<V>(kind: FactKind<V>, fact: Fact): fact is Fact<V>;
-/** This function gives the facts of one kind, in their order. */
-export declare function factsOf<V>(kind: FactKind<V>, facts: readonly Fact[]): Fact<V>[];
-/**
- * An observation is a fact that a probe parsed, before the runner gives it an id, a layer and a source.
- *
- * The time is optional. Without a time, the fact gets the time of the run of the probe.
- */
-interface Observation<V = unknown> {
-  readonly kind: FactKind<V>;
-  readonly subject: Target;
-  readonly value: V;
-  readonly time?: FactTime | undefined;
-}
-/** This function makes an observation with a type check of its value against its kind. */
-export declare function observe<V>(kind: FactKind<V>, subject: Target, value: V, time?: FactTime): Observation<V>;
-/**
- * The mode of a probe.
- *
- * - `active`: the probe sends packets to its peers, for example a TCP connect.
- * - `passive`: the probe reads only the state of this computer, for example its routes. It has no peers.
- */
-type ProbeMode = "active" | "passive";
-/** The context of a run: the clock of the runner, and the signal that stops the run. */
-interface ProbeContext {
-  readonly clock: Clock;
-  readonly signal: AbortSignal;
-}
-/** The availability of a probe on this computer. An unavailable probe tells why, for example a tool that is not installed. */
-type Availability = {
-  readonly available: true;
-  readonly version?: string | undefined;
-} | {
-  readonly available: false;
-  readonly reason: string;
-};
-/**
- * The contract of a probe. A probe is an adapter: it tells if it is available, it does its work, and it parses its raw output into
- * observations.
- *
- * - `peers` gives each host that `run` sends packets to. A passive probe gives no peers. The runner examines each peer
- *   against the scope before `run` starts.
- * - `run` does the effects and gives the raw output. A network failure is an observation, not an error. For example, a
- *   TCP connect that times out gives the outcome `timeout`. `run` throws only for a fault of the probe.
- * - `parse` is a pure function of the raw output and the input. Thus a record of a raw output gives the same facts again,
- *   also after a correction of the parser.
- *
- * The input and the raw output are plain JSON data, so a record can keep them.
- */
-interface Probe<I, R> {
-  /** The id has lower-case words with dots, for example `tcp.connect`. */
-  readonly id: string;
-  /** The version of the probe changes when its facts change. */
-  readonly version: string;
-  readonly summary: string;
-  readonly layer: Layer;
-  readonly mode: ProbeMode;
-  /** The kinds of the facts that the probe gives. The runner refuses an observation of a different kind. */
-  readonly kinds: readonly FactKind<unknown>[];
-  /** The outside tool that the probe starts, for example `ping`. A native probe has no tool. */
-  readonly tool?: string | undefined;
-  peers(input: I): readonly Target[];
-  available(context: ProbeContext): Promise<Availability>;
-  run(input: I, context: ProbeContext): Promise<R>;
-  parse(raw: R, input: I): readonly Observation[];
-}
-/** This function makes a probe, and examines its fields. */
-export declare function defineProbe<I, R>(probe: Probe<I, R>): Probe<I, R>;
 /**
  * The basis of a grant: why a target is in the scope.
  *
@@ -283,5 +141,252 @@ interface Runner {
 }
 /** This function makes a runner. */
 export declare function createRunner(options: RunnerOptions): Runner;
-export { type Availability, type Catalog, type CatalogSpec, type Cause, type ClockOrigin, type Contribution, type Diagnosis, type Distribution, type Evidence, type Expectation, FLOOR, type Fact, type FactKind, type FactSource, type FactTime, type Fault, type Feature, type Grant, type GrantBasis, type HostGrant, type HostKind, type Hypothesis, LAYERS, type Layer, NONE, type Observation, PARTS, type Part, type PortLedger, type Prediction, type Probe, type ProbeContext, type ProbeMode, type ProbeOutcome, type RangeGrant, type Reach, type Runner, type RunnerOptions, STANDARD_CATALOG, STANDARD_CATALOG_SPEC, STANDARD_FAULTS, STANDARD_FEATURES, STRENGTHS, type Scope, type ScopeDecision, type Strength, type Target, UNKNOWN, type ValueOf, compileCatalog, diagnose, expand, explain, isLayer, layerRank, predictive };
+/** The function that opens a TCP socket. A test can give a function that gives a socket with no connection. */
+type Dial = (options: TcpNetConnectOpts) => Socket;
+/** The options of the native probes that connect. */
+interface ConnectOptions {
+  /** The function that opens a TCP socket. The default is `connect` of `node:net`. */
+  readonly dial?: Dial | undefined;
+}
+/** The time limit of a probe run, when its input gives none: 5 seconds. */
+export declare const DEFAULT_TIMEOUT_MS = 5e3;
+/** This function maps an error code of a TCP connect to its outcome. */
+export declare function connectOutcome(code: string | undefined): ConnectOutcome;
+/** This function maps an error of a TLS handshake to its outcome. */
+export declare function handshakeOutcome(thrown: unknown, expired: boolean): HandshakeOutcome;
+/** This function maps the authorization error of a TLS socket to the problem of the certificate. */
+export declare function certProblem(code: string): CertProblem;
+/** The TCP phase of a probe run. The times are readings of the clock of the runner. */
+interface TcpPhase {
+  readonly address: string;
+  readonly port: number;
+  readonly family: 4 | 6;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: ConnectOutcome;
+  readonly code?: string | undefined;
+}
+/** The TLS phase of a probe run. */
+interface TlsPhase {
+  readonly servername?: string | undefined;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: HandshakeOutcome;
+  readonly protocol?: string | undefined;
+  readonly cipher?: string | undefined;
+  readonly alpn?: string | undefined;
+  readonly code?: string | undefined;
+  readonly certificate?: TlsCertificate | undefined;
+}
+/** The fields of a response head that an HTTP fact keeps. */
+export declare const KEPT_FIELDS: readonly string[];
+/** The HTTP phase of a probe run. */
+interface HttpPhase {
+  readonly method: "GET" | "HEAD";
+  readonly host: string;
+  readonly path: string;
+  readonly start: number;
+  /** The time of the head of the response. */
+  readonly head?: number | undefined;
+  readonly end: number;
+  readonly outcome: HttpOutcome;
+  readonly status?: number | undefined;
+  readonly version?: string | undefined;
+  readonly fields: Readonly<Record<string, string>>;
+  readonly bytes: number;
+  readonly truncated: boolean;
+  readonly code?: string | undefined;
+}
+/** The input of the DNS probe: one query for the addresses of a name, to one resolver. */
+interface DnsInput {
+  readonly name: string;
+  /** The record type. The default is `A`. */
+  readonly record?: RecordType | undefined;
+  /** The IP address of the resolver. */
+  readonly resolver: string;
+  /** The port of the resolver. The default is 53. */
+  readonly port?: number | undefined;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the DNS probe. The times are readings of the clock of the runner. */
+interface DnsRaw {
+  readonly name: string;
+  readonly record: RecordType;
+  readonly resolver: string;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: DnsOutcome;
+  readonly addresses: readonly string[];
+  readonly ttl?: number | undefined;
+  readonly code?: string | undefined;
+}
+/** This function maps an error code of a DNS query to its outcome. */
+export declare function dnsOutcome(code: string | undefined): DnsOutcome;
+/**
+ * The DNS probe sends one query for the addresses of a name to one resolver. Its peer is the resolver, not the name.
+ * The query uses no search domain.
+ */
+export declare const DNS_PROBE: Probe<DnsInput, DnsRaw>;
+/** The input of the TCP probe: one connect to an IP address and a port. */
+interface TcpInput {
+  readonly address: string;
+  readonly port: number;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the TCP probe. */
+interface TcpRaw {
+  readonly tcp: TcpPhase;
+}
+/** This function makes the TCP probe. It connects, and then it closes the connection. */
+export declare function tcpProbe(options?: ConnectOptions): Probe<TcpInput, TcpRaw>;
+/** The TCP probe with the `connect` of `node:net`. */
+export declare const TCP_PROBE: Probe<TcpInput, TcpRaw>;
+/** The input of the TLS probe: a TCP connect and a TLS handshake. */
+interface TlsInput {
+  readonly address: string;
+  /** The port. The default is 443. */
+  readonly port?: number | undefined;
+  /** The name for SNI and for the check of the certificate. */
+  readonly servername?: string | undefined;
+  readonly alpn?: readonly string[] | undefined;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the TLS probe. It has no TLS phase when the TCP connect failed. */
+interface TlsRaw {
+  readonly tcp: TcpPhase;
+  readonly tls?: TlsPhase | undefined;
+}
+/** The options of the TLS and HTTP probes. */
+interface TlsProbeOptions extends ConnectOptions {
+  /** More roots of trust, as PEM text: the roots that the user trusts, for example the root of a company. */
+  readonly roots?: readonly string[] | undefined;
+  /**
+   * More public roots, as PEM text. A chain that ends at one of them gets the trust `public`. A lab gives its own
+   * root here, so that its servers stand for servers on the internet.
+   */
+  readonly publicRoots?: readonly string[] | undefined;
+}
+/**
+ * This function makes the TLS probe. It measures the TCP connect and the TLS handshake apart. It examines the
+ * certificate, and it does not refuse a certificate that is not valid.
+ */
+export declare function tlsProbe(options?: TlsProbeOptions): Probe<TlsInput, TlsRaw>;
+/** The TLS probe with the public roots and the roots of the computer. */
+export declare const TLS_PROBE: Probe<TlsInput, TlsRaw>;
+/** The input of the HTTP probe: one HTTP/1.1 request over TCP, or over TLS for `https`. */
+interface HttpInput {
+  readonly address: string;
+  readonly scheme: "http" | "https";
+  /** The port. The default is 80 for `http` and 443 for `https`. */
+  readonly port?: number | undefined;
+  /** The name of the host for the `Host` field and for SNI. The default is the address. */
+  readonly host?: string | undefined;
+  /** The path of the request. The default is `/`. */
+  readonly path?: string | undefined;
+  /** The method. The default is `GET`. */
+  readonly method?: "GET" | "HEAD" | undefined;
+  readonly timeoutMs?: number | undefined;
+  /** The limit of the bytes of the body that the probe reads. The default is 65536. */
+  readonly maxBytes?: number | undefined;
+}
+/** The raw output of the HTTP probe. */
+interface HttpRaw {
+  readonly scheme: "http" | "https";
+  readonly tcp: TcpPhase;
+  readonly tls?: TlsPhase | undefined;
+  readonly http?: HttpPhase | undefined;
+}
+/** The limit of the bytes of a body that the HTTP probe reads, when its input gives none: 64 KiB. */
+export declare const DEFAULT_MAX_BYTES = 65536;
+/**
+ * This function makes the HTTP probe. It sends one request, follows no redirect, and reads the body up to a limit. It
+ * gives the facts of each phase: TCP, TLS for `https`, and HTTP. For `https`, it sends the request only when the
+ * certificate passes its check.
+ */
+export declare function httpProbe(options?: TlsProbeOptions): Probe<HttpInput, HttpRaw>;
+/** The HTTP probe with the public roots and the roots of the computer. */
+export declare const HTTP_PROBE: Probe<HttpInput, HttpRaw>;
+/** A fact that gave no evidence, with the reason in plain words. */
+export interface Skipped {
+  readonly fact: string;
+  readonly reason: string;
+}
+/** The evidence of a list of facts, and the facts that gave no evidence. */
+export interface Reading {
+  readonly evidence: readonly Evidence[];
+  readonly skipped: readonly Skipped[];
+}
+/** The options of `readEvidence`. */
+export interface ReadOptions {
+  /** This function tells if a fact is about the target (`true`) or about a reference host (`false`). The default is `true`. */
+  readonly primary?: ((fact: Fact) => boolean) | undefined;
+  /**
+   * The IP address of the default gateway. The ICMP echo facts of this address give the feature `gateway.reply`. The
+   * ICMP echo facts of the other addresses give the feature `icmp.reply`.
+   */
+  readonly gateway?: string | undefined;
+}
+/** A bin of a time or a ratio. A number below `below` gets `value`. The last bin has no limit. */
+export interface Bin {
+  readonly below?: number | undefined;
+  readonly value: string;
+}
+/** The bins of the feature `tcp.time`, in milliseconds. A connect of 900 ms or more sent its SYN again. */
+export declare const TCP_TIME_BINS: readonly Bin[];
+/** The bins of the feature `tls.ratio`: the time of the TLS handshake divided by the time of the TCP connect. */
+export declare const TLS_RATIO_BINS: readonly Bin[];
+/** The bins of the feature `http.ttfb`: the time to the first byte divided by the time of the TCP connect. */
+export declare const HTTP_TTFB_BINS: readonly Bin[];
+/**
+ * The smallest time of a TCP connect in a ratio, in milliseconds. On a local link, a ratio with a smaller time measures
+ * only the cost of the cryptography.
+ */
+export declare const MIN_CONNECT_MS = 1;
+/** The value of the feature `dns.answer` for each outcome of a DNS query. `nodata` tells that the name exists. */
+export declare const DNS_ANSWER_VALUES: Readonly<Partial<Record<DnsOutcome, string>>>;
+/** The value of the feature `tcp.connect` for each outcome of a TCP connect. */
+export declare const TCP_CONNECT_VALUES: Readonly<Partial<Record<ConnectOutcome, string>>>;
+/**
+ * The value of the feature `tls.handshake` for each outcome of a TLS handshake. The catalog has no value for `not-tls`
+ * and `closed` yet. The lab runs (ND-7) tell which faults cause them.
+ */
+export declare const TLS_HANDSHAKE_VALUES: Readonly<Partial<Record<HandshakeOutcome, string>>>;
+/** The value of the feature `tls.trust` for each trust. A chain that ends at no root of the store has no public root. */
+export declare const TLS_TRUST_VALUES: Readonly<Record<Trust, string>>;
+/** The value of the feature `icmp.reply` for each outcome of the ICMP echo requests to an address. */
+export declare const ICMP_REPLY_VALUES: Readonly<Partial<Record<EchoOutcome, string>>>;
+/**
+ * The value of the feature `gateway.reply` for each outcome of the ICMP echo requests to the gateway. When this computer
+ * tells that the gateway is unreachable, the gateway gives no reply.
+ */
+export declare const GATEWAY_REPLY_VALUES: Readonly<Partial<Record<EchoOutcome, string>>>;
+/**
+ * The bins of the feature `path.loss`, on the share of the echo requests with a reply. A share of 1 has no loss. A share
+ * of 0.95 or more has a loss of up to 5 %.
+ */
+export declare const PATH_LOSS_BINS: readonly Bin[];
+/**
+ * The smallest number of echo requests that gives the feature `path.loss`. With 20 requests, one lost request is a loss
+ * of 5 %. With no reply, the feature `icmp.reply` tells the result, not `path.loss`.
+ */
+export declare const LOSS_MIN_SENT = 20;
+/** The suffixes of the names of local networks and of the special-use names (RFC 6761, RFC 6762 and RFC 8375). */
+export declare const LOCAL_SUFFIXES: readonly string[];
+/** This function gives the value of the first bin that holds `x`. */
+export declare function binOf(bins: readonly Bin[], x: number): string;
+/** This function tells if a name is a local name: a name with one label, or a name with a local suffix. */
+export declare function isLocalName(name: string): boolean;
+/**
+ * This function changes facts into evidence for the model.
+ *
+ * - The reader gives one evidence for each feature, subject and role. When a subject has more facts, the last fact decides.
+ * - For `dns.answer`, one answer `ok` of a name and a resolver decides. For `dns.address`, one private address decides.
+ * - The order of the facts is the order of the runner. A ratio uses the last TCP connect before the handshake or the request.
+ * - An ICMP echo fact gives `gateway.reply` for the gateway, and `icmp.reply` for each other address.
+ * - An ICMP echo fact with replies to `LOSS_MIN_SENT` requests or more gives `path.loss`. A report of `mtr` gives it from
+ *   the last hop, when the address answered there.
+ * - A trace of `traceroute` gives no evidence. The catalog has no feature for the hops of a path.
+ */
+export declare function readEvidence(facts: readonly Fact[], options?: ReadOptions): Reading;
+export { ADDRESS_CLASSES, AddressClass, AddressFamily, type Availability, CERT_PROBLEMS, CONNECT_OUTCOMES, type Catalog, type CatalogSpec, type Cause, CertProblem, Cidr, CidrSet, type ClockOrigin, type ConnectOptions, ConnectOutcome, type Contribution, DNS_ANSWER, DNS_OUTCOMES, type Diagnosis, type Dial, type Distribution, DnsAnswer, type DnsInput, DnsOutcome, type DnsRaw, ECHO_OUTCOMES, EchoOutcome, type Evidence, type Expectation, FLOOR, type Fact, type FactKind, type FactSource, type FactTime, type Fault, type Feature, type Grant, type GrantBasis, HANDSHAKE_OUTCOMES, HTTP_OUTCOMES, HTTP_RESPONSE, HandshakeOutcome, type HostGrant, type HostKind, type HttpInput, HttpOutcome, type HttpPhase, type HttpRaw, HttpResponse, type Hypothesis, ICMP_ECHO, IcmpEcho, LAB_RECORD_FORMAT, LAYERS, type LabBars, type LabCause, type LabGate, type LabRecord, type LabScore, type LabStatus, type LabVerdict, type Layer, NATIVE_KINDS, NONE, type Observation, PARTS, PATH_REPORT, PATH_TRACE, type Part, PathReport, PathTrace, type PortLedger, type Prediction, type Probe, type ProbeContext, type ProbeMode, type ProbeOutcome, RECORD_TYPES, type RangeGrant, type Reach, RecordType, ReportHop, type Runner, type RunnerOptions, STANDARD_CATALOG, STANDARD_CATALOG_SPEC, STANDARD_FAULTS, STANDARD_FEATURES, STRENGTHS, type Scope, type ScopeDecision, type Strength, TCP_CONNECT, TLS_HANDSHAKE, TOOL_KINDS, TRACE_OUTCOMES, TRUSTS, type Target, TcpConnect, type TcpInput, type TcpPhase, type TcpRaw, TlsCertificate, TlsHandshake, type TlsInput, type TlsPhase, type TlsProbeOptions, type TlsRaw, TraceHop, TraceOutcome, Trust, UNKNOWN, type ValueOf, addressClass, addressFamily, addressKind, canonicalAddress, canonicalHost, cidrContains, cidrSet, compileCatalog, defineFactKind, defineProbe, diagnose, expand, explain, factsOf, formatCidr, formatTarget, hostKind, isFactOf, isLayer, labGate, labRecordOf, layerRank, observe, parseCidr, parseTarget, predictive, sameTarget, scoreLab, target };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/target.ts","../src/fact.ts","../src/probe.ts","../src/scope.ts","../src/run.ts"],"mappings":";;;;KAIY;;;;;;UAOK;WACN;WACA,MAAM;WACN;;;wBAcK,SAAS,eAAe;;wBAQxB,cAAc;;wBAQd,OAAO,cAAc,gBAAgB;;wBAMrC,aAAa,GAAG;;wBAMhB,WAAW,GAAG,QAAQ,GAAG;;;;;;;;wBAwBzB,YAAY,eAAe,OAAO;;;;;;UCxEjC;WACN;WACA;;;UAIM;WACN;WACA;WACA;;;;;;;;UASM,KAAK;;WAEX;WACA;WACA,OAAO;WACP,SAAS;WACT,MAAM;WACN,QAAQ;WACR,OAAO;;;;;;;;UASD,SAAS;WACf;WACA,OAAO;WACP;WACA,QAAQ,mBAAmB,SAAS;;;KAInC,QAAQ,KAAK,UAAU,eAAe,KAAK;;wBAKvC,eAAe,GAAG,MAAM,SAAS,KAAK,SAAS;;wBAM/C,SAAS,GAAG,MAAM,SAAS,IAAI,MAAM,OAAO,QAAQ,KAAK;;wBAKzD,QAAQ,GAAG,MAAM,SAAS,IAAI,gBAAgB,SAAS,KAAK;;;;;;UAS3D,YAAY;WAClB,MAAM,SAAS;WACf,SAAS;WACT,OAAO;WACP,OAAO;;;wBAIF,QAAQ,GAAG,MAAM,SAAS,IAAI,SAAS,QAAQ,OAAO,GAAG,OAAO,WAAW,YAAY;;;;;;;KCzE3F;;UAGK;WACN,OAAO;WACP,QAAQ;;;KAIP;WACG;WAA0B;;WAC1B;WAA2B;;;;;;;;;;;;;;;UAezB,MAAM,GAAG;;WAEf;;WAEA;WACA;WACA,OAAO;WACP,MAAM;;WAEN,gBAAgB;;WAEhB;EACT,MAAM,OAAO,aAAa;EAC1B,UAAU,SAAS,eAAe,QAAQ;EAC1C,IAAI,OAAO,GAAG,SAAS,eAAe,QAAQ;EAC9C,MAAM,KAAK,GAAG,OAAO,aAAa;;;wBAIpB,YAAY,GAAG,GAAG,OAAO,MAAM,GAAG,KAAK,MAAM,GAAG;;;;;;;;;KC5CpD;;;;;;;KAQA,QAAQ,YAAY;;UAGf;WACN;WACA;WACA;WACA,OAAO;WACP;;;UAIM;WACN;WACA;WACA,OAAO;WACP;;;;;;;;UASM;WACN,iBAAiB;WACjB;;;qBAIE;;KAGD;WACG;WAAwB,OAAO;;WAC/B;WAAyB;;;KAG5B,aAAa,oBAAoB;;wBAoB7B,cAAc,OAAO;;;;;;wBAgBrB,QAAQ,iBAAiB,SAAS;WAAoB;IAAkC,OAAO;;;;;wBAY/F,WAAW,GAAG,QAAQ,gBAAgB;;wBAMtC,cAAc,cAAc,iBAAiB,kBAAkB;;wBAS/D,MAAM,OAAO,OAAO,iBAAiB,UAAU,OAAO;;;;;;;wBA8BtD,YAAY,OAAO,OAAO,MAAM,QAAQ,SAAQ,aAAyB;;;;;;;;;;KCzI7E,aAAa;WACV;WAAyB,MAAM;WAAmB,KAAK;WAAY,gBAAgB;;WACnF;WAA4B,MAAM;WAAiB;;WACnD;WAAgC;;WAChC;WAA2B;WAA2C;WAAwB,MAAM;;WACpG;WAA4B;;;UAG1B;WACN;WACA;;;UAIM;WACN,OAAO;WACP,OAAO;;WAEP;;;;;;;UAQM;WACN,QAAQ;EACjB,SAAS;EACT,kBAAkB;;EAElB,MAAM,iBAAiB;EACvB,IAAI,GAAG,GAAG,OAAO,MAAM,GAAG,IAAI,OAAO,GAAG,SAAS,cAAc,QAAQ,aAAa;;;wBActE,aAAa,SAAS,gBAAgB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/scope.ts","../src/run.ts","../src/probes/socket.ts","../src/probes/native.ts","../src/readers.ts"],"mappings":"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"}