@telorun/analyzer 0.56.1 → 0.58.0

package/dist/validate-value-type-slots.js

@@ -0,0 +1,142 @@
+/**
+ * Static validation of the `x-telo-type` annotation itself — the strict half of
+ * the accessor split, and the `validate-ref-slots.ts` precedent.
+ *
+ * `readValueTypeSlot` is deliberately lenient: it reports whatever it can read,
+ * returning a slot with no `entry` for a name it does not know. That leniency is
+ * what lets every surface keep working; this pass is what stops it becoming
+ * silence. Before the unification an unrecognized brand simply resolved to
+ * `undefined` and the slot quietly lost its identity — the same class of failure
+ * `X_TELO_REF_INVALID_USE` exists to prevent for `use` tokens.
+ *
+ * The vocabulary is CLOSED and `Telo.`-qualified, so there is nothing here to
+ * resolve against an alias scope: a name is a built-in or it is a mistake. A
+ * SHAPE is a different thing entirely and is named with the reference tag, which
+ * carries its own resolution and its own diagnostics — this pass never sees one,
+ * because `resolveSchemaTypeRefs` has already turned it into a `$ref`.
+ *
+ * Scoping follows `X_TELO_REF_UNRESOLVED`: reported only for manifests in the
+ * entry's own modules, since a published dependency is not the consumer's to fix.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+import { readValueTypeSlot, VALUE_TYPES, X_TELO_TYPE } from "@telorun/sdk";
+import { distance } from "./levenshtein.js";
+import { isInSchemaRegion } from "./schema-region.js";
+/** Schema regions are reached by ANCESTRY, not by root key — see
+ *  `schema-region.ts`. Walking a manifest's root fields covers only a fraction of
+ *  the sites an author writes a schema at: an API route's `request.schema.body`
+ *  sits under `routes`, and a check that never reaches it is a hole in exactly
+ *  the diagnostic that exists to stop an unknown name degrading silently. */
+/** The closest declared type name within an edit-distance threshold, or
+ *  undefined. Mirrors `computeSuggestKind`: case-sensitive, and silent on a tie,
+ *  because a coin-flip suggestion is worse than none. */
+function suggestValueType(name) {
+    if (!name)
+        return undefined;
+    const threshold = Math.min(3, Math.floor(name.length / 3));
+    if (threshold < 1)
+        return undefined;
+    let best;
+    let bestDist = threshold + 1;
+    let tied = false;
+    for (const candidate of VALUE_TYPES.keys()) {
+        const d = distance(name, candidate);
+        if (d < bestDist) {
+            best = candidate;
+            bestDist = d;
+            tied = false;
+        }
+        else if (d === bestDist) {
+            tied = true;
+        }
+    }
+    return !best || bestDist > threshold || tied ? undefined : best;
+}
+function declaredNames() {
+    return [...VALUE_TYPES.keys()].join(", ");
+}
+/** Report the annotation on one schema node. */
+function checkNode(node, manifest, path, issues) {
+    const slot = readValueTypeSlot(node);
+    if (!slot)
+        return;
+    if (!slot.entry) {
+        const suggestion = suggestValueType(slot.name);
+        // Only the bare-name spelling can carry the repair: it IS the annotation's
+        // whole value, which is the only shape `DiagnosticFix` describes.
+        const bareName = typeof node[X_TELO_TYPE] === "string";
+        issues.push({
+            code: "X_TELO_TYPE_UNKNOWN",
+            manifest,
+            path,
+            message: `'${slot.name || "(missing name)"}' is not a value type. ` +
+                (suggestion ? `Did you mean '${suggestion}'? ` : "") +
+                `Declared types: ${declaredNames()}. A value type names how a value is ` +
+                `REPRESENTED and is kernel-owned; to name a shape, reference it with !ref.`,
+            ...(suggestion && bareName ? { fix: { replacement: suggestion } } : {}),
+        });
+        return;
+    }
+    const declared = new Set(slot.entry.parameters.map((p) => p.name));
+    for (const argument of Object.keys(slot.args)) {
+        if (declared.has(argument))
+            continue;
+        issues.push({
+            code: "X_TELO_TYPE_ARGUMENT_UNKNOWN",
+            manifest,
+            path,
+            message: `'${slot.entry.name}' declares no type parameter '${argument}'. ` +
+                (declared.size > 0
+                    ? `Its parameters: ${[...declared].join(", ")}.`
+                    : `It takes no type parameters.`),
+        });
+    }
+}
+/** Walk a schema value, reporting every annotation it carries.
+ *
+ *  Descends through every container rather than through a keyword list: a value
+ *  type is legal at any schema position — a property, an item, a union branch, a
+ *  `$defs` entry, a type argument — and enumerating positions is how a check
+ *  ends up not covering the one an author used. */
+function walk(value, manifest, path, segments, seen, issues) {
+    if (value === null || typeof value !== "object")
+        return;
+    if (seen.has(value))
+        return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        value.forEach((item, i) => walk(item, manifest, `${path}[${i}]`, [...segments, i], seen, issues));
+        return;
+    }
+    const node = value;
+    // Report only inside a schema region. The walk itself is unbounded — reporting
+    // is safe anywhere, unlike a rewrite — but an `x-telo-type` key sitting in a
+    // resource's own configuration is not a schema annotation and is not this
+    // check's to judge.
+    if (isInSchemaRegion([...segments, X_TELO_TYPE])) {
+        checkNode(node, manifest, path, issues);
+    }
+    for (const [key, child] of Object.entries(node)) {
+        // The annotation's own value is read by `checkNode`; descending into it
+        // would report the type ARGUMENTS as if they were annotated nodes of their
+        // own. Their turn comes below, as ordinary schema nodes.
+        if (key === X_TELO_TYPE) {
+            // Walk the NORMALIZED arguments, so a bare-name argument (`of: Telo.Bytes`)
+            // is checked exactly as its expanded form is — the sugar must not be a
+            // hole in the check that exists to catch a misspelled name.
+            const slot = readValueTypeSlot(node);
+            for (const [argName, argValue] of Object.entries(slot?.args ?? {})) {
+                walk(argValue, manifest, `${path}.${X_TELO_TYPE}.${argName}`, [...segments, X_TELO_TYPE, argName], seen, issues);
+            }
+            continue;
+        }
+        walk(child, manifest, path ? `${path}.${key}` : key, [...segments, key], seen, issues);
+    }
+}
+/** Every `x-telo-type` problem in one manifest, wherever a schema is written. */
+export function validateValueTypeSlots(manifest) {
+    const issues = [];
+    walk(manifest, manifest, "", [], new Set(), issues);
+    return issues;
+}

