@intentius/chant 0.124.13 → 0.124.14

package/dist/index.js

@@ -0,0 +1,118 @@
+/**
+ * chant Core
+ *
+ * Lexicon-agnostic declarative specification system
+ */
+export * from "./declarable.js";
+export * from "./held-elsewhere.js";
+export * from "./composite.js";
+export * from "./provenance.js";
+export * from "./secret-provenance.js";
+export * from "./secret-materialization.js";
+export * from "./effect-receipt.js";
+export * from "./build-params.js";
+export * from "./intrinsic.js";
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./attrref.js";
+export * from "./utils.js";
+export * from "./builder.js";
+export * from "./serializer.js";
+export * from "./lexicon-output.js";
+export * from "./discovery/files.js";
+export * from "./discovery/import.js";
+export * from "./discovery/collect.js";
+export * from "./discovery/cycles.js";
+export * from "./sort.js";
+export * from "./discovery/resolve.js";
+export * from "./discovery/graph.js";
+export * from "./discovery/index.js";
+export * from "./discovery/cache.js";
+export * from "./build.js";
+export * from "./env.js";
+export * from "./graph-ir.js";
+export * from "./graph-detail.js";
+export * from "./graph-mermaid.js";
+export * from "./graph-dot.js";
+export * from "./graph-layout.js";
+export * from "./graph-lens.js";
+export * from "./detectLexicon.js";
+export * from "./fold/fold.js";
+// The shape classifier is the predicate downstream tooling asks "will this
+// fold?" of without running a fold (subset.ts module doc, point 2c), and the
+// half of the fold subset a conformance adapter needs that `fold()` alone
+// does not expose. INTENTIUS/typescript-as-data#11.
+export { findSubsetViolation, checkObjectMember, collectLocalCallables } from "./fold/subset.js";
+// The version of the TypeScript-as-Data specification chant implements
+// (INTENTIUS/typescript-as-data#18, chant#2424). The specification's
+// conformance adapter reads this off the public entry; without it a suite
+// reports chant as `undeclared` rather than as implementing anything.
+export { SPEC_VERSION } from "./fold/subset.js";
+// The whole-build fold. `fold()` and `foldModule()` answer one expression and
+// one file; neither cross-file rule is observable at that granularity — the
+// forward rule needs an importer, the reverse rule needs a capturing sibling,
+// and the fixpoint needs the whole set. chant#2408,
+// INTENTIUS/typescript-as-data#62.
+export { foldProject, planFoldTaintWithEdges, 
+// F-Obs-Counters' three integers: what a build invoked, what it invoked from
+// project code, and what it interpreted instead. Already exported from the
+// module; on the public entry so a conformance harness can report them per
+// build (chant#2446, INTENTIUS/typescript-as-data#121). The counters are
+// process-wide and monotonic, so a per-build figure means calling
+// `resetFoldExecutionCounts()` first — which is why both travel together and
+// neither is useful alone.
+foldExecutionCounts, resetFoldExecutionCounts, } from "./discovery/fold-import.js";
+export * from "./lint/parser.js";
+export * from "./lint/rule.js";
+export * from "./lint/rules/index.js";
+export * from "./lint/declarative.js";
+export * from "./lint/selectors.js";
+export * from "./lint/named-checks.js";
+export * from "./lint/post-synth.js";
+export * from "./lint/policy.js";
+export * from "./lint/pipeline-change-gate.js";
+export * from "./lint/rule-loader.js";
+export * from "./lint/discover.js";
+export * from "./import/parser.js";
+export * from "./import/generator.js";
+export * from "./lexicon.js";
+export * from "./observation.js";
+export * from "./identity.js";
+export * from "./apply.js";
+export * from "./deep-observation.js";
+export * from "./behaviour.js";
+export * from "./behaviour-http.js";
+export * from "./behaviour-kinds.js";
+export * from "./behaviour-delta.js";
+export * from "./claimed-fields.js";
+export * from "./fold-provenance.js";
+export * from "./owner-chain.js";
+export * from "./lexicon-integrity.js";
+export * from "./lexicon-manifest.js";
+export * from "./lexicon-schema.js";
+export * from "./config.js";
+export * from "./validation.js";
+export * from "./project-validation.js";
+export * from "./codegen/naming.js";
+export * from "./codegen/fetch.js";
+export * from "./codegen/generate.js";
+export * from "./codegen/package.js";
+export * from "./codegen/typecheck.js";
+export * from "./codegen/coverage.js";
+export * from "./codegen/validate.js";
+export * from "./codegen/docs.js";
+export * from "./codegen/surface-snapshot.js";
+export { regenLexicon, writeSurfaceSnapshot, SNAPSHOT_FILENAME, } from "./codegen/lexicon-regen.js";
+export { checkRollingUpgrade, classifyDelta, diffRollingSurface, computeAzureApiVersionDelta, diffAzureApiVersions, extractAzureProvider, } from "./codegen/rolling-upgrade.js";
+export { checkPinnedUpgrade, applyPinnedVersionBump, isNewer, parseVersion, isPreRelease, } from "./codegen/pinned-upgrade.js";
+export * from "./runtime.js";
+export * from "./runtime-adapter.js";
+export * from "./resource-attributes.js";
+export * from "./stack-output.js";
+export * from "./child-project.js";
+export * from "./lsp/types.js";
+export * from "./lsp/lexicon-providers.js";
+export * from "./mcp/types.js";
+export * from "./lifecycle/index.js";
+// Op builders — use explicit exports to avoid collision with the core `build` function
+export { Op, phase, activity, gate, kubectlApply, helmInstall, waitForStack, gitlabPipeline, lifecycleSnapshot, shell, teardown, OpResource } from "./op/index.js";

