@intentius/chant-lexicon-otel 0.124.31 → 0.124.32

package/dist/import/generator.js

@@ -0,0 +1,459 @@
+/**
+ * `TemplateIR` -> TypeScript, for `chant import`.
+ *
+ * Writes the collector the way the lexicon's examples are written: a module
+ * per section with one constant per component, typed by its built-in class
+ * (`const otlpTempo = new OtlpExporter({ name: "tempo", ... })`), nested
+ * settings lifted into consts typed by the component's config type (COR001),
+ * at most eight declarables per module (COR009), and an `export { ... }` list
+ * at the end of each. `pipelines.ts` declares a `Pipeline` per pipeline that
+ * references those constants, and `service.ts` a `Service` when
+ * `service.extensions` or `service.telemetry` needs one. A connector is one
+ * constant, listed in the exporters of the pipeline that feeds it and the
+ * receivers of the pipeline it feeds.
+ *
+ * A component type chant does not ship gets a `defineComponent` in
+ * `custom-components.ts`, with its config carried as data and a comment
+ * saying so. Its pin is the one the config's `# chant:` header named, or
+ * `COLLECTOR_PIN`.
+ */
+import * as components from "../components/index.js";
+import { COLLECTOR_PIN } from "../define.js";
+import { COMPONENT_KINDS, SECTION_OF, canonicalComponentType, SIGNALS, parseComponentId, pipelineSignal, } from "../model.js";
+import { COLLECTOR_RESOURCE_TYPE, } from "./parser.js";
+const PACKAGE = "@intentius/chant-lexicon-otel";
+const KIND_SEGMENT = {
+    receiver: "Receiver",
+    processor: "Processor",
+    exporter: "Exporter",
+    connector: "Connector",
+    extension: "Extension",
+};
+/** `kind:type` -> the exported class name of every built-in. */
+const BUILTIN_CLASSES = (() => {
+    const map = new Map();
+    for (const [exportName, value] of Object.entries(components)) {
+        const def = value?.definition;
+        if (typeof value === "function" && def?.builtin)
+            map.set(`${def.kind}:${def.type}`, exportName);
+    }
+    return map;
+})();
+/**
+ * The class name of the built-in for `kind` + `type`, if chant ships one.
+ * A renamed built-in's new name (`span_metrics`) gives the class for the old
+ * one, which emits the old name.
+ */
+export function builtinClassName(kind, type) {
+    return BUILTIN_CLASSES.get(`${kind}:${type}`) ?? BUILTIN_CLASSES.get(`${kind}:${canonicalComponentType(kind, type)}`);
+}
+const RESERVED = new Set(("break case catch class const continue debugger default delete do else enum export extends false finally for " +
+    "function if import in instanceof new null return super switch this throw true try typeof var void while with " +
+    "yield let static implements interface package private protected public await arguments eval undefined").split(" "));
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function words(text) {
+    return text.split(/[^A-Za-z0-9]+/).filter((w) => w !== "");
+}
+function camel(text) {
+    const parts = words(text);
+    if (parts.length === 0)
+        return "";
+    return parts
+        .map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1)))
+        .join("");
+}
+function pascal(text) {
+    return words(text)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+}
+// ── TypeScript literals ──────────────────────────────────────────────
+const MAX_LINE = 100;
+function propertyKey(k) {
+    return IDENT.test(k) ? k : JSON.stringify(k);
+}
+/** A string literal: double-quoted, or single-quoted when that saves escaping `"` (OTTL reads better). */
+function stringLiteral(s) {
+    const double = JSON.stringify(s);
+    if (!s.includes('"') || s.includes("'"))
+        return double;
+    return `'${double.slice(1, -1).replace(/\\"/g, '"')}'`;
+}
+function scalarLiteral(v) {
+    if (v === null)
+        return "null";
+    if (typeof v === "string")
+        return stringLiteral(v);
+    if (typeof v === "number") {
+        if (Number.isNaN(v))
+            return "NaN";
+        if (v === Infinity)
+            return "Infinity";
+        if (v === -Infinity)
+            return "-Infinity";
+        return String(v);
+    }
+    if (typeof v === "boolean")
+        return v ? "true" : "false";
+    return JSON.stringify(String(v));
+}
+/** One-line rendering of a value. */
+function inline(v) {
+    if (Array.isArray(v))
+        return `[${v.map(inline).join(", ")}]`;
+    if (typeof v === "object" && v !== null) {
+        const items = Object.entries(v)
+            .filter(([, x]) => x !== undefined)
+            .map(([k, x]) => `${propertyKey(k)}: ${inline(x)}`);
+        return items.length === 0 ? "{}" : `{ ${items.join(", ")} }`;
+    }
+    return scalarLiteral(v);
+}
+/** A value as a TypeScript expression, starting at column `col`, indented by `indent` spaces. */
+export function tsLiteral(v, indent, col = indent) {
+    const one = inline(v);
+    if (col + one.length + 2 <= MAX_LINE)
+        return one;
+    const pad = " ".repeat(indent + 2);
+    const close = " ".repeat(indent);
+    if (Array.isArray(v)) {
+        const items = v.map((x) => `${pad}${tsLiteral(x, indent + 2)},`);
+        return `[\n${items.join("\n")}\n${close}]`;
+    }
+    if (typeof v === "object" && v !== null) {
+        const lines = [];
+        for (const [k, x] of Object.entries(v)) {
+            if (x === undefined)
+                continue;
+            const key = `${pad}${propertyKey(k)}: `;
+            lines.push(`${key}${tsLiteral(x, indent + 2, key.length)},`);
+        }
+        return `{\n${lines.join("\n")}\n${close}}`;
+    }
+    return scalarLiteral(v);
+}
+/** An object literal whose entries are already-rendered expressions, starting at column `col`. */
+function objectOf(entries, indent, col) {
+    if (entries.length === 0)
+        return "{}";
+    const prop = ([k, v]) => (k === v && IDENT.test(k) ? k : `${propertyKey(k)}: ${v}`);
+    const one = `{ ${entries.map(prop).join(", ")} }`;
+    if (!one.includes("\n") && col + one.length + 2 <= MAX_LINE)
+        return one;
+    const pad = " ".repeat(indent + 2);
+    return `{\n${entries.map((e) => `${pad}${prop(e)},`).join("\n")}\n${" ".repeat(indent)}}`;
+}
+function assignNames(comps, pipes, taken) {
+    const base = (s, fallback) => {
+        const c = camel(s);
+        return c === "" || /^[0-9]/.test(c) ? camel(`${fallback} ${s}`) : c;
+    };
+    const candidates = new Map();
+    const compBase = comps.map((c) => base(c.id, c.kind));
+    const pipeBase = pipes.map((p) => base(p.id, "pipeline"));
+    for (const b of [...compBase, ...pipeBase])
+        candidates.set(b, (candidates.get(b) ?? 0) + 1);
+    const unique = (name) => {
+        let out = name;
+        for (let n = 2; taken.has(out) || RESERVED.has(out); n++)
+            out = `${name}${n}`;
+        taken.add(out);
+        return out;
+    };
+    const clash = (b) => (candidates.get(b) ?? 0) > 1 || RESERVED.has(b) || taken.has(b);
+    comps.forEach((c, i) => {
+        const b = compBase[i];
+        c.varName = unique(clash(b) ? `${b}${KIND_SEGMENT[c.kind]}` : b);
+    });
+    pipes.forEach((p, i) => {
+        const b = pipeBase[i];
+        p.varName = unique(clash(b) ? `${b}Pipeline` : b);
+    });
+}
+// ── files ────────────────────────────────────────────────────────────
+/** COR009's default: at most this many declarables per file. */
+const DECLARABLES_PER_FILE = 8;
+/** One generated module: what it imports, declares and exports. */
+class Module {
+    constructor(path, summary) {
+        this.path = path;
+        this.summary = summary;
+        this.values = new Set();
+        this.types = new Set();
+        this.local = new Map();
+        this.body = [];
+        this.exports = [];
+    }
+    use(name, from) {
+        if (!from)
+            this.values.add(name);
+        else if (from !== this) {
+            const spec = `./${from.path.replace(/\.ts$/, "")}`;
+            const set = this.local.get(spec) ?? new Set();
+            set.add(name);
+            this.local.set(spec, set);
+        }
+    }
+    block(lines) {
+        if (this.body.length > 0)
+            this.body.push("");
+        this.body.push(...lines);
+    }
+    render() {
+        const byName = (a, b) => a.localeCompare(b, "en", { sensitivity: "base" });
+        const names = [...[...this.values].map((v) => v), ...[...this.types].map((t) => `type ${t}`)].sort((a, b) => byName(a.replace(/^type /, ""), b.replace(/^type /, "")));
+        const lines = [`/** ${this.summary} */`];
+        if (names.length > 0) {
+            const one = `import { ${names.join(", ")} } from "${PACKAGE}";`;
+            lines.push(one.length <= MAX_LINE ? one : `import {\n${names.map((n) => `  ${n},`).join("\n")}\n} from "${PACKAGE}";`);
+        }
+        for (const [spec, set] of [...this.local].sort(([a], [b]) => byName(a, b))) {
+            lines.push(`import { ${[...set].sort(byName).join(", ")} } from "${spec}";`);
+        }
+        lines.push("", ...this.body);
+        if (this.exports.length > 0) {
+            const one = `export { ${this.exports.join(", ")} };`;
+            lines.push("", one.length <= MAX_LINE ? one : `export {\n${this.exports.map((e) => `  ${e},`).join("\n")}\n};`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+}
+/** Split `items` into files of at most `DECLARABLES_PER_FILE`, named `base.ts` or `base-1.ts`, `base-2.ts`, … */
+function chunk(items, base, summary) {
+    if (items.length === 0)
+        return [];
+    if (items.length <= DECLARABLES_PER_FILE)
+        return [[new Module(`${base}.ts`, summary), items]];
+    const out = [];
+    for (let i = 0; i < items.length; i += DECLARABLES_PER_FILE) {
+        out.push([new Module(`${base}-${out.length + 1}.ts`, summary), items.slice(i, i + DECLARABLES_PER_FILE)]);
+    }
+    return out;
+}
+// ── generation ───────────────────────────────────────────────────────
+function isCollectorResource(r) {
+    return r.type === COLLECTOR_RESOURCE_TYPE;
+}
+function samePin(a, b) {
+    return a.source === b.source && a.version === b.version && (a.digest ?? "") === (b.digest ?? "");
+}
+/** True for a value COR001 wants in a named const rather than inline in a constructor. */
+function needsHoist(v) {
+    if (Array.isArray(v))
+        return v.some((x) => typeof x === "object" && x !== null);
+    return typeof v === "object" && v !== null;
+}
+const SECTION_SUMMARY = {
+    receiver: "Receivers",
+    processor: "Processors",
+    exporter: "Exporters",
+    connector: "Connectors: each one is an exporter in the pipeline that feeds it and a receiver in the pipeline it feeds",
+    extension: "Extensions",
+};
+/**
+ * Generate the TypeScript declaring one collector config: one module per
+ * section (split at eight declarables, as COR009 asks), `pipelines.ts`,
+ * `service.ts` when the config needs a Service, and `custom-components.ts`
+ * for component types chant does not ship.
+ */
+export function generateCollectorFiles(config, meta = {}) {
+    const pins = meta.pins ?? [];
+    const comps = [];
+    const customClasses = new Map();
+    const taken = new Set(["Pipeline", "Service", "defineComponent", "COLLECTOR_PIN", "ServiceTelemetry", "telemetry"]);
+    for (const cls of BUILTIN_CLASSES.values())
+        taken.add(cls).add(`${cls}Config`);
+    for (const kind of COMPONENT_KINDS) {
+        const section = config[SECTION_OF[kind]];
+        for (const [id, raw] of Object.entries(section ?? {})) {
+            const parsed = parseComponentId(id);
+            const slash = id.indexOf("/");
+            const type = parsed?.type ?? (slash === -1 ? id : id.slice(0, slash));
+            const name = parsed ? parsed.name : slash === -1 ? undefined : id.slice(slash + 1);
+            const { name: _dropped, ...cfg } = (raw ?? {});
+            const builtin = builtinClassName(kind, type);
+            let className = builtin;
+            if (!className) {
+                const key = `${kind}:${type}`;
+                let custom = customClasses.get(key);
+                if (!custom) {
+                    const base = `${/^[0-9]/.test(type) ? "Custom" : ""}${pascal(type) || "Custom"}${KIND_SEGMENT[kind]}`;
+                    let cn = base;
+                    for (let n = 2; taken.has(cn); n++)
+                        cn = `${base}${n}`;
+                    taken.add(cn);
+                    const headerPin = pins.find((p) => p.kind === kind && parseComponentId(p.id)?.type === type)?.pin;
+                    custom = { className: cn, kind, type, pin: headerPin ?? COLLECTOR_PIN };
+                    customClasses.set(key, custom);
+                }
+                className = custom.className;
+            }
+            comps.push({ kind, id, type, name, config: cfg, className, builtin: !!builtin, varName: "" });
+        }
+    }
+    const pipes = Object.entries(config.service?.pipelines ?? {}).map(([id, lists]) => {
+        const slash = id.indexOf("/");
+        return {
+            id,
+            signal: pipelineSignal(id),
+            name: slash === -1 ? undefined : id.slice(slash + 1),
+            lists: lists ?? {},
+            varName: "",
+        };
+    });
+    assignNames(comps, pipes, taken);
+    const unique = (name) => {
+        let out = name;
+        for (let n = 2; taken.has(out) || RESERVED.has(out); n++)
+            out = `${name}${n}`;
+        taken.add(out);
+        return out;
+    };
+    const modules = [];
+    const home = new Map(); // variable or class name -> module declaring it
+    // Custom component types, exported for every module that declares an instance.
+    if (customClasses.size > 0) {
+        const mod = new Module("custom-components.ts", "Component types chant does not ship, declared with defineComponent");
+        modules.push(mod);
+        mod.use("defineComponent");
+        for (const custom of customClasses.values()) {
+            const pinIsCollector = samePin(custom.pin, COLLECTOR_PIN);
+            if (pinIsCollector)
+                mod.use("COLLECTOR_PIN");
+            mod.block([
+                `// ${custom.kind} "${custom.type}" is not a component chant ships, so its config is carried as data`,
+                "// and is not type-checked. Replace Record<string, unknown> with its config type to check it.",
+                pinIsCollector
+                    ? "// The imported config named no schema pin for it, so it is pinned to COLLECTOR_PIN."
+                    : "// The pin is the one the imported config's `# chant:` header named.",
+                `const ${custom.className} = defineComponent<Record<string, unknown>>()({`,
+                `  kind: ${JSON.stringify(custom.kind)},`,
+                `  type: ${JSON.stringify(custom.type)},`,
+                `  pin: ${pinIsCollector ? "COLLECTOR_PIN" : tsLiteral({ ...custom.pin }, 2, 7)},`,
+                "});",
+            ]);
+            mod.exports.push(custom.className);
+            home.set(custom.className, mod);
+        }
+    }
+    // Components, one module per section.
+    for (const kind of COMPONENT_KINDS) {
+        const ofKind = comps.filter((c) => c.kind === kind);
+        for (const [mod, items] of chunk(ofKind, SECTION_OF[kind], SECTION_SUMMARY[kind])) {
+            modules.push(mod);
+            for (const c of items) {
+                const lines = [];
+                if (c.builtin)
+                    mod.use(c.className);
+                else
+                    mod.use(c.className, home.get(c.className));
+                const entries = [];
+                if (c.name !== undefined)
+                    entries.push(["name", JSON.stringify(c.name)]);
+                for (const [key, value] of Object.entries(c.config)) {
+                    if (value === undefined)
+                        continue;
+                    if (!needsHoist(value)) {
+                        entries.push([key, tsLiteral(value, 2, 4 + key.length)]);
+                        continue;
+                    }
+                    const constName = unique(`${c.varName}${pascal(key) || "Value"}`);
+                    let annotation = "";
+                    if (c.builtin) {
+                        mod.types.add(`${c.className}Config`);
+                        annotation = `: ${c.className}Config[${JSON.stringify(key)}]`;
+                    }
+                    const head = `const ${constName}${annotation} = `;
+                    lines.push(`${head}${tsLiteral(value, 0, head.length)};`);
+                    entries.push([key, constName]);
+                }
+                const head = `const ${c.varName} = new ${c.className}(`;
+                lines.push(`${head}${entries.length === 0 ? "" : objectOf(entries, 0, head.length)});`);
+                mod.block(lines);
+                mod.exports.push(c.varName);
+                home.set(c.varName, mod);
+            }
+        }
+    }
+    const byKindId = new Map();
+    for (const c of comps)
+        byKindId.set(`${c.kind}:${c.id}`, c);
+    const ref = (mod, id, kinds) => {
+        for (const k of kinds) {
+            const c = byKindId.get(`${k}:${id}`);
+            if (c) {
+                mod.use(c.varName, home.get(c.varName));
+                return c.varName;
+            }
+        }
+        return JSON.stringify(id);
+    };
+    // Pipelines.
+    for (const [mod, items] of chunk(pipes, "pipelines", "Pipelines")) {
+        modules.push(mod);
+        mod.use("Pipeline");
+        for (const p of items) {
+            const entries = [["signal", JSON.stringify(p.signal)]];
+            if (p.name !== undefined)
+                entries.push(["name", JSON.stringify(p.name)]);
+            const list = (ids, kinds) => `[${(ids ?? []).map((id) => ref(mod, id, kinds)).join(", ")}]`;
+            entries.push(["receivers", list(p.lists.receivers, ["receiver", "connector"])]);
+            if (p.lists.processors && p.lists.processors.length > 0) {
+                entries.push(["processors", list(p.lists.processors, ["processor"])]);
+            }
+            entries.push(["exporters", list(p.lists.exporters, ["exporter", "connector"])]);
+            const head = `const ${p.varName} = new Pipeline(`;
+            if (SIGNALS.includes(p.signal)) {
+                mod.block([`${head}${objectOf(entries, 0, head.length)});`]);
+            }
+            else {
+                mod.block([
+                    `${head}{`,
+                    `  // @ts-expect-error "${p.signal}" is a collector signal Pipeline does not type`,
+                    ...entries.map(([k, v]) => `  ${k}: ${v},`),
+                    "});",
+                ]);
+            }
+            mod.exports.push(p.varName);
+        }
+    }
+    // Service: only when the config says something the default does not.
+    const declaredExtensions = comps.filter((c) => c.kind === "extension").map((c) => c.id);
+    const enabled = config.service?.extensions;
+    const telemetry = config.service?.telemetry;
+    const extensionsDiffer = enabled === undefined
+        ? declaredExtensions.length > 0
+        : enabled.length !== declaredExtensions.length || enabled.some((id, i) => declaredExtensions[i] !== id);
+    if (extensionsDiffer || telemetry !== undefined) {
+        const mod = new Module("service.ts", "service.extensions and service.telemetry");
+        modules.push(mod);
+        mod.use("Service");
+        const lines = [];
+        const entries = [];
+        if (extensionsDiffer)
+            entries.push(["extensions", `[${(enabled ?? []).map((id) => ref(mod, id, ["extension"])).join(", ")}]`]);
+        if (telemetry !== undefined) {
+            mod.types.add("ServiceTelemetry");
+            const head = "const telemetry: ServiceTelemetry = ";
+            lines.push(`${head}${tsLiteral(telemetry, 0, head.length)};`);
+            entries.push(["telemetry", "telemetry"]);
+        }
+        const serviceName = unique("service");
+        const head = `const ${serviceName} = new Service(`;
+        lines.push(`${head}${objectOf(entries, 0, head.length)});`);
+        mod.block(lines);
+        mod.exports.push(serviceName);
+    }
+    return modules.map((m) => ({ path: m.path, content: m.render() }));
+}
+/** The OpenTelemetry Collector TypeScript generator `chant import` runs. */
+export class OtelCollectorGenerator {
+    generate(ir) {
+        const resource = ir.resources.find(isCollectorResource);
+        const props = resource?.properties;
+        const meta = resource?.metadata;
+        const files = generateCollectorFiles(props?.config ?? {}, meta ?? {});
+        // Core writes the first file of a generate() call as a whole module for some layouts; never hand it nothing.
+        return files.length > 0 ? files : [{ path: "pipelines.ts", content: "// The imported config declares nothing.\n" }];
+    }
+}

package/dist/import/parser.js

@@ -0,0 +1,199 @@
+/**
+ * Collector YAML -> `TemplateIR`, for `chant import`.
+ *
+ * A collector config is one document whose parts name each other: pipelines
+ * list component ids, a connector sits in two pipelines, `service.extensions`
+ * lists extension ids. So the IR carries the whole config as one resource of
+ * type `OTel::Collector`, and the generator lays out the modules itself, with
+ * those names turned into imports of declared entities. (Core splits an IR
+ * with more than three resources into one generate() call per category and
+ * keeps only the first file of each, which would lose the imports between a
+ * pipeline and the components it references.)
+ *
+ * The config is carried as parsed, with nothing dropped from a component's
+ * config. What the lexicon cannot express is named in `warnings`.
+ *
+ * The `# chant:` lines the serializer writes above a config are read back:
+ * a custom component's schema pin becomes the pin of the `defineComponent`
+ * the generator writes for it. A config without them imports against
+ * `COLLECTOR_PIN`.
+ */
+import * as jsYaml from "js-yaml";
+import { SEMCONV_VOCABULARIES } from "../semconv.js";
+import { COMPONENT_KINDS, SECTION_OF, SIGNALS, canonicalComponentType, parseComponentId, pipelineSignal, } from "../model.js";
+/** The IR resource type for a whole collector config. */
+export const COLLECTOR_RESOURCE_TYPE = "OTel::Collector";
+// YAML 1.2 core types plus `<<` merge keys. The default schema would also
+// turn an unquoted date into a Date, which the collector never does.
+// js-yaml exports its built-in types at runtime; @types/js-yaml does not declare them.
+const MERGE_TYPE = jsYaml.types.merge;
+const COLLECTOR_YAML_SCHEMA = jsYaml.CORE_SCHEMA.extend({ implicit: [MERGE_TYPE] });
+const SECTIONS = new Set(["receivers", "processors", "exporters", "connectors", "extensions", "service"]);
+const SERVICE_KEYS = new Set(["extensions", "telemetry", "pipelines"]);
+const PIPELINE_KEYS = new Set(["receivers", "processors", "exporters"]);
+const PIN_LINE = /^#\s*chant:\s*(receiver|processor|exporter|connector|extension)\s+(\S+)\s+schema\s+(\S+)@([^@\s]+)(?:\s+(\S+))?\s*$/;
+const SEMCONV_LINE = /^#\s*chant:\s*semconv\s+(\S+)\s+(\S+)@([^@\s]+)(?:\s+([^\s(]+))?(?:\s+\(.*\))?\s*$/;
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** The `# chant:` lines of the comment block at the top of the file. */
+function readHeader(content, warnings) {
+    const pins = [];
+    const semconv = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === "")
+            continue;
+        if (!line.startsWith("#"))
+            break;
+        if (!/^#\s*chant:/.test(line))
+            continue;
+        const pin = PIN_LINE.exec(line);
+        if (pin) {
+            const [, kind, id, source, version, digest] = pin;
+            if (source === "(unpinned)" || version === "(unpinned)")
+                continue;
+            pins.push({ kind: kind, id, pin: digest ? { source, version, digest } : { source, version } });
+            continue;
+        }
+        const sc = SEMCONV_LINE.exec(line);
+        if (sc) {
+            const [, namespace, source, version, digest] = sc;
+            semconv.push({ namespace, pin: digest ? { source, version, digest } : { source, version } });
+            const ours = SEMCONV_VOCABULARIES.find((v) => v.namespace === namespace)?.pin;
+            if (ours && (source !== ours.source || version !== ours.version)) {
+                warnings.push(`the config was built against ${namespace} semantic conventions ${source}@${version}; ` +
+                    `this lexicon follows ${ours.source}@${ours.version}, which the rebuilt config will name`);
+            }
+            continue;
+        }
+        warnings.push(`header line "${line}" is not a schema pin chant recognises; it is not carried`);
+    }
+    return { pins, semconv };
+}
+/** Parse collector YAML into the plain config model, the header pins and what cannot be carried. */
+export function parseCollectorYaml(content) {
+    const warnings = [];
+    const { pins, semconv } = readHeader(content, warnings);
+    const doc = content.trim() === "" ? {} : jsYaml.load(content, { schema: COLLECTOR_YAML_SCHEMA });
+    if (doc === null || doc === undefined)
+        return { config: {}, pins, semconv, warnings };
+    if (!isPlainObject(doc)) {
+        throw new Error("an OpenTelemetry Collector config is a YAML mapping; this document is not one");
+    }
+    const config = {};
+    for (const [key, value] of Object.entries(doc)) {
+        if (!SECTIONS.has(key)) {
+            warnings.push(`top-level section "${key}" is not part of a collector config; it is not carried`);
+            continue;
+        }
+        if (value === null || value === undefined)
+            continue;
+        if (!isPlainObject(value)) {
+            warnings.push(`"${key}" is not a mapping; it is not carried`);
+            continue;
+        }
+        if (key === "service")
+            continue;
+        const section = {};
+        for (const [id, cfg] of Object.entries(value)) {
+            const parsed = parseComponentId(id);
+            if (!parsed)
+                warnings.push(`${key}: "${id}" is not a type[/name] component id`);
+            const builtin = parsed && canonicalComponentType(KIND_OF_SECTION[key], parsed.type);
+            if (parsed && builtin && builtin !== parsed.type) {
+                warnings.push(`${key}.${id} uses "${parsed.type}", the collector's newer name for "${builtin}"; it imports as the built-in, which writes "${builtin}"`);
+                const renamed = parsed.name === undefined ? builtin : `${builtin}/${parsed.name}`;
+                if (renamed in value)
+                    warnings.push(`${key}.${id} and ${key}.${renamed} become the same id "${renamed}"; rename one of them`);
+            }
+            if (cfg !== null && cfg !== undefined && !isPlainObject(cfg)) {
+                warnings.push(`${key}.${id} is not a mapping; it is carried as an empty config`);
+                section[id] = null;
+                continue;
+            }
+            if (isPlainObject(cfg) && "name" in cfg) {
+                warnings.push(`${key}.${id} has a config key "name", which chant uses for the instance name; the key is not carried`);
+            }
+            section[id] = cfg ?? null;
+        }
+        config[key] = section;
+    }
+    const service = doc.service;
+    if (isPlainObject(service)) {
+        config.service = {};
+        for (const [key, value] of Object.entries(service)) {
+            if (!SERVICE_KEYS.has(key)) {
+                warnings.push(`service.${key} is not carried; chant's Service declares extensions and telemetry`);
+                continue;
+            }
+            if (value === null || value === undefined)
+                continue;
+            if (key === "extensions") {
+                if (!Array.isArray(value))
+                    warnings.push("service.extensions is not a list; it is not carried");
+                else
+                    config.service.extensions = value.map(String);
+            }
+            else if (key === "telemetry") {
+                if (!isPlainObject(value))
+                    warnings.push("service.telemetry is not a mapping; it is not carried");
+                else
+                    config.service.telemetry = value;
+            }
+            else if (key === "pipelines") {
+                if (!isPlainObject(value)) {
+                    warnings.push("service.pipelines is not a mapping; it is not carried");
+                    continue;
+                }
+                config.service.pipelines = {};
+                for (const [pid, p] of Object.entries(value)) {
+                    const signal = pipelineSignal(pid);
+                    if (!SIGNALS.includes(signal)) {
+                        warnings.push(`pipeline "${pid}" carries signal "${signal}", which Pipeline does not type; it is imported with a type suppression`);
+                    }
+                    const entry = {};
+                    if (isPlainObject(p)) {
+                        for (const [k, list] of Object.entries(p)) {
+                            if (!PIPELINE_KEYS.has(k)) {
+                                warnings.push(`service.pipelines.${pid}.${k} is not carried; a Pipeline has receivers, processors and exporters`);
+                                continue;
+                            }
+                            if (list === null || list === undefined)
+                                continue;
+                            if (!Array.isArray(list)) {
+                                warnings.push(`service.pipelines.${pid}.${k} is not a list; it is not carried`);
+                                continue;
+                            }
+                            entry[k] = list.map(String);
+                        }
+                    }
+                    config.service.pipelines[pid] = entry;
+                }
+            }
+        }
+    }
+    return { config, pins, semconv, warnings };
+}
+/** Which kind a section's components are. */
+export const KIND_OF_SECTION = Object.fromEntries(COMPONENT_KINDS.map((k) => [SECTION_OF[k], k]));
+/** The OpenTelemetry Collector config parser `chant import` runs. */
+export class OtelCollectorParser {
+    parse(content) {
+        const parsed = parseCollectorYaml(content);
+        const properties = { config: parsed.config };
+        const metadata = { pins: parsed.pins, semconv: parsed.semconv };
+        return {
+            resources: [
+                {
+                    logicalId: "collector",
+                    type: COLLECTOR_RESOURCE_TYPE,
+                    properties: properties,
+                    metadata: metadata,
+                },
+            ],
+            parameters: [],
+            warnings: parsed.warnings,
+        };
+    }
+}