package/dist/value-type-keyword.d.ts

@@ -0,0 +1,60 @@
+/** The AJV half of `x-telo-type`, and the single place any Telo keyword is
+ *  registered on an AJV instance.
+ *
+ *  WHY CODEGEN RATHER THAN A `validate` FUNCTION. The kernel compiles standalone
+ *  validators and caches them on disk; a function-valued keyword does not survive
+ *  that serialization, so the check would silently be absent from exactly the
+ *  validators the runtime uses. Codegen inlines instead.
+ *
+ *  WHY THE CODEGEN LIVES HERE AND THE VOCABULARY DOES NOT. The SDK cannot depend
+ *  on ajv, and an entry declares a REPRESENTATION rather than a code fragment —
+ *  which is what lets one JSON file be read by a Rust kernel that has no AJV at
+ *  all. The split is the whole point: `sdk/value-types/*.json` says *what a value
+ *  is*, `sdk/nodejs/src/value-type.ts` says *what that means in this runtime*,
+ *  and this file turns the pair into a check.
+ *
+ *  ONE REGISTRATION SITE. {@link registerTeloKeywords} replaced five drifted
+ *  ones — the analyzer's `createAjv` and the kernel's `schema-validator`,
+ *  `resource-context`, `observed-state` and `manifest-schemas` — which registered
+ *  overlapping lists of twelve, four, one and one. Drift there is not cosmetic: a
+ *  no-op registration is what keeps `strict` mode quiet about an annotation, and
+ *  a keyword that emits code is missing entirely from any instance that forgot
+ *  it, so the same schema validated two ways depending on which AJV saw it. */
+import type { KeywordDefinition } from "ajv";
+/**
+ * Annotations that carry no validation at all: analyzer, editor and topology
+ * metadata. Registered as no-ops so AJV does not treat them as unknown keywords,
+ * and listed in one place so an instance cannot know about half of them.
+ *
+ * `x-telo-type` is deliberately absent — it is the one that emits code.
+ */
+export declare const ANNOTATION_KEYWORDS: readonly ["x-telo-bindings-from", "x-telo-catches-for", "x-telo-context", "x-telo-context-element-from", "x-telo-context-from", "x-telo-context-from-ref-kind", "x-telo-context-from-root", "x-telo-context-ref-from", "x-telo-error-context", "x-telo-eval", "x-telo-inline", "x-telo-outcome-list", "x-telo-provides-zone", "x-telo-ref", "x-telo-requires-zone", "x-telo-schema-from", "x-telo-scope", "x-telo-step-context", "x-telo-topology-role", "x-telo-value-schema-from", "x-telo-widget"];
+/**
+ * The `x-telo-type` keyword.
+ *
+ * Three postures, decided by the entry and never by this code:
+ *
+ *  - a `json` representation validates through its own declared schema, so the
+ *    keyword emits nothing — the name carries nominal identity for static wiring
+ *    and has no runtime existence at all;
+ *  - a `live` instance is EXEMPT: its value is never traversed, because iterating
+ *    a stream to check it is precisely what the exemption is for;
+ *  - every other instance is ASSERTED against the constructor its binding names.
+ *
+ * An unknown name emits nothing here. It is a hard diagnostic in the analyzer
+ * (`X_TELO_TYPE_UNKNOWN`), which is where a name can be reported against the
+ * manifest that wrote it; failing compilation instead would take out every
+ * validator in a module for one typo in one slot.
+ */
+export declare function valueTypeKeyword(): KeywordDefinition;
+/**
+ * Register every Telo keyword on an AJV instance: the annotations as no-ops and
+ * `x-telo-type` as the one that checks.
+ *
+ * Every AJV instance in the runtime and the analyzer goes through this, so a
+ * schema means the same thing wherever it is validated.
+ */
+export declare function registerTeloKeywords(ajv: {
+    addKeyword: (keyword: any, definition?: any) => unknown;
+}): void;
+//# sourceMappingURL=value-type-keyword.d.ts.map