package/dist/intrinsic-interpolation.js

@@ -0,0 +1,73 @@
+/**
+ * Tagged template interpolation helper.
+ *
+ * Implements the lockstep walk over tagged template literal parts/values,
+ * dispatching on AttrRef / Intrinsic / Declarable / primitive.
+ * Each lexicon provides format-specific serialization strings.
+ */
+import { INTRINSIC_MARKER } from "./intrinsic.js";
+import { DECLARABLE_MARKER } from "./declarable.js";
+import { isAttrRefLike } from "./utils.js";
+/**
+ * Default serialization dispatch for interpolated values.
+ *
+ * Handles: AttrRef → Intrinsic (with Ref special case) → Declarable (throws) → primitive.
+ * Lexicons can wrap/extend this for format-specific behavior.
+ *
+ * @param serializeAttrRef - Format an AttrRef: (logicalName, attribute) → string
+ * @param serializeRef - Format a Ref intrinsic: (refName) → string
+ */
+export function defaultInterpolationSerializer(serializeAttrRef, serializeRef) {
+    return (value) => {
+        // Handle AttrRef. Duck-type, not `instanceof` (chant #1137): a lexicon
+        // built against a separate copy of `@intentius/chant` produces AttrRefs
+        // that fail `instanceof AttrRef` here but carry the same shape — and
+        // since AttrRef also implements Intrinsic, missing this branch does not
+        // fail loud. The value instead falls into the generic Intrinsic branch
+        // below, which calls `toJSON()` (returning the `{__attrRef}` wire
+        // envelope, not a `Ref`) and silently stringifies it to `[object
+        // Object]` in the interpolated output.
+        if (isAttrRefLike(value)) {
+            const logicalName = value.getLogicalName();
+            if (!logicalName) {
+                throw new Error(`Cannot serialize AttrRef for attribute "${value.attribute}": logical name not set`);
+            }
+            return serializeAttrRef(logicalName, value.attribute);
+        }
+        // Handle Intrinsics with toJSON
+        if (typeof value === "object" &&
+            value !== null &&
+            INTRINSIC_MARKER in value &&
+            "toJSON" in value &&
+            typeof value.toJSON === "function") {
+            const result = value.toJSON();
+            // If it's a Ref, use the ref serializer
+            if (typeof result === "object" && result !== null && "Ref" in result) {
+                return serializeRef(result.Ref);
+            }
+            return String(value);
+        }
+        // Handle Declarables — error
+        if (typeof value === "object" &&
+            value !== null &&
+            DECLARABLE_MARKER in value) {
+            throw new Error("Cannot embed Declarable directly in Sub template. Use AttrRef instead.");
+        }
+        // Primitive
+        return String(value);
+    };
+}
+/**
+ * Walk tagged template literal parts/values in lockstep,
+ * serializing each value via the provided serializer.
+ */
+export function buildInterpolatedString(templateParts, values, serializeValue) {
+    let result = "";
+    for (let i = 0; i < templateParts.length; i++) {
+        result += templateParts[i];
+        if (i < values.length) {
+            result += serializeValue(values[i]);
+        }
+    }
+    return result;
+}

package/dist/intrinsic.js

