@mark1russell7/netdiag 0.0.0-bootstrap.0 → 0.1.0

package/build/diagnosis-BTa-Dfwl.js

@@ -0,0 +1,820 @@
+import { err, ok } from "@mark1russell7/optional";
+// src/layer.ts
+/**
+* The layers of the network stack that netdiag examines, from the bottom to the top.
+*
+* - `link`: the network interface and its physical link.
+* - `wifi`: the Wi-Fi link: the signal, the channel and the rate.
+* - `ip`: the addresses of the interfaces.
+* - `route`: the routes of this computer and its gateway.
+* - `path`: the hops through the provider networks to the remote host.
+* - `dns`: the resolution of names to addresses.
+* - `tcp`: the connections to a port.
+* - `tls`: the handshake and the certificate of the server.
+* - `http`: the request and the response.
+*/
+const LAYERS = [
+	"link",
+	"wifi",
+	"ip",
+	"route",
+	"path",
+	"dns",
+	"tcp",
+	"tls",
+	"http"
+];
+const RANKS = new Map(LAYERS.map((layer, rank) => [layer, rank]));
+/** This function tells if a value is the name of a layer. */
+function isLayer(value) {
+	return typeof value === "string" && RANKS.has(value);
+}
+/** This function gives the position of a layer in `LAYERS`. The bottom layer `link` has the position 0. */
+function layerRank(layer) {
+	const rank = RANKS.get(layer);
+	if (rank === void 0) throw new RangeError(`"${String(layer)}" is not a layer`);
+	return rank;
+}
+// src/diagnosis/model.ts
+/** The parts of the model. Each fault is in one part. */
+const PARTS = [
+	"interface",
+	"wifi",
+	"gateway",
+	"resolver",
+	"path",
+	"service"
+];
+/** The probability that each strength gives to the expected values together. */
+const STRENGTHS = {
+	sure: .98,
+	strong: .9,
+	usual: .75,
+	weak: .6
+};
+function isExpectation(prediction) {
+	return typeof prediction.strength === "string";
+}
+/** The id of the hypothesis "no fault". */
+const NONE = "none";
+/** The id of the hypothesis "unknown cause". */
+const UNKNOWN = "unknown";
+/** The lowest probability of a value. With a probability of 0, one wrong observation removes a cause. */
+const FLOOR = .001;
+const SUM_TOLERANCE = 1e-9;
+function distributionProblems(where, feature, dist) {
+	const problems = [];
+	for (const value of Object.keys(dist)) if (!feature.values.includes(value)) problems.push(`${where}: "${value}" is not a value of ${feature.id}.`);
+	for (const value of feature.values) {
+		const p = dist[value];
+		if (p === void 0) problems.push(`${where}: the value "${value}" of ${feature.id} has no probability.`);
+		else if (!Number.isFinite(p) || p < .001) problems.push(`${where}: the probability of "${value}" is ${p}. It must be ${FLOOR} or more.`);
+	}
+	const sum = Object.values(dist).reduce((a, b) => a + b, 0);
+	if (Math.abs(sum - 1) > SUM_TOLERANCE) problems.push(`${where}: the sum of the probabilities is ${sum}, not 1.`);
+	return problems;
+}
+/** This function gives the full distribution of a prediction, or the problems of the prediction. */
+function expand(feature, prediction) {
+	if (!isExpectation(prediction)) return ok(prediction);
+	const expected = typeof prediction.expect === "string" ? [prediction.expect] : [...prediction.expect];
+	const unknown = expected.filter((value) => !feature.values.includes(value));
+	if (unknown.length > 0) return err(unknown.map((value) => `"${value}" is not a value of ${feature.id}.`));
+	if (expected.length === 0 || new Set(expected).size !== expected.length) return err([`The expected values of ${feature.id} are empty or repeated.`]);
+	const others = feature.values.filter((value) => !expected.includes(value));
+	const mass = others.length === 0 ? 1 : STRENGTHS[prediction.strength];
+	const dist = {};
+	for (const value of expected) dist[value] = mass / expected.length;
+	for (const value of others) dist[value] = (1 - mass) / others.length;
+	return ok(dist);
+}
+const ID = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/;
+/**
+* This function examines a catalog and makes its tables.
+*
+* It refuses a repeated id, an unknown feature or value, a probability below `FLOOR`, and a distribution with a sum that is not 1.
+*/
+function compileCatalog(spec) {
+	const problems = [];
+	const features = /* @__PURE__ */ new Map();
+	for (const feature of spec.features) {
+		if (!ID.test(feature.id)) problems.push(`"${feature.id}" is not a valid feature id.`);
+		if (features.has(feature.id)) problems.push(`The feature ${feature.id} is repeated.`);
+		if (feature.values.length < 2 || new Set(feature.values).size !== feature.values.length) problems.push(`The feature ${feature.id} must have two or more different values.`);
+		problems.push(...distributionProblems(`healthy of ${feature.id}`, feature, feature.healthy));
+		features.set(feature.id, feature);
+	}
+	const hypotheses = [{
+		id: NONE,
+		kind: "none",
+		summary: "The network has no fault.",
+		step: "No step is necessary."
+	}];
+	const priors = /* @__PURE__ */ new Map([[NONE, spec.priors?.none ?? 1]]);
+	const tables = /* @__PURE__ */ new Map();
+	for (const fault of spec.faults) {
+		if (!ID.test(fault.id) || fault.id === "none" || fault.id === "unknown") problems.push(`"${fault.id}" is not a valid fault id.`);
+		if (priors.has(fault.id)) problems.push(`The fault ${fault.id} is repeated.`);
+		priors.set(fault.id, fault.prior ?? 1);
+		hypotheses.push({
+			id: fault.id,
+			kind: "fault",
+			summary: fault.summary,
+			step: fault.step,
+			part: fault.part,
+			reach: fault.reach
+		});
+		const table = /* @__PURE__ */ new Map();
+		for (const [featureId, prediction] of Object.entries(fault.predicts)) {
+			const feature = features.get(featureId);
+			if (feature === void 0) {
+				problems.push(`The fault ${fault.id} predicts the unknown feature ${featureId}.`);
+				continue;
+			}
+			const dist = expand(feature, prediction);
+			if (dist.tag === "err") problems.push(...dist.error.map((problem) => `${fault.id}: ${problem}`));
+			else {
+				problems.push(...distributionProblems(`${fault.id} for ${featureId}`, feature, dist.value));
+				table.set(featureId, dist.value);
+			}
+		}
+		if (table.size === 0) problems.push(`The fault ${fault.id} predicts no feature.`);
+		tables.set(fault.id, table);
+	}
+	hypotheses.push({
+		id: UNKNOWN,
+		kind: "unknown",
+		summary: "The catalog does not have the cause.",
+		step: "Collect more facts, and report the facts as a new fault of the catalog."
+	});
+	priors.set(UNKNOWN, spec.priors?.unknown ?? 1);
+	for (const [id, prior] of priors) if (!Number.isFinite(prior) || prior <= 0) problems.push(`The prior of ${id} is ${prior}. It must be more than 0.`);
+	if (problems.length > 0) return err(problems);
+	const total = [...priors.values()].reduce((a, b) => a + b, 0);
+	const reach = new Map(hypotheses.map((h) => [h.id, h.reach]));
+	return ok({
+		version: spec.version,
+		features,
+		hypotheses,
+		prior: (hypothesis) => (priors.get(hypothesis) ?? 0) / total,
+		likelihood(hypothesis, featureId, value, primary) {
+			const feature = features.get(featureId);
+			if (feature === void 0 || !feature.values.includes(value)) return NaN;
+			if (hypothesis === "unknown") return 1 / feature.values.length;
+			const changed = tables.get(hypothesis)?.get(featureId);
+			return ((primary || reach.get(hypothesis) === "shared") && changed !== void 0 ? changed : feature.healthy)[value] ?? NaN;
+		}
+	});
+}
+function usable(catalog, evidence) {
+	const used = [];
+	const ignored = [];
+	for (const item of evidence) {
+		const feature = catalog.features.get(item.feature);
+		if (feature === void 0) ignored.push({
+			evidence: item,
+			reason: `The catalog has no feature ${item.feature}.`
+		});
+		else if (!feature.values.includes(item.value)) ignored.push({
+			evidence: item,
+			reason: `"${item.value}" is not a value of ${item.feature}.`
+		});
+		else used.push(item);
+	}
+	return {
+		used,
+		ignored
+	};
+}
+/**
+* This function gives the probability of each hypothesis from the evidence, with the rule of Bayes.
+*
+* The model takes the observations as independent for a given hypothesis. The calculation uses logarithms, so a long
+* list of evidence does not go to zero. The order of the evidence does not change the result.
+* An exact tie keeps the order of the catalog, with "no fault" first.
+*/
+function diagnose(catalog, evidence) {
+	const { used, ignored } = usable(catalog, evidence);
+	const logs = catalog.hypotheses.map((h) => {
+		let sum = Math.log(catalog.prior(h.id));
+		for (const item of used) sum += Math.log(catalog.likelihood(h.id, item.feature, item.value, item.primary));
+		return sum;
+	});
+	const top = Math.max(...logs);
+	const weights = logs.map((log) => Math.exp(log - top));
+	const total = weights.reduce((a, b) => a + b, 0);
+	return {
+		causes: catalog.hypotheses.map((h, i) => ({
+			...h,
+			probability: (weights[i] ?? 0) / total,
+			order: i
+		})).sort((a, b) => b.probability - a.probability || a.order - b.order).map(({ order: _order, ...cause }) => cause),
+		used,
+		ignored
+	};
+}
+/**
+* This function tells why the model prefers one hypothesis to a second hypothesis.
+*
+* It gives each observation with its weight, from the largest weight in absolute value. The default second hypothesis is
+* "no fault".
+*/
+function explain(catalog, evidence, hypothesis, versus = NONE) {
+	const { used } = usable(catalog, evidence);
+	return used.map((item) => ({
+		evidence: item,
+		weight: Math.log10(catalog.likelihood(hypothesis, item.feature, item.value, item.primary)) - Math.log10(catalog.likelihood(versus, item.feature, item.value, item.primary))
+	})).sort((a, b) => Math.abs(b.weight) - Math.abs(a.weight));
+}
+/**
+* This function gives the probability of each value of a feature that is not observed yet, from the probabilities of
+* the causes. The choice of the next probe uses it.
+*/
+function predictive(catalog, diagnosis, feature, primary) {
+	const known = catalog.features.get(feature);
+	if (known === void 0) throw new RangeError(`The catalog has no feature ${feature}`);
+	const dist = {};
+	for (const value of known.values) dist[value] = diagnosis.causes.reduce((sum, cause) => sum + cause.probability * catalog.likelihood(cause.id, feature, value, primary), 0);
+	return dist;
+}
+// src/diagnosis/catalog.ts
+/**
+* The features of the standard catalog.
+*
+* The readers of the facts give these features. The distribution `healthy` of each feature is a rule of practice. The
+* lab runs (ND-7) then fit it.
+*/
+const STANDARD_FEATURES = [
+	{
+		id: "link.state",
+		layer: "link",
+		summary: "The state of the link of the network interface.",
+		values: ["up", "down"],
+		healthy: {
+			up: .999,
+			down: .001
+		}
+	},
+	{
+		id: "wifi.signal",
+		layer: "wifi",
+		summary: "The strength of the Wi-Fi signal: strong above -60 dBm, weak below -75 dBm.",
+		values: [
+			"strong",
+			"fair",
+			"weak"
+		],
+		healthy: {
+			strong: .7,
+			fair: .25,
+			weak: .05
+		}
+	},
+	{
+		id: "gateway.reply",
+		layer: "route",
+		summary: "The gateway answers an ICMP echo request.",
+		values: ["reply", "none"],
+		healthy: {
+			reply: .97,
+			none: .03
+		}
+	},
+	{
+		id: "path.loss",
+		layer: "path",
+		summary: "The packet loss on the path: none, some (up to 5 %) or high (more than 5 %).",
+		values: [
+			"none",
+			"some",
+			"high"
+		],
+		healthy: {
+			none: .9,
+			some: .08,
+			high: .02
+		}
+	},
+	{
+		id: "dns.answer",
+		layer: "dns",
+		summary: "The result of the DNS lookup of the name of the target.",
+		values: [
+			"ok",
+			"nxdomain",
+			"servfail",
+			"refused",
+			"timeout"
+		],
+		healthy: {
+			ok: .97,
+			nxdomain: .01,
+			servfail: .005,
+			refused: .005,
+			timeout: .01
+		}
+	},
+	{
+		id: "dns.address",
+		layer: "dns",
+		summary: "The kind of the addresses of a public name: public, or private (RFC 1918, RFC 4193 or loopback).",
+		values: ["public", "private"],
+		healthy: {
+			public: .95,
+			private: .05
+		}
+	},
+	{
+		id: "ip.family",
+		layer: "ip",
+		summary: "The address families that connect, for a host with IPv4 and IPv6 addresses.",
+		values: [
+			"both",
+			"ipv4-only",
+			"ipv6-only"
+		],
+		healthy: {
+			both: .9,
+			"ipv4-only": .08,
+			"ipv6-only": .02
+		}
+	},
+	{
+		id: "icmp.reply",
+		layer: "ip",
+		summary: "The host answers an ICMP echo request, does not answer, or a router tells that it is unreachable.",
+		values: [
+			"reply",
+			"none",
+			"unreachable"
+		],
+		healthy: {
+			reply: .85,
+			none: .14,
+			unreachable: .01
+		}
+	},
+	{
+		id: "tcp.connect",
+		layer: "tcp",
+		summary: "The outcome of a TCP connect to the port of the target.",
+		values: [
+			"connected",
+			"refused",
+			"timeout",
+			"unreachable",
+			"reset"
+		],
+		healthy: {
+			connected: .97,
+			refused: .01,
+			timeout: .01,
+			unreachable: .005,
+			reset: .005
+		}
+	},
+	{
+		id: "tcp.time",
+		layer: "tcp",
+		summary: "The time of the TCP connect: short (below 150 ms), long, or retry (900 ms or more, a SYN sent again).",
+		values: [
+			"short",
+			"long",
+			"retry"
+		],
+		healthy: {
+			short: .8,
+			long: .18,
+			retry: .02
+		}
+	},
+	{
+		id: "tls.handshake",
+		layer: "tls",
+		summary: "The outcome of the TLS handshake.",
+		values: [
+			"ok",
+			"cert-error",
+			"alert",
+			"timeout",
+			"reset"
+		],
+		healthy: {
+			ok: .97,
+			"cert-error": .01,
+			alert: .01,
+			timeout: .005,
+			reset: .005
+		}
+	},
+	{
+		id: "tls.ratio",
+		layer: "tls",
+		summary: "The time of the TLS handshake divided by the time of the TCP connect: low (below 3), mid, or high (above 8).",
+		values: [
+			"low",
+			"mid",
+			"high"
+		],
+		healthy: {
+			low: .75,
+			mid: .2,
+			high: .05
+		}
+	},
+	{
+		id: "tls.trust",
+		layer: "tls",
+		summary: "The issuer of the certificate: a public root of trust, or a private root.",
+		values: ["public", "private"],
+		healthy: {
+			public: .97,
+			private: .03
+		}
+	},
+	{
+		id: "http.status",
+		layer: "http",
+		summary: "The class of the HTTP status: ok (2xx and 3xx), client-error (4xx), server-error (5xx), or none.",
+		values: [
+			"ok",
+			"client-error",
+			"server-error",
+			"none"
+		],
+		healthy: {
+			ok: .95,
+			"client-error": .03,
+			"server-error": .01,
+			none: .01
+		}
+	},
+	{
+		id: "http.ttfb",
+		layer: "http",
+		summary: "The time to the first byte divided by the time of the TCP connect: low (below 4), mid, or high (above 20).",
+		values: [
+			"low",
+			"mid",
+			"high"
+		],
+		healthy: {
+			low: .6,
+			mid: .3,
+			high: .1
+		}
+	}
+];
+/**
+* The faults of the standard catalog. Each prediction is a rule of practice. The lab runs (ND-7) then fit the
+* distributions, and the priors.
+*/
+const STANDARD_FAULTS = [
+	{
+		id: "interface.down",
+		part: "interface",
+		reach: "shared",
+		summary: "The network interface has no link.",
+		step: "Connect the cable or the Wi-Fi network, and make sure that the interface is on.",
+		predicts: {
+			"link.state": {
+				expect: "down",
+				strength: "sure"
+			},
+			"gateway.reply": {
+				expect: "none",
+				strength: "sure"
+			},
+			"dns.answer": {
+				expect: "timeout",
+				strength: "strong"
+			},
+			"icmp.reply": {
+				expect: ["none", "unreachable"],
+				strength: "sure"
+			},
+			"tcp.connect": {
+				expect: ["unreachable", "timeout"],
+				strength: "sure"
+			}
+		}
+	},
+	{
+		id: "wifi.weak",
+		part: "wifi",
+		reach: "shared",
+		summary: "The Wi-Fi signal is weak, so the link loses packets.",
+		step: "Move nearer to the access point, or use a cable.",
+		predicts: {
+			"wifi.signal": {
+				expect: "weak",
+				strength: "strong"
+			},
+			"path.loss": {
+				expect: ["some", "high"],
+				strength: "usual"
+			},
+			"tcp.time": {
+				expect: ["long", "retry"],
+				strength: "usual"
+			}
+		}
+	},
+	{
+		id: "gateway.down",
+		part: "gateway",
+		reach: "shared",
+		summary: "The gateway does not forward packets.",
+		step: "Restart the router, or examine the link from the router to the provider.",
+		predicts: {
+			"gateway.reply": {
+				expect: "none",
+				strength: "strong"
+			},
+			"dns.answer": {
+				expect: "timeout",
+				strength: "strong"
+			},
+			"icmp.reply": {
+				expect: ["none", "unreachable"],
+				strength: "strong"
+			},
+			"tcp.connect": {
+				expect: ["timeout", "unreachable"],
+				strength: "strong"
+			}
+		}
+	},
+	{
+		id: "captive.portal",
+		part: "gateway",
+		reach: "shared",
+		summary: "A captive portal holds the traffic until you sign in.",
+		step: "Open a web page in a browser, and accept the terms of the network.",
+		predicts: {
+			"dns.address": {
+				expect: "private",
+				strength: "usual"
+			},
+			"tls.handshake": {
+				expect: "cert-error",
+				strength: "strong"
+			},
+			"tls.trust": {
+				expect: "private",
+				strength: "usual"
+			}
+		}
+	},
+	{
+		id: "resolver.down",
+		part: "resolver",
+		reach: "shared",
+		summary: "The DNS resolver does not answer.",
+		step: "Use a different DNS resolver, or examine the resolver of the router.",
+		predicts: { "dns.answer": {
+			expect: "timeout",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "resolver.failing",
+		part: "resolver",
+		reach: "shared",
+		summary: "The DNS resolver answers with an error for each name.",
+		step: "Use a different DNS resolver, and examine the DNSSEC settings of the resolver.",
+		predicts: { "dns.answer": {
+			expect: ["servfail", "refused"],
+			strength: "strong"
+		} }
+	},
+	{
+		id: "name.missing",
+		part: "service",
+		reach: "target",
+		summary: "The name does not exist in DNS.",
+		step: "Examine the spelling of the name, and the records of its DNS zone.",
+		predicts: { "dns.answer": {
+			expect: "nxdomain",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "port.closed",
+		part: "service",
+		reach: "target",
+		summary: "No program listens on the port.",
+		step: "Start the service, or use the correct port.",
+		predicts: { "tcp.connect": {
+			expect: "refused",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "host.down",
+		part: "service",
+		reach: "target",
+		summary: "The host is down.",
+		step: "Start the host, or examine its network link.",
+		predicts: {
+			"tcp.connect": {
+				expect: ["timeout", "unreachable"],
+				strength: "strong"
+			},
+			"icmp.reply": {
+				expect: ["none", "unreachable"],
+				strength: "strong"
+			}
+		}
+	},
+	{
+		id: "filter.drop",
+		part: "path",
+		reach: "target",
+		summary: "A filter drops the packets to the port.",
+		step: "Examine the firewall rules of the host and of each network on the path.",
+		predicts: {
+			"tcp.connect": {
+				expect: "timeout",
+				strength: "strong"
+			},
+			"icmp.reply": {
+				reply: .5,
+				none: .45,
+				unreachable: .05
+			}
+		}
+	},
+	{
+		id: "filter.icmp",
+		part: "path",
+		reach: "target",
+		summary: "A filter blocks ICMP. The host is up.",
+		step: "No step is necessary for the service. Use TCP to examine the host.",
+		predicts: { "icmp.reply": {
+			expect: "none",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "filter.reset",
+		part: "path",
+		reach: "target",
+		summary: "A device on the path resets the connections.",
+		step: "Examine the firewalls and the filters of content on the path, and try a different network.",
+		predicts: {
+			"tcp.connect": {
+				connected: .5,
+				refused: .02,
+				timeout: .02,
+				unreachable: .02,
+				reset: .44
+			},
+			"tls.handshake": {
+				expect: "reset",
+				strength: "strong"
+			}
+		}
+	},
+	{
+		id: "path.loss",
+		part: "path",
+		reach: "target",
+		summary: "A network on the path loses packets.",
+		step: "Find the first hop with loss, and tell the provider of that network.",
+		predicts: {
+			"path.loss": {
+				expect: ["some", "high"],
+				strength: "strong"
+			},
+			"tcp.time": {
+				expect: ["long", "retry"],
+				strength: "usual"
+			},
+			"http.ttfb": {
+				expect: ["mid", "high"],
+				strength: "weak"
+			}
+		}
+	},
+	{
+		id: "path.mtu",
+		part: "path",
+		reach: "shared",
+		summary: "Large packets do not pass, and no ICMP message tells the size (an MTU black hole).",
+		step: "Lower the MTU of the interface or of the VPN, or enable MSS clamping on the router.",
+		predicts: {
+			"tls.handshake": {
+				expect: "timeout",
+				strength: "strong"
+			},
+			"http.status": {
+				expect: "none",
+				strength: "usual"
+			}
+		}
+	},
+	{
+		id: "ipv6.broken",
+		part: "path",
+		reach: "shared",
+		summary: "IPv6 does not work, and IPv4 works.",
+		step: "Examine the IPv6 settings of the router, or turn off IPv6 until the provider repairs it.",
+		predicts: {
+			"ip.family": {
+				expect: "ipv4-only",
+				strength: "strong"
+			},
+			"tcp.time": {
+				expect: ["long", "retry"],
+				strength: "weak"
+			}
+		}
+	},
+	{
+		id: "tls.proxy",
+		part: "path",
+		reach: "shared",
+		summary: "A proxy examines the TLS traffic.",
+		step: "Compare the issuer of the certificate with the issuer on a different network, and ask the owner of the network.",
+		predicts: {
+			"tls.ratio": {
+				expect: ["mid", "high"],
+				strength: "usual"
+			},
+			"tls.trust": {
+				expect: "private",
+				strength: "usual"
+			},
+			"tcp.time": {
+				expect: "short",
+				strength: "strong"
+			}
+		}
+	},
+	{
+		id: "tls.cert-invalid",
+		part: "service",
+		reach: "target",
+		summary: "The certificate of the server is not valid: it expired, or it is for a different name.",
+		step: "Renew the certificate of the server, or correct its names.",
+		predicts: { "tls.handshake": {
+			expect: "cert-error",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "tls.mismatch",
+		part: "service",
+		reach: "target",
+		summary: "The client and the server have no TLS version or cipher in common.",
+		step: "Enable TLS 1.2 or TLS 1.3 with modern ciphers on the server.",
+		predicts: { "tls.handshake": {
+			expect: "alert",
+			strength: "strong"
+		} }
+	},
+	{
+		id: "server.slow",
+		part: "service",
+		reach: "target",
+		summary: "The server is slow.",
+		step: "Examine the load and the logs of the server.",
+		predicts: {
+			"http.ttfb": {
+				expect: "high",
+				strength: "strong"
+			},
+			"tls.ratio": {
+				expect: ["mid", "high"],
+				strength: "weak"
+			}
+		}
+	},
+	{
+		id: "server.error",
+		part: "service",
+		reach: "target",
+		summary: "The server answers with an error.",
+		step: "Examine the logs of the server and of its upstream services.",
+		predicts: { "http.status": {
+			expect: "server-error",
+			strength: "strong"
+		} }
+	}
+];
+/** The standard catalog: the rules of practice as the first likelihoods. Each hypothesis has the prior weight 1. */
+const STANDARD_CATALOG_SPEC = {
+	version: "1",
+	features: STANDARD_FEATURES,
+	faults: STANDARD_FAULTS
+};
+/** The standard catalog, compiled. */
+const STANDARD_CATALOG = (() => {
+	const compiled = compileCatalog(STANDARD_CATALOG_SPEC);
+	if (compiled.tag === "err") throw new Error(`The standard catalog has problems: ${compiled.error.join(" ")}`);
+	return compiled.value;
+})();
+export { layerRank as _, FLOOR as a, STRENGTHS as c, diagnose as d, expand as f, isLayer as g, LAYERS as h, STANDARD_FEATURES as i, UNKNOWN as l, predictive as m, STANDARD_CATALOG_SPEC as n, NONE as o, explain as p, STANDARD_FAULTS as r, PARTS as s, STANDARD_CATALOG as t, compileCatalog as u };
+
+//# sourceMappingURL=diagnosis-BTa-Dfwl.js.map