package/dist/value-type-keyword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-type-keyword.d.ts","sourceRoot":"","sources":["../src/value-type-keyword.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;+EAqB+E;AAG/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,KAAK,CAAC;AAiB7C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,ueAsBtB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,IAAI,iBAAiB,CA+BpD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE;IACxC,UAAU,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC;CACzD,GAAG,IAAI,CAGP"}

package/dist/value-type-keyword.js

@@ -0,0 +1,119 @@
+/** The AJV half of `x-telo-type`, and the single place any Telo keyword is
+ *  registered on an AJV instance.
+ *
+ *  WHY CODEGEN RATHER THAN A `validate` FUNCTION. The kernel compiles standalone
+ *  validators and caches them on disk; a function-valued keyword does not survive
+ *  that serialization, so the check would silently be absent from exactly the
+ *  validators the runtime uses. Codegen inlines instead.
+ *
+ *  WHY THE CODEGEN LIVES HERE AND THE VOCABULARY DOES NOT. The SDK cannot depend
+ *  on ajv, and an entry declares a REPRESENTATION rather than a code fragment —
+ *  which is what lets one JSON file be read by a Rust kernel that has no AJV at
+ *  all. The split is the whole point: `sdk/value-types/*.json` says *what a value
+ *  is*, `sdk/nodejs/src/value-type.ts` says *what that means in this runtime*,
+ *  and this file turns the pair into a check.
+ *
+ *  ONE REGISTRATION SITE. {@link registerTeloKeywords} replaced five drifted
+ *  ones — the analyzer's `createAjv` and the kernel's `schema-validator`,
+ *  `resource-context`, `observed-state` and `manifest-schemas` — which registered
+ *  overlapping lists of twelve, four, one and one. Drift there is not cosmetic: a
+ *  no-op registration is what keeps `strict` mode quiet about an annotation, and
+ *  a keyword that emits code is missing entirely from any instance that forgot
+ *  it, so the same schema validated two ways depending on which AJV saw it. */
+import * as AjvNS from "ajv";
+import { VALUE_TYPE_BINDINGS, X_TELO_TYPE, readValueTypeSlot, } from "@telorun/sdk";
+const ajvExports = AjvNS.default ?? AjvNS;
+const codegen = ajvExports._ ?? AjvNS._;
+/**
+ * Annotations that carry no validation at all: analyzer, editor and topology
+ * metadata. Registered as no-ops so AJV does not treat them as unknown keywords,
+ * and listed in one place so an instance cannot know about half of them.
+ *
+ * `x-telo-type` is deliberately absent — it is the one that emits code.
+ */
+export const ANNOTATION_KEYWORDS = [
+    "x-telo-bindings-from",
+    "x-telo-catches-for",
+    "x-telo-context",
+    "x-telo-context-element-from",
+    "x-telo-context-from",
+    "x-telo-context-from-ref-kind",
+    "x-telo-context-from-root",
+    "x-telo-context-ref-from",
+    "x-telo-error-context",
+    "x-telo-eval",
+    "x-telo-inline",
+    "x-telo-outcome-list",
+    "x-telo-provides-zone",
+    "x-telo-ref",
+    "x-telo-requires-zone",
+    "x-telo-schema-from",
+    "x-telo-scope",
+    "x-telo-step-context",
+    "x-telo-topology-role",
+    "x-telo-value-schema-from",
+    "x-telo-widget",
+];
+/**
+ * The `x-telo-type` keyword.
+ *
+ * Three postures, decided by the entry and never by this code:
+ *
+ *  - a `json` representation validates through its own declared schema, so the
+ *    keyword emits nothing — the name carries nominal identity for static wiring
+ *    and has no runtime existence at all;
+ *  - a `live` instance is EXEMPT: its value is never traversed, because iterating
+ *    a stream to check it is precisely what the exemption is for;
+ *  - every other instance is ASSERTED against the constructor its binding names.
+ *
+ * An unknown name emits nothing here. It is a hard diagnostic in the analyzer
+ * (`X_TELO_TYPE_UNKNOWN`), which is where a name can be reported against the
+ * manifest that wrote it; failing compilation instead would take out every
+ * validator in a module for one typo in one slot.
+ */
+export function valueTypeKeyword() {
+    return {
+        keyword: X_TELO_TYPE,
+        // Both spellings: a bare name, or the object form carrying type arguments.
+        schemaType: ["string", "object"],
+        code(cxt) {
+            const entry = readValueTypeSlot({
+                [X_TELO_TYPE]: cxt.schema,
+            })?.entry;
+            if (!entry || entry.representation !== "instance" || entry.live)
+                return;
+            const binding = VALUE_TYPE_BINDINGS[entry.binding];
+            if (!binding)
+                return;
+            // The constructor reaches generated code through AJV's value scope, which
+            // is what keeps this general: `Uint8Array` happens to be a global, but a
+            // binding may name a class that is not, and inlining a bare identifier
+            // would compile to a reference that does not resolve.
+            const ctor = cxt.gen.scopeValue("obj", {
+                ref: binding.constructor,
+                code: codegen `require("@telorun/sdk").VALUE_TYPE_BINDINGS[${entry.binding}].constructor`,
+            });
+            cxt.pass(codegen `${cxt.data} instanceof ${ctor}`);
+        },
+        error: {
+            message: (cxt) => {
+                const entry = readValueTypeSlot({ [X_TELO_TYPE]: cxt.schema })?.entry;
+                return entry?.binding === "bytes"
+                    ? "must be raw bytes (a Uint8Array) — bytes cannot be written inline in a manifest"
+                    : `must be a ${entry?.name ?? "declared value type"} — this value is not writable inline in a manifest`;
+            },
+        },
+    };
+}
+/**
+ * Register every Telo keyword on an AJV instance: the annotations as no-ops and
+ * `x-telo-type` as the one that checks.
+ *
+ * Every AJV instance in the runtime and the analyzer goes through this, so a
+ * schema means the same thing wherever it is validated.
+ */
+export function registerTeloKeywords(ajv) {
+    for (const keyword of ANNOTATION_KEYWORDS)
+        ajv.addKeyword(keyword);
+    ajv.addKeyword(valueTypeKeyword());
+}

