@intentius/chant-lexicon-otel 0.124.46 → 0.124.48

package/dist/spec/parse.js

@@ -0,0 +1,337 @@
+/**
+ * `config.schema.yaml` to TypeScript (#3361).
+ *
+ * `schemagen` writes a small JSON Schema dialect: `type`, `properties`,
+ * `items`, `additionalProperties`, `enum`, `allOf` (an embedded struct,
+ * `mapstructure:",squash"`), `$ref` and `$defs`, `format: duration`, and three
+ * extensions:
+ *
+ * - `x-customType`, the Go type when the JSON type alone loses it (`int64`,
+ *   `component.ID`, `time.Duration`, or a type from outside the collector);
+ * - `x-optional`, a `configoptional.Optional`: the key may be written with no
+ *   value (`grpc:`) to turn the section on with its defaults, so it also takes
+ *   `null`;
+ * - `x-pointer`, a Go pointer, which changes nothing in YAML.
+ *
+ * It writes no `required`, so every generated property is optional; what a
+ * component cannot start without is its definition's `validate` overlay.
+ *
+ * Every definition reached from a built-in becomes one named type alias,
+ * `<document><Definition>`, so recursive definitions (tail_sampling's `and`
+ * and `not` policies) are expressible. A `$ref` to a document upstream does
+ * not publish, or to a definition it lacks, becomes `unknown` and is listed in
+ * {@link GeneratedTypes.unresolved}.
+ */
+import { CONTRIB_MODULE, CORE_MODULE, resolveRef } from "./fetch.js";
+/** How each `x-customType` reads in TypeScript. A type not listed falls back on the node's JSON `type`. */
+const CUSTOM_TYPES = {
+    int: "number",
+    int8: "number",
+    int16: "number",
+    int32: "number",
+    int64: "number",
+    uint: "number",
+    uint8: "number",
+    uint16: "number",
+    uint32: "number",
+    uint64: "number",
+    float32: "number",
+    float64: "number",
+    any: "unknown",
+    "time.Duration": "Duration",
+    "go.opentelemetry.io/collector/component.ID": "string",
+    "go.opentelemetry.io/otel/attribute.key": "string",
+    "golang.org/x/time/rate.Limit": "number",
+    "net/url.values": "Record<string, string[]>",
+    "os.file_mode": "number | string",
+};
+/**
+ * Definitions whose Go type has its own unmarshaller, so the JSON type
+ * `schemagen` writes (the underlying `int`, or the stored form) is not all a
+ * YAML config may hold. Keyed by `<document>#<definition>`; a function gets
+ * the type generated from the schema and widens it.
+ */
+const TEXT_DEFINITIONS = {
+    // configopaque.MapList is stored as name/value pairs and also read from a plain map.
+    "go.opentelemetry.io/collector/config/configopaque#map_list": (generated) => `Record<string, string> | ${generated}`,
+    // configtelemetry.Level implements UnmarshalText over these names.
+    "go.opentelemetry.io/collector/config/configtelemetry#level": '"none" | "basic" | "normal" | "detailed"',
+    // spanmetrics' histogram unit, `ms` or `s`.
+    "github.com/open-telemetry/opentelemetry-collector-contrib/connector/spanmetricsconnector/internal/metrics#unit": '"ms" | "s"',
+    // stanza's ByteSize takes `1MiB` as well as a byte count.
+    "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza/operator/helper#byte_size": "number | string",
+    // Severities take a name (`INFO`, `warn`) as well as a number.
+    "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza/entry#severity": "number | string",
+    "go.opentelemetry.io/collector/pdata/plog#severity_number": "number | string",
+    "go.opentelemetry.io/collector/pdata/internal#severity_number": "number | string",
+};
+/** The TypeScript for one `x-customType`, or undefined when the JSON type should decide. */
+export function customType(name) {
+    return CUSTOM_TYPES[name];
+}
+function pascal(s) {
+    return s
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join("");
+}
+/** The type-name prefix for a document: its package path below the repository, PascalCased, with `Collector` for core packages. */
+export function documentAlias(doc) {
+    if (doc.startsWith(`${CONTRIB_MODULE}/`))
+        return pascal(doc.slice(CONTRIB_MODULE.length + 1));
+    if (doc.startsWith(`${CORE_MODULE}/`))
+        return `Collector${pascal(doc.slice(CORE_MODULE.length + 1))}`;
+    return pascal(doc);
+}
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propKey(name) {
+    return IDENT.test(name) ? name : JSON.stringify(name);
+}
+function jsdoc(description, indent, deprecated) {
+    const lines = [];
+    if (description)
+        lines.push(...description.replace(/\*\//g, "*\\/").split("\n"));
+    if (deprecated)
+        lines.push("@deprecated");
+    if (lines.length === 0)
+        return "";
+    if (lines.length === 1)
+        return `${indent}/** ${lines[0]} */\n`;
+    return `${indent}/**\n${lines.map((l) => `${indent} * ${l}`.trimEnd()).join("\n")}\n${indent} */\n`;
+}
+/** A description that says the field is deprecated, as Go comments do. */
+export function isDeprecated(description) {
+    // `Deprecated: use X`, `Deprecated [v0.130.0]: use X`, or a comment that opens with it.
+    return description !== undefined && /^\s*Deprecated\b|\bDeprecated(\s*\[[^\]]*\])?:/.test(description);
+}
+/** True for a document that is only a `$defs` container. */
+function isBareDocument(node) {
+    return !node.type && !node.properties && !node.allOf && !node.$ref;
+}
+/** A document's root type: the document itself, or its `config` definition when the document is only `$defs`. */
+function rootOf(node) {
+    if (node && isBareDocument(node) && node.$defs?.config)
+        return node.$defs.config;
+    return node;
+}
+/**
+ * Generate TypeScript for the root documents in `roots` and every definition
+ * they reach. `docs` holds every available document, keyed by Go package path.
+ */
+export function generateTypes(docs, roots) {
+    const decls = new Map();
+    const unresolved = new Map();
+    const pending = [];
+    const named = new Map();
+    const noteUnresolved = (key, from) => {
+        if (!unresolved.has(key))
+            unresolved.set(key, new Set());
+        unresolved.get(key).add(from);
+    };
+    // The type name for `doc` + `def` (def "" is the document's root), queued for emission on first use.
+    const nameFor = (doc, def) => {
+        const key = `${doc}#${def}`;
+        const known = named.get(key);
+        if (known)
+            return known;
+        const node = docs[doc];
+        if (!node)
+            return undefined;
+        // A package whose `Config` lives under `$defs` (signaltometrics' `config`
+        // package) has no root type; the document stands for that definition.
+        if (def === "" && isBareDocument(node) && node.$defs?.config)
+            return nameFor(doc, "config");
+        // `pkg.config` names the package's `Config` struct, which schemagen
+        // writes as the document root rather than under `$defs`.
+        if (def !== "" && !node.$defs?.[def])
+            return def === "config" ? nameFor(doc, "") : undefined;
+        let name = documentAlias(doc) + (def === "" ? "Schema" : pascal(def));
+        while ([...named.values()].includes(name))
+            name += "_";
+        named.set(key, name);
+        pending.push({ doc, def, name });
+        return name;
+    };
+    const tsType = (node, doc, indent) => {
+        if (!node || typeof node !== "object")
+            return "unknown";
+        let t = baseType(node, doc, indent);
+        if (node["x-optional"])
+            t = `${parenthesize(t)} | null`;
+        return t;
+    };
+    const parenthesize = (t) => (/[|&]/.test(t) && !/^\{[\s\S]*\}$/.test(t) ? `(${t})` : t);
+    const objectBody = (props, doc, indent) => {
+        const inner = `${indent}  `;
+        const lines = Object.keys(props)
+            .sort()
+            .map((k) => {
+            const p = props[k];
+            return `${jsdoc(p.description, inner, isDeprecated(p.description))}${inner}${propKey(k)}?: ${tsType(p, doc, inner)};\n`;
+        });
+        return `{\n${lines.join("")}${indent}}`;
+    };
+    const baseType = (node, doc, indent) => {
+        if (node.$ref) {
+            const { doc: target, def } = resolveRef(doc, node.$ref);
+            const name = nameFor(target, def);
+            if (!name) {
+                noteUnresolved(`${target}${def ? `.${def}` : ""}`, doc);
+                return "unknown";
+            }
+            return name;
+        }
+        if (node.allOf && node.allOf.length > 0) {
+            const parts = node.allOf.map((n) => parenthesize(tsType(n, doc, indent)));
+            if (node.properties && Object.keys(node.properties).length > 0)
+                parts.push(objectBody(node.properties, doc, indent));
+            const kept = parts.filter((p) => p !== "unknown");
+            return kept.length === 0 ? "unknown" : kept.join(" & ");
+        }
+        const custom = node["x-customType"];
+        if (custom) {
+            const mapped = customType(custom);
+            if (mapped)
+                return mapped;
+        }
+        const types = Array.isArray(node.type) ? node.type : node.type ? [node.type] : [];
+        if (types.length === 0) {
+            if (node.properties)
+                return objectBody(node.properties, doc, indent);
+            return "unknown";
+        }
+        return types.map((t) => jsonType(t, node, doc, indent)).join(" | ");
+    };
+    const jsonType = (t, node, doc, indent) => {
+        switch (t) {
+            case "string":
+                if (node.enum && node.enum.length > 0)
+                    return node.enum.map((v) => JSON.stringify(v)).join(" | ");
+                return node.format === "duration" ? "Duration" : "string";
+            case "integer":
+            case "number":
+                if (node.format === "duration")
+                    return "Duration";
+                return "number";
+            case "boolean":
+                return "boolean";
+            case "null":
+                return "null";
+            case "array":
+                return `Array<${tsType(node.items, doc, indent)}>`;
+            case "object": {
+                const hasProps = node.properties && Object.keys(node.properties).length > 0;
+                if (hasProps)
+                    return objectBody(node.properties, doc, indent);
+                const ap = node.additionalProperties;
+                if (ap && typeof ap === "object")
+                    return `Record<string, ${tsType(ap, doc, indent)}>`;
+                return "Record<string, unknown>";
+            }
+            default:
+                return "unknown";
+        }
+    };
+    const roots_ = new Map();
+    for (const root of roots) {
+        const name = nameFor(root, "");
+        if (name)
+            roots_.set(root, name);
+    }
+    while (pending.length > 0) {
+        const { doc, def, name } = pending.shift();
+        const docNode = docs[doc];
+        const node = def === "" ? docNode : docNode.$defs[def];
+        const text = TEXT_DEFINITIONS[`${doc}#${def}`];
+        const body = typeof text === "string" ? text : text ? text(tsType(node, doc, "")) : tsType(node, doc, "");
+        decls.set(name, `${jsdoc(node.description, "")}export type ${name} = ${body};\n`);
+    }
+    const declarations = [...decls.keys()]
+        .sort()
+        .map((k) => decls.get(k))
+        .join("\n");
+    return { declarations, roots: roots_, unresolved };
+}
+/**
+ * The property tree of a root document, for completion and hover: each
+ * property's description and a short type label, nested objects expanded to
+ * `depth` levels, embedded structs (`allOf`) flattened in.
+ */
+export function propertyDocs(docs, root, depth = 4) {
+    const visit = (node, doc, level, stack) => {
+        const out = {};
+        const target = deref(node, doc);
+        if (!target)
+            return out;
+        const { node: n, doc: d, key } = target;
+        if (key && stack.includes(key))
+            return out;
+        const nextStack = key ? [...stack, key] : stack;
+        // A list of objects: complete the properties of one item.
+        if (n.items && (n.type === "array" || (Array.isArray(n.type) && n.type.includes("array"))))
+            return visit(n.items, d, level, nextStack);
+        // A map of objects: complete the properties of one value.
+        if (!n.properties && !n.allOf && n.additionalProperties && typeof n.additionalProperties === "object") {
+            return visit(n.additionalProperties, d, level, nextStack);
+        }
+        for (const part of n.allOf ?? [])
+            Object.assign(out, visit(part, d, level, nextStack));
+        for (const [name, p] of Object.entries(n.properties ?? {})) {
+            const entry = { type: label(p, d) };
+            const description = p.description ?? deref(p, d)?.node.description;
+            if (description)
+                entry.description = description;
+            if (isDeprecated(p.description))
+                entry.deprecated = true;
+            if (level < depth) {
+                const child = visit(p, d, level + 1, nextStack);
+                if (Object.keys(child).length > 0)
+                    entry.properties = child;
+            }
+            out[name] = entry;
+        }
+        return out;
+    };
+    const deref = (node, doc) => {
+        let n = node;
+        let d = doc;
+        // Only a `$ref`ed definition can recur; an inline object gets no key.
+        let key = "";
+        for (let hops = 0; n?.$ref && hops < 16; hops++) {
+            const r = resolveRef(d, n.$ref);
+            const target = docs[r.doc];
+            n = r.def === "" ? rootOf(target) : (target?.$defs?.[r.def] ?? (r.def === "config" ? target : undefined));
+            d = r.doc;
+            key = `${r.doc}#${r.def}`;
+        }
+        return n ? { node: n, doc: d, key } : undefined;
+    };
+    const label = (node, doc) => {
+        const resolved = deref(node, doc);
+        const text = resolved && TEXT_DEFINITIONS[resolved.key];
+        if (typeof text === "string")
+            return text;
+        if (text)
+            return "map | list";
+        const target = resolved?.node ?? node;
+        const custom = target["x-customType"];
+        if (custom === "time.Duration" || target.format === "duration")
+            return "duration";
+        if (custom && customType(custom) === "number")
+            return "number";
+        if (custom === "go.opentelemetry.io/collector/component.ID")
+            return "component id";
+        const t = Array.isArray(target.type) ? target.type[0] : target.type;
+        if (t === "integer")
+            return "number";
+        if (t === "array")
+            return `${target.items ? label(target.items, doc) : "unknown"}[]`;
+        if (t === "string" && target.enum)
+            return target.enum.map((v) => JSON.stringify(v)).join(" | ");
+        if (!t && (target.allOf || target.properties))
+            return "object";
+        return t ?? "unknown";
+    };
+    return visit(rootOf(docs[root]), root, 1, []);
+}

package/dist/spec/pin.d.ts

@@ -0,0 +1,82 @@
+/**
+ * What the otel lexicon's generated config types are pinned to (#3361).
+ *
+ * ## The version pins
+ *
+ * Upstream publishes a `config.schema.yaml` next to each component's
+ * `config.go`, produced by `schemagen` from the Go structs. A collector
+ * *distribution* decides which components a given `otelcol` binary carries, so
+ * the types are scoped by a distribution's builder manifest
+ * (`distributions/<name>/manifest.yaml` in opentelemetry-collector-releases) at
+ * a release tag:
+ *
+ * - `otelcol-contrib`, the distribution the built-ins are generated against and
+ *   the one `COLLECTOR_IMAGE` runs;
+ * - `otelcol-k8s`, a second pin, so the coverage report can say which built-ins
+ *   the Kubernetes distribution leaves out.
+ *
+ * Each manifest names the component modules and their versions; the schemas
+ * are read from opentelemetry-collector and opentelemetry-collector-contrib at
+ * those versions. Every one of these is a git tag, so the content behind a pin
+ * never moves.
+ *
+ * ## The content pin
+ *
+ * The resolved set (both manifests' component index plus every schema document
+ * the built-ins reach through `$ref`) is committed as
+ * `otel-schemas.snapshot.json`, and generation reads only that file, offline.
+ * The digest below is over that resolved set, so a hand edit to the snapshot,
+ * or a refresh nobody accepted, refuses to generate. Moving a version is: bump
+ * the constant, run `just snapshot`, read the diff, and paste the printed pin
+ * here, in the same commit.
+ */
+/** The opentelemetry-collector-releases tag whose `otelcol-contrib` manifest scopes the built-ins. */
+export declare const OTELCOL_CONTRIB_VERSION = "v0.162.0";
+/** The opentelemetry-collector-releases tag whose `otelcol-k8s` manifest the coverage report also reads. */
+export declare const OTELCOL_K8S_VERSION = "v0.162.0";
+/** Env var that accepts a snapshot whose digest does not match the pin, printing the new pin. */
+export declare const ACCEPT_ENV = "CHANT_ACCEPT_OTEL_SPEC";
+export interface OtelSpecPin {
+    /** `sha256:…` over the resolved set, see {@link specDigest}. */
+    readonly digest: string;
+    /** How many schema documents the resolved set holds. */
+    readonly documents: number;
+    /** ISO date the pin was accepted, so a diff reads as a decision. */
+    readonly accepted: string;
+}
+/** The accepted resolved set. Paste the block `just snapshot` prints here. */
+export declare const OTEL_SPEC_PIN: OtelSpecPin;
+/**
+ * Refuse a snapshot taken at other versions than the constants above: a
+ * version bump without `just snapshot` would otherwise generate the old
+ * release's types under the new pin.
+ */
+export declare function assertSnapshotVersions(versions: {
+    "otelcol-contrib": string;
+    "otelcol-k8s": string;
+}): void;
+/** Stable JSON: object keys sorted at every level, so the digest ignores key order. */
+export declare function canonicalJson(value: unknown): string;
+/** The parts of a snapshot the digest covers. */
+export interface DigestInput {
+    readonly versions: unknown;
+    readonly distributions: unknown;
+    readonly schemas: Readonly<Record<string, unknown>>;
+}
+/**
+ * Digest the resolved set: the versions, the distribution index, and each
+ * schema document by key, in key order.
+ */
+export declare function specDigest(input: DigestInput): string;
+/** The pin block to paste into this file for a resolved set. */
+export declare function pinBlock(digest: string, documents: number, accepted?: string): string;
+/**
+ * Refuse a snapshot whose digest does not match the pin. Under
+ * {@link ACCEPT_ENV} it warns with the block to paste instead.
+ */
+export declare function assertPinnedSnapshot(input: DigestInput, options?: {
+    pin?: OtelSpecPin;
+    env?: NodeJS.ProcessEnv;
+    warn?: (message: string) => void;
+}): void;
+//# sourceMappingURL=pin.d.ts.map

package/dist/spec/pin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pin.d.ts","sourceRoot":"","sources":["../../src/spec/pin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,sGAAsG;AACtG,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAElD,4GAA4G;AAC5G,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAE9C,iGAAiG;AACjG,eAAO,MAAM,UAAU,2BAA2B,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,8EAA8E;AAC9E,eAAO,MAAM,aAAa,EAAE,WAI3B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAW3G;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWpD;AAED,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACrD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CASrD;AAED,gEAAgE;AAChE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAwC,GAAG,MAAM,CAQpH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,WAAW,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC7F,IAAI,CAsBN"}

package/dist/spec/pin.js

@@ -0,0 +1,126 @@
+/**
+ * What the otel lexicon's generated config types are pinned to (#3361).
+ *
+ * ## The version pins
+ *
+ * Upstream publishes a `config.schema.yaml` next to each component's
+ * `config.go`, produced by `schemagen` from the Go structs. A collector
+ * *distribution* decides which components a given `otelcol` binary carries, so
+ * the types are scoped by a distribution's builder manifest
+ * (`distributions/<name>/manifest.yaml` in opentelemetry-collector-releases) at
+ * a release tag:
+ *
+ * - `otelcol-contrib`, the distribution the built-ins are generated against and
+ *   the one `COLLECTOR_IMAGE` runs;
+ * - `otelcol-k8s`, a second pin, so the coverage report can say which built-ins
+ *   the Kubernetes distribution leaves out.
+ *
+ * Each manifest names the component modules and their versions; the schemas
+ * are read from opentelemetry-collector and opentelemetry-collector-contrib at
+ * those versions. Every one of these is a git tag, so the content behind a pin
+ * never moves.
+ *
+ * ## The content pin
+ *
+ * The resolved set (both manifests' component index plus every schema document
+ * the built-ins reach through `$ref`) is committed as
+ * `otel-schemas.snapshot.json`, and generation reads only that file, offline.
+ * The digest below is over that resolved set, so a hand edit to the snapshot,
+ * or a refresh nobody accepted, refuses to generate. Moving a version is: bump
+ * the constant, run `just snapshot`, read the diff, and paste the printed pin
+ * here, in the same commit.
+ */
+import { createHash } from "crypto";
+/** The opentelemetry-collector-releases tag whose `otelcol-contrib` manifest scopes the built-ins. */
+export const OTELCOL_CONTRIB_VERSION = "v0.162.0";
+/** The opentelemetry-collector-releases tag whose `otelcol-k8s` manifest the coverage report also reads. */
+export const OTELCOL_K8S_VERSION = "v0.162.0";
+/** Env var that accepts a snapshot whose digest does not match the pin, printing the new pin. */
+export const ACCEPT_ENV = "CHANT_ACCEPT_OTEL_SPEC";
+/** The accepted resolved set. Paste the block `just snapshot` prints here. */
+export const OTEL_SPEC_PIN = {
+    digest: "sha256:90ac78ed3f40aac1ef29b4df9a11574a829f08de2758c379817a92e557bb9d05",
+    documents: 133,
+    accepted: "2026-10-24",
+};
+/**
+ * Refuse a snapshot taken at other versions than the constants above: a
+ * version bump without `just snapshot` would otherwise generate the old
+ * release's types under the new pin.
+ */
+export function assertSnapshotVersions(versions) {
+    const wrong = [
+        versions["otelcol-contrib"] !== OTELCOL_CONTRIB_VERSION ? `otelcol-contrib ${versions["otelcol-contrib"]} (pin ${OTELCOL_CONTRIB_VERSION})` : "",
+        versions["otelcol-k8s"] !== OTELCOL_K8S_VERSION ? `otelcol-k8s ${versions["otelcol-k8s"]} (pin ${OTELCOL_K8S_VERSION})` : "",
+    ].filter(Boolean);
+    if (wrong.length > 0) {
+        throw new Error(`The otel schema snapshot was taken at ${wrong.join(" and ")}. Run \`just snapshot\` in lexicons/otel, ` +
+            "paste the printed OTEL_SPEC_PIN into src/spec/pin.ts, and generate again.");
+    }
+}
+/** Stable JSON: object keys sorted at every level, so the digest ignores key order. */
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        return `{${Object.keys(obj)
+            .sort()
+            .filter((k) => obj[k] !== undefined)
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Digest the resolved set: the versions, the distribution index, and each
+ * schema document by key, in key order.
+ */
+export function specDigest(input) {
+    const hash = createHash("sha256");
+    hash.update(canonicalJson(input.versions));
+    hash.update(canonicalJson(input.distributions));
+    for (const key of Object.keys(input.schemas).sort()) {
+        hash.update(key);
+        hash.update(createHash("sha256").update(canonicalJson(input.schemas[key])).digest());
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+/** The pin block to paste into this file for a resolved set. */
+export function pinBlock(digest, documents, accepted = new Date().toISOString().slice(0, 10)) {
+    return [
+        "export const OTEL_SPEC_PIN: OtelSpecPin = {",
+        `  digest: "${digest}",`,
+        `  documents: ${documents},`,
+        `  accepted: "${accepted}",`,
+        "};",
+    ].join("\n");
+}
+/**
+ * Refuse a snapshot whose digest does not match the pin. Under
+ * {@link ACCEPT_ENV} it warns with the block to paste instead.
+ */
+export function assertPinnedSnapshot(input, options = {}) {
+    const pin = options.pin ?? OTEL_SPEC_PIN;
+    const digest = specDigest(input);
+    if (digest === pin.digest)
+        return;
+    const documents = Object.keys(input.schemas).length;
+    const message = [
+        "The otel schema snapshot (src/spec/otel-schemas.snapshot.json) does not match OTEL_SPEC_PIN.",
+        "",
+        `  pinned    ${pin.digest}  (${pin.documents} documents, accepted ${pin.accepted})`,
+        `  snapshot  ${digest}  (${documents} documents)`,
+        "",
+        "If the snapshot was refreshed on purpose (`just snapshot`), read its diff and",
+        "paste this into lexicons/otel/src/spec/pin.ts in the same commit:",
+        "",
+        pinBlock(digest, documents),
+    ].join("\n");
+    const env = options.env ?? process.env;
+    if (env[ACCEPT_ENV]) {
+        (options.warn ?? ((m) => console.error(m)))(message);
+        return;
+    }
+    throw new Error(`${message}\n\nOr re-run with ${ACCEPT_ENV}=1 to generate from it this once.`);
+}

package/dist/spec/snapshot-cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env tsx
+/**
+ * Refresh the committed schema snapshot (`just snapshot`, #3361).
+ *
+ * Reads both distribution manifests at the versions in `pin.ts`, indexes every
+ * component they list, and keeps the schema documents the built-ins reach. The
+ * output is re-indented so a version move reads as a diff. Run it on a
+ * networked machine after bumping `OTELCOL_CONTRIB_VERSION` or
+ * `OTELCOL_K8S_VERSION`, then paste the printed pin into `pin.ts` and run
+ * `just generate`, all in one commit.
+ */
+export {};
+//# sourceMappingURL=snapshot-cli.d.ts.map

package/dist/spec/snapshot-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-cli.d.ts","sourceRoot":"","sources":["../../src/spec/snapshot-cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG"}

package/dist/spec/snapshot-cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env tsx
+/**
+ * Refresh the committed schema snapshot (`just snapshot`, #3361).
+ *
+ * Reads both distribution manifests at the versions in `pin.ts`, indexes every
+ * component they list, and keeps the schema documents the built-ins reach. The
+ * output is re-indented so a version move reads as a diff. Run it on a
+ * networked machine after bumping `OTELCOL_CONTRIB_VERSION` or
+ * `OTELCOL_K8S_VERSION`, then paste the printed pin into `pin.ts` and run
+ * `just generate`, all in one commit.
+ */
+import { writeFileSync } from "fs";
+import { fetchUpstreamSpec } from "./fetch.js";
+import { OTELCOL_CONTRIB_VERSION, OTELCOL_K8S_VERSION, pinBlock, specDigest } from "./pin.js";
+import { BUILTIN_SPECS } from "./builtins.js";
+import { SNAPSHOT_FILE } from "./snapshot.js";
+const snapshot = await fetchUpstreamSpec({
+    contribVersion: OTELCOL_CONTRIB_VERSION,
+    k8sVersion: OTELCOL_K8S_VERSION,
+    keep: BUILTIN_SPECS,
+    force: process.argv.includes("--force"),
+    log: (m) => console.error(m),
+});
+const json = `${JSON.stringify(snapshot, null, 1)}\n`;
+writeFileSync(SNAPSHOT_FILE, json);
+const documents = Object.keys(snapshot.schemas).length;
+console.error(`Wrote ${documents} schema documents (${(json.length / 1024).toFixed(0)} KB) to ${SNAPSHOT_FILE}`);
+const unresolved = Object.keys(snapshot.unresolved);
+if (unresolved.length > 0)
+    console.error(`Unresolved $ref documents (typed as unknown): ${unresolved.join(", ")}`);
+console.error(`\nPaste into src/spec/pin.ts:\n\n${pinBlock(specDigest(snapshot), documents)}`);

package/dist/spec/snapshot.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The committed schema snapshot (#3361): what generation, the coverage report
+ * and the LSP read. Never fetched here; `just snapshot` refreshes it.
+ */
+import type { OtelSpecSnapshot } from "./fetch.js";
+export declare const SNAPSHOT_FILE: string;
+/** The snapshot as committed, parsed once per process. */
+export declare function loadSnapshot(): OtelSpecSnapshot;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/spec/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/spec/snapshot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,aAAa,QAAuE,CAAC;AAIlG,0DAA0D;AAC1D,wBAAgB,YAAY,IAAI,gBAAgB,CAG/C"}

package/dist/spec/snapshot.js

@@ -0,0 +1,14 @@
+/**
+ * The committed schema snapshot (#3361): what generation, the coverage report
+ * and the LSP read. Never fetched here; `just snapshot` refreshes it.
+ */
+import { readFileSync } from "fs";
+import { join } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+export const SNAPSHOT_FILE = join(moduleSourceDir(import.meta.url), "otel-schemas.snapshot.json");
+let cached;
+/** The snapshot as committed, parsed once per process. */
+export function loadSnapshot() {
+    cached ?? (cached = JSON.parse(readFileSync(SNAPSHOT_FILE, "utf-8")));
+    return cached;
+}

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
-// The otel lexicon's entity classes and config types are hand-written in
-// src/ and compiled to dist/index.d.ts; this entry re-exports them.
+// The otel lexicon's entity classes and config types are compiled to
+// dist/index.d.ts (config types generated from upstream config.schema.yaml);
+// this entry re-exports them.
 export * from "../index.js";

package/dist/validate-config.d.ts

@@ -10,7 +10,7 @@
 import type { Declarable } from "@intentius/chant/declarable";
 import { type CollectorConfig } from "./model.js";
 import "./components/connectors.js";
-export type CollectorIssueCode = "OTEL101" | "OTEL102" | "OTEL103" | "OTEL104" | "OTEL105" | "OTEL106" | "OTEL107" | "OTEL108" | "OTEL109" | "OTEL112" | "OTEL113" | "OTEL114" | "OTEL115" | "OTEL116" | "OTEL117" | "OTEL118" | "OTEL119" | "OTEL120" | "OTEL121" | "OTEL122" | "OTEL123" | "OTEL124" | "OTEL125" | "OTEL126" | "OTEL127";
+export type CollectorIssueCode = "OTEL101" | "OTEL102" | "OTEL103" | "OTEL104" | "OTEL105" | "OTEL106" | "OTEL107" | "OTEL108" | "OTEL109" | "OTEL112" | "OTEL113" | "OTEL114" | "OTEL115" | "OTEL116" | "OTEL117" | "OTEL118" | "OTEL119" | "OTEL120" | "OTEL121" | "OTEL122" | "OTEL123" | "OTEL124" | "OTEL125" | "OTEL126" | "OTEL127" | "OTEL128";
 export interface CollectorIssue {
     code: CollectorIssueCode;
     severity: "error" | "warning";

package/dist/validate-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-config.d.ts","sourceRoot":"","sources":["../src/validate-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D,OAAO,EAAoF,KAAK,eAAe,EAA4B,MAAM,SAAS,CAAC;AAO3J,OAAO,yBAAyB,CAAC;AAEjC,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,EAAE,CAmKjF;AA6OD,kDAAkD;AAClD,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AA4ED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AAYD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,CAExG;AAuBD,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,CAWrH;AAqHD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,cAAc,EAAE,CAyDpH"}
+{"version":3,"file":"validate-config.d.ts","sourceRoot":"","sources":["../src/validate-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D,OAAO,EAAoF,KAAK,eAAe,EAA4B,MAAM,SAAS,CAAC;AAO3J,OAAO,yBAAyB,CAAC;AAEjC,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,EAAE,CAmKjF;AA6OD,kDAAkD;AAClD,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AA4ED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AAYD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,CAExG;AAuBD,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,CAWrH;AAqHD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,cAAc,EAAE,CAyDpH"}

package/dist/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAMvF,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEvF,0DAA0D;AAC1D,eAAO,MAAM,cAAc,UAsC1B,CAAC;AAEF,wBAAsB,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,CAmDxD"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAMvF,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEvF,0DAA0D;AAC1D,eAAO,MAAM,cAAc,UAuC1B,CAAC;AAEF,wBAAsB,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,CAmDxD"}