@@ -0,0 +1,31 @@
+/**
+ * Marker symbol for Intrinsic type identification
+ */
+export const INTRINSIC_MARKER = Symbol.for("chant.intrinsic");
+/**
+ * Type guard to check if a value is an Intrinsic
+ */
+export function isIntrinsic(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        INTRINSIC_MARKER in value &&
+        value[INTRINSIC_MARKER] === true);
+}
+/**
+ * Recursively unwrap intrinsic values by calling `toJSON()`.
+ *
+ * - If the value has the INTRINSIC_MARKER and a `toJSON` method, calls it.
+ * - If the value is an array, recurses into each element.
+ * - Otherwise returns the value as-is.
+ */
+export function resolveIntrinsicValue(value) {
+    if (value !== null && typeof value === "object" && INTRINSIC_MARKER in value) {
+        if ("toJSON" in value && typeof value.toJSON === "function") {
+            return value.toJSON();
+        }
+    }
+    if (Array.isArray(value)) {
+        return value.map(resolveIntrinsicValue);
+    }
+    return value;
+}

package/dist/join-key.js

@@ -0,0 +1,35 @@
+/**
+ * The one join key for names matched across projects (#2524 D6, ws-008).
+ *
+ * A consumer's parameter and a producer's output are joined by name when
+ * nobody wrote the join down. Deploy matches names exactly, and real projects
+ * rarely spell both sides the same (`clusterArn` against `ClusterArn`), so an
+ * inferred join compares {@link joinKey}s and says how it matched: `exact`
+ * when the names are equal, `folded` when only case or punctuation differ.
+ * A declared member link is always compared exactly and never uses this.
+ *
+ * Before this module, core only published the handles (a graph IR's
+ * `exports` and `imports`) and each viewer matched them with its own rule.
+ * Every reader that infers a join by name uses this function instead, so the
+ * same workspace shows the same inferred edges everywhere. It imports nothing,
+ * so any reader can load it through `@intentius/chant/join-key`.
+ */
+/**
+ * The key two names are joined on: Unicode-normalised, lowercased, with every
+ * character that is not a letter or a digit removed. `ClusterArn`,
+ * `clusterArn`, `cluster_arn` and `cluster-arn` share the key `clusterarn`.
+ */
+export function joinKey(name) {
+    return name.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+/**
+ * How `a` and `b` join: `exact` when they are the same string, `folded` when
+ * only their {@link joinKey}s are equal, and undefined when they don't join.
+ * Names whose key is empty never join.
+ */
+export function joinLabel(a, b) {
+    if (a === b)
+        return a === "" ? undefined : "exact";
+    const key = joinKey(a);
+    return key !== "" && key === joinKey(b) ? "folded" : undefined;
+}

package/dist/kubectl-context.js

@@ -0,0 +1,150 @@
+/**
+ * K8s environment→cluster binding — chant #1100.
+ *
+ * Every cloud lexicon binds an environment to a scope: AWS resolves `<env>`
+ * to a CloudFormation stack, Azure treats `<env>` as the resource group,
+ * Fly resolves it to an app. K8s (and
+ * GCP-via-Config-Connector, which observes through the same kubectl path)
+ * bound nothing — `describeResources` shelled out to `kubectl get` with no
+ * `--context`, so it read whatever cluster `kubectl config current-context`
+ * happened to point at. Point `prod` at a dev cluster and every declared
+ * resource reads as missing — a wrong-cluster diff that looks like a
+ * confident list of deletions.
+ *
+ * This module is the shared resolver both the k8s and gcp lexicons'
+ * `describeResources` call, so they resolve a cluster identity the same way
+ * (see `lexicons/k8s/src/config.ts`'s `K8sChantConfig` for the declared
+ * shape). It is intentionally provider-agnostic and lives in core (like
+ * `./ownership.ts`) rather than in the k8s lexicon package, since gcp's
+ * Config Connector observation needs it too without taking a dependency on
+ * the k8s lexicon.
+ */
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+/**
+ * Historically thrown when an environment declared a cluster binding but the
+ * ambient kubectl context disagreed with it (#1100/#1155). As of #1488 the
+ * resolver no longer polices ambient at all — a declared binding is USED, not
+ * checked — so {@link resolveClusterTarget} never throws this anymore. The
+ * class stays exported because the k8s lexicon's read/write paths still catch
+ * it (converting a refusal into NOT-OBSERVED), and a custom connector may
+ * still throw it to get that classification.
+ */
+export class ClusterBindingMismatchError extends Error {
+    constructor(environment, expectedContext, ambientContext) {
+        super(`k8s: environment "${environment}" is bound to cluster context "${expectedContext}" ` +
+            `(k8s.profiles.${environment}.context), but the ambient kubectl context is ` +
+            `"${ambientContext}". Refusing to observe — reading the wrong cluster would misreport ` +
+            `every declared resource as missing. Run \`kubectl config use-context ${expectedContext}\` ` +
+            `to switch, or update the binding in chant.config.ts if "${ambientContext}" is actually correct.`);
+        this.environment = environment;
+        this.expectedContext = expectedContext;
+        this.ambientContext = ambientContext;
+        this.name = "ClusterBindingMismatchError";
+    }
+}
+/** Reads `kubectl config current-context`. Returns undefined if unset or kubectl fails. */
+const currentAmbientContext = async () => {
+    try {
+        const { stdout } = await execAsync("kubectl config current-context");
+        const trimmed = stdout.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Resolve the kubectl context an environment should be observed/applied
+ * against, reading `k8s.profiles.<environment>.context` from `chant.config.ts`
+ * (the `config` passed in is the passthrough `ChantConfig`, cast loosely since
+ * the `k8s` key isn't declared on the core schema — the same pattern every
+ * lexicon namespace follows).
+ *
+ * - No binding declared: returns `{ source: "ambient" }` — unchanged
+ *   behavior — but logs a visible warning identifying the caller and
+ *   environment, so the fallback is never silent (#1100 acceptance).
+ * - Binding declared: returns `{ context: bound, source: "bound" }`,
+ *   regardless of what is ambient (#1488). The declared binding is the
+ *   selection, not a check: callers pass this context explicitly on every
+ *   read and write, so whichever cluster `kubectl` happens to be pointed at
+ *   is irrelevant. Any k3d cluster another project creates mid-session used
+ *   to steal the ambient context and turn a healthy estate grey with
+ *   `read-failed` as the only explanation; now it cannot. A bound context
+ *   that is absent from the kubeconfig fails downstream in the typed client
+ *   with an error naming the context and the `k8s.profiles.<env>.context`
+ *   binding — never by falling back to ambient.
+ */
+export async function resolveClusterTarget(config, environment, lexiconName, options = {}) {
+    // #1344 — the k8s lexicon declares this namespace and core validates it at
+    // load, so the shape is checked rather than asserted. `K8sConfigShape` stays
+    // as core's local description for the case where the lexicon is absent.
+    const k8sConfig = config.k8s;
+    const bound = k8sConfig?.profiles?.[environment]?.context;
+    if (!bound) {
+        console.warn(`[${lexiconName}] no cluster binding for environment "${environment}" ` +
+            `(k8s.profiles.${environment}.context in chant.config.ts) — observing whatever kubectl ` +
+            `context is ambient. Add a binding to pin this environment to a specific cluster (chant #1100).`);
+        return { source: "ambient" };
+    }
+    return { context: bound, source: "bound" };
+}
+/** Pull whatever the child process actually said out of an exec rejection. */
+function execErrorText(err) {
+    if (typeof err === "object" && err !== null) {
+        const e = err;
+        const stderr = typeof e.stderr === "string" ? e.stderr.trim() : "";
+        if (stderr)
+            return stderr;
+        if (typeof e.message === "string")
+            return e.message.trim();
+    }
+    return String(err);
+}
+/** Collapse kubectl's noise to one line for a plan/diff entry. */
+function firstLine(text, max = 200) {
+    const line = text.split("\n").find((l) => l.trim().length > 0)?.trim() ?? text.trim();
+    return line.length > max ? `${line.slice(0, max - 3)}...` : line;
+}
+/**
+ * Classify a `kubectl get` failure into the observation tri-state (#1089).
+ *
+ * Only a genuine `NotFound` from the API server — or a kind the server does not
+ * serve at all, where no instance can exist — establishes absence. Auth,
+ * connectivity, and unresolvable contexts establish nothing, and must reach the
+ * change set as NOT-OBSERVED rather than as an empty result.
+ */
+export function classifyKubectlFailure(err) {
+    const text = execErrorText(err);
+    const lower = text.toLowerCase();
+    // The object was looked for and is not there.
+    if (lower.includes("notfound") || /error from server \(notfound\)/.test(lower) || lower.includes("not found")) {
+        return { kind: "absent" };
+    }
+    // The cluster serves no such kind, so no instance of it can exist there. The
+    // usual cause is a CRD this same plan has not applied yet — a real absence,
+    // and the case a create is for.
+    if (lower.includes("the server doesn't have a resource type") ||
+        lower.includes("the server could not find the requested resource")) {
+        return { kind: "absent" };
+    }
+    if (lower.includes("unauthorized") ||
+        lower.includes("forbidden") ||
+        lower.includes("you must be logged in") ||
+        lower.includes("invalid bearer token") ||
+        lower.includes("credentials")) {
+        return { kind: "unobserved", reason: "no-credentials", detail: firstLine(text) };
+    }
+    if (lower.includes("unable to connect to the server") ||
+        lower.includes("connection refused") ||
+        lower.includes("no configuration has been provided") ||
+        lower.includes("did you specify the right host or port") ||
+        lower.includes("context was not found") ||
+        /context ".*" does not exist/.test(lower) ||
+        lower.includes("no such host") ||
+        lower.includes("i/o timeout")) {
+        return { kind: "unobserved", reason: "no-binding", detail: firstLine(text) };
+    }
+    return { kind: "unobserved", reason: "read-failed", detail: firstLine(text) };
+}

package/dist/lexicon-config.js

@@ -0,0 +1,58 @@
+/**
+ * The config namespace a lexicon owns (#1344).
+ *
+ * Three lexicons read a top-level `chant.config.ts` key named after themselves —
+ * `k8s.profiles.<env>.context`, `forgejo.runnerLabels` and
+ * `forgejo.actionsRoot` — all documented for users, none declared anywhere.
+ * `ChantConfigSchema` is `.passthrough()`, so at runtime any key is accepted and
+ * a typo is silently ignored: write `runnerLabel` and the Forgejo dialect just
+ * uses its defaults, with nothing said. The `ChantConfig` interface is closed,
+ * so the documented forgejo example did not even compile:
+ *
+ *     error TS2353: Object literal may only specify known properties,
+ *     and 'forgejo' does not exist in type 'ChantConfig'.
+ *
+ * The lexicons had arrived at different workarounds: one exported its own
+ * widened config type, k8s's docs dropped `satisfies`, and forgejo's kept it
+ * and were wrong.
+ *
+ * A lexicon now declares the shape of its namespace. The declaration is both
+ * halves of the fix at once: core validates against it at load, and the lexicon
+ * derives the type it augments `ChantConfig` with from the same schema, so the
+ * runtime rule and the compile-time one cannot disagree.
+ */
+/**
+ * Validate each lexicon's own namespace against the schema it declares.
+ *
+ * A lexicon that declares nothing keeps today's passthrough — silence for an
+ * unknown key — because tightening a namespace nobody described would fail
+ * configs that are working. Declaring is the opt-in.
+ *
+ * An absent namespace is not a problem: every one of them is optional.
+ */
+export function validateLexiconConfig(lexicons, config) {
+    if (!config)
+        return [];
+    const problems = [];
+    const raw = config;
+    for (const lexicon of lexicons) {
+        const schema = lexicon.configSchema;
+        if (!schema)
+            continue;
+        const value = raw[lexicon.name];
+        if (value === undefined)
+            continue;
+        const result = schema.strict().safeParse(value);
+        if (result.success)
+            continue;
+        for (const issue of result.error.issues) {
+            const path = [lexicon.name, ...issue.path.map(String)].join(".");
+            problems.push({ lexicon: lexicon.name, path, message: issue.message });
+        }
+    }
+    return problems;
+}
+/** One line per problem, for a CLI error. */
+export function formatLexiconConfigProblems(problems) {
+    return problems.map((p) => `  ${p.path}: ${p.message}`).join("\n");
+}

package/dist/lexicon-integrity.js

@@ -0,0 +1,47 @@
+import { getRuntime } from "./runtime-adapter.js";
+/**
+ * Hash a single artifact's content using the runtime's hash algorithm.
+ */
+export function hashArtifact(content) {
+    return getRuntime().hash(content);
+}
+/**
+ * Compute integrity for all artifacts in a BundleSpec.
+ */
+export function computeIntegrity(spec) {
+    const artifacts = {};
+    // Hash each artifact
+    artifacts["manifest.json"] = hashArtifact(JSON.stringify(spec.manifest, null, 2));
+    artifacts["meta.json"] = hashArtifact(spec.registry);
+    artifacts["types/index.d.ts"] = hashArtifact(spec.typesDTS);
+    for (const [name, content] of spec.rules) {
+        artifacts[`rules/${name}`] = hashArtifact(content);
+    }
+    for (const [name, content] of spec.skills) {
+        artifacts[`skills/${name}`] = hashArtifact(content);
+    }
+    // Composite hash: sorted key:hash pairs
+    const sorted = Object.entries(artifacts).sort(([a], [b]) => a.localeCompare(b));
+    const compositeInput = sorted.map(([k, v]) => `${k}:${v}`).join("\n");
+    const composite = hashArtifact(compositeInput);
+    return { algorithm: getRuntime().hashAlgorithm, artifacts, composite };
+}
+/**
+ * Verify integrity of a BundleSpec against expected hashes.
+ */
+export function verifyIntegrity(spec, expected) {
+    const actual = computeIntegrity(spec);
+    const mismatches = [];
+    for (const [key, expectedHash] of Object.entries(expected.artifacts)) {
+        if (actual.artifacts[key] !== expectedHash) {
+            mismatches.push(key);
+        }
+    }
+    // Check for artifacts in actual but not in expected
+    for (const key of Object.keys(actual.artifacts)) {
+        if (!(key in expected.artifacts)) {
+            mismatches.push(key);
+        }
+    }
+    return { ok: mismatches.length === 0, mismatches };
+}

package/dist/lexicon-manifest.js

@@ -0,0 +1,70 @@
+/**
+ * Lexicon manifest validation and version compatibility checking.
+ */
+/**
+ * Check if the current version satisfies a semver range requirement.
+ * Supports: >=X.Y.Z, <=X.Y.Z, >X.Y.Z, <X.Y.Z, =X.Y.Z, X.Y.Z (exact match)
+ */
+export function checkVersionCompatibility(required, current) {
+    const trimmed = required.trim();
+    if (!trimmed)
+        return true;
+    let op;
+    let versionStr;
+    if (trimmed.startsWith(">=")) {
+        op = ">=";
+        versionStr = trimmed.slice(2).trim();
+    }
+    else if (trimmed.startsWith("<=")) {
+        op = "<=";
+        versionStr = trimmed.slice(2).trim();
+    }
+    else if (trimmed.startsWith(">")) {
+        op = ">";
+        versionStr = trimmed.slice(1).trim();
+    }
+    else if (trimmed.startsWith("<")) {
+        op = "<";
+        versionStr = trimmed.slice(1).trim();
+    }
+    else if (trimmed.startsWith("=")) {
+        op = "=";
+        versionStr = trimmed.slice(1).trim();
+    }
+    else {
+        op = "=";
+        versionStr = trimmed;
+    }
+    const requiredParts = parseVersion(versionStr);
+    const currentParts = parseVersion(current.trim());
+    if (!requiredParts || !currentParts)
+        return false;
+    const cmp = compareVersions(currentParts, requiredParts);
+    switch (op) {
+        case ">=": return cmp >= 0;
+        case "<=": return cmp <= 0;
+        case ">": return cmp > 0;
+        case "<": return cmp < 0;
+        case "=": return cmp === 0;
+        default: return false;
+    }
+}
+function parseVersion(v) {
+    // Strip leading 'v'
+    if (v.startsWith("v"))
+        v = v.slice(1);
+    const parts = v.split(".");
+    if (parts.length < 2 || parts.length > 3)
+        return null;
+    const nums = parts.map(Number);
+    if (nums.some(isNaN))
+        return null;
+    return [nums[0], nums[1], nums[2] ?? 0];
+}
+function compareVersions(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return 0;
+}

package/dist/lexicon-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicon-module.d.ts","sourceRoot":"","sources":["../src/lexicon-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAExE;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;AAC/E,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAiBvG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACxC,OAAO,EAAE,MAAM,EACf,SAAS,SAAM,GACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,EAClD,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxB;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAM3G;AAED,2DAA2D;AAC3D,wBAAgB,sBAAsB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE5D;AAED,sGAAsG;AACtG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAWpG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,MAAsB,EAC/B,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,CAKR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,EAAE,CAEV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI9D;AAUD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,MAAM,GAAG,SAAS,CAMpG;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAU1H"}
+{"version":3,"file":"lexicon-module.d.ts","sourceRoot":"","sources":["../src/lexicon-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAExE;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;AAC/E,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAiBvG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACxC,OAAO,EAAE,MAAM,EACf,SAAS,SAAM,GACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,EAClD,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxB;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAM3G;AAED,2DAA2D;AAC3D,wBAAgB,sBAAsB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE5D;AAED,sGAAsG;AACtG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAYpG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,MAAsB,EAC/B,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,CAKR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,EAAE,CAEV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI9D;AAUD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,MAAM,GAAG,SAAS,CAMpG;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAW1H"}