package/dist/yaml-source-edit.d.ts

@@ -0,0 +1,56 @@
+/** Writing a value back into YAML SOURCE — the two primitives every in-place
+ *  repair is built from, and the one place their rules are stated.
+ *
+ *  A repair is a byte splice over the author's own text, never
+ *  `Document.toString()`: re-serializing re-folds block scalars, drops
+ *  quote-style hints and reflows long strings, so a one-key edit would arrive
+ *  as a whole-file diff. That leaves two questions every writer has to answer
+ *  identically — how a value is re-quoted to occupy a span, and how overlapping
+ *  spans are spliced — and three surfaces asking them: the editors' quick fix
+ *  (`@telorun/ide-support`), `telo migrate` (the migration driver), and
+ *  `telo upgrade`'s pin rewrite.
+ *
+ *  They live HERE, in the lowest package of the three, because they are pure
+ *  string work with no Node dependency and because a copy per surface is a
+ *  silent-divergence risk of exactly the kind Telo's cross-cutting primitives
+ *  rule exists to prevent: two writers editing the same file from two copies of
+ *  a subtle quoting rule will eventually quote one value two ways, and nothing
+ *  would catch it. Same precedent as `ref-slot.ts` / `binary-slot.ts` — a rule
+ *  several surfaces must agree on gets one reader. */
+/** Whether `value` can be written as a plain scalar without changing meaning. */
+export declare function isPlainSafe(value: string): boolean;
+/** Quote style of the source text a repair is replacing. */
+export type QuoteStyle = "double" | "single" | "plain";
+export declare function quoteStyleOf(source: string): QuoteStyle;
+/** Render `replacement` so it occupies `originalSource`'s span as the same
+ *  scalar the author would have written by hand, or `undefined` when the span
+ *  cannot be rewritten safely.
+ *
+ *  A plain original is kept plain when it can be — rewriting `Run.Sequenc` to
+ *  `"Run.Sequence"` would be a correct but noisy diff on a kind name — and
+ *  promoted to double quotes when the new value would not survive unquoted.
+ *
+ *  **A multi-line span is refused.** A block scalar's span covers its `|`/`>-`
+ *  indicator AND its trailing newline, so writing a single-line scalar over it
+ *  deletes the line break that ended the mapping entry and glues the next key
+ *  onto the value — the document stops parsing. Re-emitting a block scalar
+ *  correctly needs the node's indentation, which no consumer of this function
+ *  has. A multi-line REPLACEMENT is refused for the mirror reason: its
+ *  continuation lines would land at column 0, which is not a legal mapping
+ *  value. A quick fix promises a repair that can be applied without review, so
+ *  the only honest answer for these is no repair. */
+export declare function renderFixReplacement(originalSource: string, replacement: string): string | undefined;
+/** A splice over a source file: replace `[start, end)` with `newText`. An empty
+ *  span is a pure insertion. */
+export interface TextEdit {
+    /** Byte offset of the first replaced character (inclusive). */
+    readonly start: number;
+    /** Byte offset one past the last replaced character. */
+    readonly end: number;
+    readonly newText: string;
+}
+/** Splice `edits` into `text`, right to left so earlier offsets stay valid.
+ *  Callers are responsible for edits not overlapping; two splices contending
+ *  for the same bytes cannot both be honoured, and this does not arbitrate. */
+export declare function applyTextEdits(text: string, edits: readonly TextEdit[]): string;
+//# sourceMappingURL=yaml-source-edit.d.ts.map

package/dist/yaml-source-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-source-edit.d.ts","sourceRoot":"","sources":["../src/yaml-source-edit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;sDAkBsD;AAStD,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAUlD;AAED,4DAA4D;AAC5D,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEvD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAIvD;AAED;;;;;;;;;;;;;;;;qDAgBqD;AACrD,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAcpB;AAED;gCACgC;AAChC,MAAM,WAAW,QAAQ;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;+EAE+E;AAC/E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAO/E"}

package/dist/yaml-source-edit.js

@@ -0,0 +1,93 @@
+/** Writing a value back into YAML SOURCE — the two primitives every in-place
+ *  repair is built from, and the one place their rules are stated.
+ *
+ *  A repair is a byte splice over the author's own text, never
+ *  `Document.toString()`: re-serializing re-folds block scalars, drops
+ *  quote-style hints and reflows long strings, so a one-key edit would arrive
+ *  as a whole-file diff. That leaves two questions every writer has to answer
+ *  identically — how a value is re-quoted to occupy a span, and how overlapping
+ *  spans are spliced — and three surfaces asking them: the editors' quick fix
+ *  (`@telorun/ide-support`), `telo migrate` (the migration driver), and
+ *  `telo upgrade`'s pin rewrite.
+ *
+ *  They live HERE, in the lowest package of the three, because they are pure
+ *  string work with no Node dependency and because a copy per surface is a
+ *  silent-divergence risk of exactly the kind Telo's cross-cutting primitives
+ *  rule exists to prevent: two writers editing the same file from two copies of
+ *  a subtle quoting rule will eventually quote one value two ways, and nothing
+ *  would catch it. Same precedent as `ref-slot.ts` / `binary-slot.ts` — a rule
+ *  several surfaces must agree on gets one reader. */
+/** Characters that make a plain (unquoted) YAML scalar reparse as something
+ *  else. `-` and `?` are indicators only when followed by a space, so they are
+ *  handled by the leading-token check rather than listed here. */
+const PLAIN_UNSAFE_LEAD = new Set([
+    "&", "*", "!", "|", ">", "%", "@", "`", "#", "'", '"', "{", "[", "}", "]", ",",
+]);
+/** Whether `value` can be written as a plain scalar without changing meaning. */
+export function isPlainSafe(value) {
+    if (value === "" || value.trim() !== value)
+        return false;
+    if (PLAIN_UNSAFE_LEAD.has(value[0]))
+        return false;
+    // `-`/`?`/`:` lead only matter when a space follows — `-x` is a scalar,
+    // `- x` is a sequence entry.
+    if (/^[-?:]\s/.test(value))
+        return false;
+    // A colon-space anywhere opens a mapping; a space-hash opens a comment.
+    if (value.includes(": ") || value.includes(" #"))
+        return false;
+    if (value.endsWith(":"))
+        return false;
+    return !/[\n\r]/.test(value);
+}
+export function quoteStyleOf(source) {
+    if (source.length >= 2 && source.startsWith('"') && source.endsWith('"'))
+        return "double";
+    if (source.length >= 2 && source.startsWith("'") && source.endsWith("'"))
+        return "single";
+    return "plain";
+}
+/** Render `replacement` so it occupies `originalSource`'s span as the same
+ *  scalar the author would have written by hand, or `undefined` when the span
+ *  cannot be rewritten safely.
+ *
+ *  A plain original is kept plain when it can be — rewriting `Run.Sequenc` to
+ *  `"Run.Sequence"` would be a correct but noisy diff on a kind name — and
+ *  promoted to double quotes when the new value would not survive unquoted.
+ *
+ *  **A multi-line span is refused.** A block scalar's span covers its `|`/`>-`
+ *  indicator AND its trailing newline, so writing a single-line scalar over it
+ *  deletes the line break that ended the mapping entry and glues the next key
+ *  onto the value — the document stops parsing. Re-emitting a block scalar
+ *  correctly needs the node's indentation, which no consumer of this function
+ *  has. A multi-line REPLACEMENT is refused for the mirror reason: its
+ *  continuation lines would land at column 0, which is not a legal mapping
+ *  value. A quick fix promises a repair that can be applied without review, so
+ *  the only honest answer for these is no repair. */
+export function renderFixReplacement(originalSource, replacement) {
+    if (/[\n\r]/.test(originalSource) || /[\n\r]/.test(replacement))
+        return undefined;
+    const style = quoteStyleOf(originalSource);
+    if (style === "single") {
+        // A single-quoted YAML scalar escapes only the quote, by doubling it. CEL
+        // string literals use single quotes constantly, so this is the common case
+        // for an expression written in a single-quoted scalar.
+        return `'${replacement.replaceAll("'", "''")}'`;
+    }
+    if (style === "double" || !isPlainSafe(replacement)) {
+        return `"${replacement.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+    }
+    return replacement;
+}
+/** Splice `edits` into `text`, right to left so earlier offsets stay valid.
+ *  Callers are responsible for edits not overlapping; two splices contending
+ *  for the same bytes cannot both be honoured, and this does not arbitrate. */
+export function applyTextEdits(text, edits) {
+    if (edits.length === 0)
+        return text;
+    let out = text;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+        out = out.slice(0, edit.start) + edit.newText + out.slice(edit.end);
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.56.1",
+  "version": "0.58.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -41,14 +41,15 @@
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
+    "packageurl-js": "^2.0.1",
     "yaml": "^2.8.3",
-    "@telorun/templating": "0.12.0"
+    "@telorun/templating": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.70.0"
+    "@telorun/sdk": "0.73.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"