@telorun/analyzer 0.61.0 → 0.62.1

package/dist/validate-observed-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-observed-state.d.ts","sourceRoot":"","sources":["../src/validate-observed-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAgBjD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;CAGjC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,SAAS,gBAAgB,EAAE,GACrC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC;+CAC2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAOzF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAQtE;AAGD;;4EAE4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,IAAI,EAAE;IAAE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;CAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAAC,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,EAC/G,MAAM,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAsC/B;AAyDD;;;gDAGgD;AAChD,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC5C,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAmBN"}
+{"version":3,"file":"validate-observed-state.d.ts","sourceRoot":"","sources":["../src/validate-observed-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAgBjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB;;;CAGjC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,SAAS,gBAAgB,EAAE,GACrC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC;+CAC2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAOzF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAQtE;AAGD;;4EAE4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,IAAI,EAAE;IAAE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;CAAE,EAC/D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAAC,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,EAC/G,MAAM,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAsC/B;AAyDD;;;gDAGgD;AAChD,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC5C,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CASrB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAmBN"}

package/dist/validate-observed-state.js

@@ -16,8 +16,15 @@ const SYSTEM_KINDS = new Set([
  * {@link validateObservedStateDeclarations} rather than here, so the author gets
  * a message naming the rule and the fix instead of AJV's "must NOT be valid".
  *
- * Exported from the analyzer and re-used by the kernel's manifest schemas, so
- * the rule has one definition rather than two kept in sync by hand.
+ * THE KERNEL'S SHAPE CHECK, not the analyzer's. The analyzer's builtins point
+ * their `status:` slot at the `JsonSchema7` fragment, which describes the same
+ * block far more precisely; the kernel keeps this permissive one, and the two do
+ * not drift into disagreement because the fragment only ever NARROWS what this
+ * accepts. That split is the same one the `required:` rule above draws: the
+ * loader answers "is this the right shape at all", and the check that can name
+ * the offending keyword and its line stays with `telo check`. Wiring the fragment
+ * into the kernel too would turn a check-time diagnostic into a boot failure for
+ * every already-published manifest carrying a sloppy keyword.
  */
 export const OBSERVED_STATE_SCHEMA = {
     type: "object",

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

@@ -1 +1 @@
-{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAmetB"}
+{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CA8ctB"}

package/dist/validate-references.js

@@ -188,32 +188,11 @@ export function validateReferences(resources, context) {
             });
         }
     }
-    // A resource name must contain no dot. The `!ref` resolver splits the tag's source on
-    // the first dot to separate an import alias from the resource name, so a dotted name
-    // would mis-resolve into a cross-module lookup. This is the load-bearing invariant of
-    // the reference grammar, so it is enforced here rather than left to the (unenforced)
-    // casing convention.
-    for (const [name, list] of byNameAll) {
-        if (!name.includes("."))
-            continue;
-        for (const r of list) {
-            const m = r.metadata;
-            const range = typeof m?.sourceLine === "number"
-                ? {
-                    start: { line: m.sourceLine, character: 0 },
-                    end: { line: m.sourceLine, character: Number.MAX_SAFE_INTEGER },
-                }
-                : undefined;
-            diagnostics.push({
-                severity: DiagnosticSeverity.Error,
-                code: "INVALID_RESOURCE_NAME",
-                source: SOURCE,
-                message: `${r.kind}/${name}: resource name must not contain '.' — in a '!ref' the '.' separates an import alias from the resource name`,
-                ...(range ? { range } : {}),
-                data: { resource: { kind: r.kind, name }, filePath: m?.source, path: "metadata.name" },
-            });
-        }
-    }
+    // The dot rule that used to live here is now the strictest special case of
+    // the identifier grammar in `validate-identifier-names.ts` — a dot is one of
+    // several characters that make a name unreferenceable, and checking one of
+    // them here while the rest went unchecked is what let a hyphenated name
+    // through to silently evaluate as arithmetic.
     // Single-resource map for the resolution / scope lookups below — when a
     // collision exists, falling back to the first occurrence keeps the rest
     // of the pass behaving the same as before the duplicate diagnostic was

package/dist/validate-requires.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The strict half of `requires-block.ts` — the accessor/validator split
+ * `zone-slot.ts` / `validate-zone-slots.ts` established, and for the same reason:
+ * the reader must not throw on a malformed block (every consumer would have to
+ * guard), while a malformed block must not pass silently either.
+ *
+ * Two distinct outputs, and conflating them was the whole failure this mechanism
+ * addresses:
+ *
+ *  - **`MODULE_REQUIRES_NEWER_RUNTIME`** — the module is fine and *this runtime*
+ *    is too old. Raised per module before that module's own validation, so the
+ *    version message wins over the vocabulary errors it would otherwise be buried
+ *    in (`ZONE_ANNOTATION_INVALID`, an `additionalProperties` violation against a
+ *    kernel-owned schema, an unknown `use` token). Those errors are true but
+ *    blame the module author for a version skew.
+ *  - **`REQUIRES_INVALID`** — the declaration itself is malformed. Severity turns
+ *    on ownership rather than presence: an ERROR on the entry's own modules,
+ *    whose author can fix it, and a WARNING on a dependency, whose author is the
+ *    only one who can. It is not silent on a dependency, because `readRequires`
+ *    drops an unparseable range and the gate then reads the module as satisfied —
+ *    so it loads while stating a requirement it failed to state, and `telo
+ *    upgrade` (which refuses such a version) would be holding it back for a
+ *    reason the load path never mentions.
+ *
+ * **Unknown axes are suppressed while the `telo` requirement is unmet.** An older
+ * runtime not recognising a newer host axis is a *consequence* of the version
+ * skew — the axis exists, this runtime is simply too old to know it — so
+ * reporting it beside the gate diagnostic would manufacture a second defect from
+ * one cause. Once `telo` is satisfied, an unrecognized axis is a real error: a
+ * runtime at or above the declared generation is expected to know every axis that
+ * generation defines.
+ */
+import type { ResourceManifest } from "@telorun/sdk";
+import { type HostVersions } from "./requires-block.js";
+import { type AnalysisDiagnostic } from "./types.js";
+export interface ValidateRequiresOptions {
+    /** The surface generation the analyzing runtime implements. Defaults to this
+     *  build's own — see `AnalysisOptions.teloVersion`. */
+    teloVersion?: string;
+    /** Versions the running host can speak for. Absent in a browser, where there
+     *  is no host to report; supplied by the kernel and CLI. */
+    hostVersions?: HostVersions;
+    /** Module names owned by the entry, when the caller can distinguish them.
+     *  `REQUIRES_INVALID` is limited to these; the gate is not, because a
+     *  dependency this runtime cannot read still stops the consumer dead. */
+    entryModules?: ReadonlySet<string>;
+}
+export declare function validateRequires(manifests: ResourceManifest[], options?: ValidateRequiresOptions): AnalysisDiagnostic[];
+//# sourceMappingURL=validate-requires.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate-requires.d.ts","sourceRoot":"","sources":["../src/validate-requires.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAkC,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExF,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE,MAAM,WAAW,uBAAuB;IACtC;2DACuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;gEAC4D;IAC5D,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;6EAEyE;IACzE,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,GAAE,uBAA4B,GACpC,kBAAkB,EAAE,CAuEtB"}

package/dist/validate-requires.js

@@ -0,0 +1,99 @@
+/**
+ * The strict half of `requires-block.ts` — the accessor/validator split
+ * `zone-slot.ts` / `validate-zone-slots.ts` established, and for the same reason:
+ * the reader must not throw on a malformed block (every consumer would have to
+ * guard), while a malformed block must not pass silently either.
+ *
+ * Two distinct outputs, and conflating them was the whole failure this mechanism
+ * addresses:
+ *
+ *  - **`MODULE_REQUIRES_NEWER_RUNTIME`** — the module is fine and *this runtime*
+ *    is too old. Raised per module before that module's own validation, so the
+ *    version message wins over the vocabulary errors it would otherwise be buried
+ *    in (`ZONE_ANNOTATION_INVALID`, an `additionalProperties` violation against a
+ *    kernel-owned schema, an unknown `use` token). Those errors are true but
+ *    blame the module author for a version skew.
+ *  - **`REQUIRES_INVALID`** — the declaration itself is malformed. Severity turns
+ *    on ownership rather than presence: an ERROR on the entry's own modules,
+ *    whose author can fix it, and a WARNING on a dependency, whose author is the
+ *    only one who can. It is not silent on a dependency, because `readRequires`
+ *    drops an unparseable range and the gate then reads the module as satisfied —
+ *    so it loads while stating a requirement it failed to state, and `telo
+ *    upgrade` (which refuses such a version) would be holding it back for a
+ *    reason the load path never mentions.
+ *
+ * **Unknown axes are suppressed while the `telo` requirement is unmet.** An older
+ * runtime not recognising a newer host axis is a *consequence* of the version
+ * skew — the axis exists, this runtime is simply too old to know it — so
+ * reporting it beside the gate diagnostic would manufacture a second defect from
+ * one cause. Once `telo` is satisfied, an unrecognized axis is a real error: a
+ * runtime at or above the declared generation is expected to know every axis that
+ * generation defines.
+ */
+import { evaluateRequires, readRequires } from "./requires-block.js";
+import { TELO_SURFACE_VERSION } from "./telo-version.js";
+import { DiagnosticSeverity } from "./types.js";
+const SOURCE = "telo-analyzer";
+export function validateRequires(manifests, options = {}) {
+    const running = options.teloVersion ?? TELO_SURFACE_VERSION;
+    const out = [];
+    for (const manifest of manifests) {
+        if (manifest.kind !== "Telo.Application" && manifest.kind !== "Telo.Library")
+            continue;
+        const doc = manifest;
+        const { declared, block, issues } = readRequires(doc);
+        if (!declared)
+            continue;
+        const metadata = (manifest.metadata ?? {});
+        const name = typeof metadata.name === "string" ? metadata.name : undefined;
+        const filePath = typeof metadata.source === "string" ? metadata.source : undefined;
+        const label = `${manifest.kind}/${name ?? "(unnamed)"}`;
+        const resource = { kind: manifest.kind, name };
+        const verdict = evaluateRequires(block, running, options.hostVersions);
+        if (!verdict.satisfied) {
+            const axis = verdict.axis === "telo" ? "telo" : `host.${verdict.axis}`;
+            const remedy = verdict.axis === "telo"
+                ? `Upgrade telo, or pin ${name ?? "this module"} to a version whose range accepts ` +
+                    `${verdict.running}.`
+                : `Upgrade ${verdict.axis}, or pin ${name ?? "this module"} to a version whose range ` +
+                    `accepts ${verdict.running}.`;
+            out.push({
+                severity: DiagnosticSeverity.Error,
+                code: "MODULE_REQUIRES_NEWER_RUNTIME",
+                source: SOURCE,
+                message: `${label} requires ${axis} '${verdict.declared.raw}'; this runtime reports ` +
+                    `${verdict.running}. ${remedy}`,
+                data: { resource, filePath, path: `requires.${axis}` },
+            });
+        }
+        const owned = options.entryModules === undefined ||
+            (typeof metadata.module === "string"
+                ? options.entryModules.has(metadata.module)
+                : name === undefined || options.entryModules.has(name));
+        for (const issue of issues) {
+            // See the header: an unknown axis is a symptom while the gate is failing.
+            if (issue.unknownAxis && !verdict.satisfied)
+                continue;
+            // A DEPENDENCY's malformed block is not the consumer's to fix, but it must
+            // not be silent either. `readRequires` drops an unparseable range from the
+            // block, so the gate reads it as satisfied and the module loads while
+            // stating a requirement it failed to state — and `telo upgrade`, which
+            // refuses to select such a version, would then be holding a version back
+            // for a reason nothing on the load path ever mentions. A warning is what
+            // makes those two halves agree about the manifest without handing the
+            // consumer an error only its publisher can fix.
+            out.push({
+                severity: owned ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning,
+                code: "REQUIRES_INVALID",
+                source: SOURCE,
+                message: owned
+                    ? `${label}: ${issue.message}` + (issue.hint ? ` Write '${issue.hint}' instead.` : "")
+                    : `${label}: ${issue.message} Its declared requirement cannot be read, so it is not ` +
+                        `enforced here and \`telo upgrade\` will not select this version. Only the module's ` +
+                        `publisher can fix it.`,
+                data: { resource, filePath, path: issue.path },
+            });
+        }
+    }
+    return out;
+}

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

@@ -28,7 +28,7 @@ import type { KeywordDefinition } from "ajv";
  *
  * `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"];
+export declare const ANNOTATION_KEYWORDS: readonly ["x-telo-bindings-from", "x-telo-catches-for", "x-telo-context", "x-telo-context-collection-from", "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.
  *

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

@@ -1 +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"}
+{"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,ygBAuBtB,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

@@ -35,6 +35,7 @@ export const ANNOTATION_KEYWORDS = [
     "x-telo-bindings-from",
     "x-telo-catches-for",
     "x-telo-context",
+    "x-telo-context-collection-from",
     "x-telo-context-element-from",
     "x-telo-context-from",
     "x-telo-context-from-ref-kind",

package/dist/version-range.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The version-range grammar `requires:` declares, and the only one Telo reads.
+ *
+ * Built on `module-version-order.ts`'s precedence rather than the `semver`
+ * package, for that file's reason: the analyzer is browser-safe, so the editor
+ * reaches the identical rule the kernel does. A second implementation of "does
+ * this version satisfy this range" would eventually disagree about what a
+ * manifest means, which is the whole failure this mechanism exists to prevent.
+ *
+ * **A range is a CONJUNCTION of explicit comparators** — `>=0.80.0`,
+ * `>=0.40.0 <0.50.0`, `>=0.40.0,<0.50.0`. That is deliberately narrower than
+ * npm's grammar, and every exclusion pays for itself:
+ *
+ *  - **`^` and `~` are rejected**, not reinterpreted. On a `0.x` version both
+ *    mean a single minor (`^0.40.0` is `>=0.40.0 <0.41.0`, identical to
+ *    `~0.40.0`), and Telo ships breaking changes as minor bumps deliberately. So
+ *    the caret reading is *correct* and therefore useless — every module would
+ *    pin to one breaking-change generation and nobody could move telo without
+ *    the whole standard library republishing. It is also the spelling semver
+ *    intuition reaches for first, so accepting it would make the failure both
+ *    common and silent.
+ *  - **A bare version is rejected.** npm reads `0.80.0` as an exact pin, which is
+ *    the same trap in a different costume; reading it as `>=` would contradict
+ *    every other semver consumer. Refusing it and naming the two spellings is
+ *    the only answer that cannot be misread.
+ *  - **`||`, hyphen ranges, `*` and `x` are rejected.** A disjunction has no
+ *    single low or high edge, and the edges are load-bearing: verification runs
+ *    the CLI *at* them, and a declared upper bound must be checked for existence.
+ *    A grammar whose edges are undefined cannot be verified, and an unverifiable
+ *    bound is what this design forbids everywhere else.
+ *
+ * **Prereleases compare by plain precedence**, with no equivalent of npm's rule
+ * that a prerelease only satisfies a range mentioning one at the same
+ * `[major, minor, patch]`. That rule exists to stop a caret range dragging a
+ * consumer onto an `-rc` build; here the version being tested is *the runtime the
+ * user is already running*, not a candidate being selected for them, so the
+ * honest answer is the precedence one — a developer on `0.81.0-rc.1` satisfies
+ * `>=0.80.0` because they genuinely are past it.
+ */
+import { type ParsedModuleVersion } from "./module-version-order.js";
+/** The comparison a single term applies. */
+export type ComparatorOperator = ">=" | ">" | "<=" | "<";
+export interface VersionComparator {
+    operator: ComparatorOperator;
+    /** The version as authored, for diagnostics and for the existence check. */
+    raw: string;
+    parsed: ParsedModuleVersion;
+}
+/** A parsed range: every comparator must hold. Never empty. */
+export interface VersionRange {
+    /** The range exactly as authored, quoted verbatim in diagnostics. */
+    raw: string;
+    comparators: VersionComparator[];
+}
+/** Why a range string was refused. `hint` is the spelling to use instead, when
+ *  there is an unambiguous one — a rejection that cannot say what to write
+ *  instead is a worse diagnostic than the value it rejects. */
+export interface VersionRangeError {
+    message: string;
+    hint?: string;
+}
+export type VersionRangeResult = {
+    ok: true;
+    range: VersionRange;
+} | {
+    ok: false;
+    error: VersionRangeError;
+};
+/**
+ * Parse a range, or explain why it cannot be one. Never throws and never
+ * degrades to a permissive reading: a range this refuses is reported, not
+ * silently treated as "no requirement".
+ */
+export declare function parseVersionRange(raw: unknown): VersionRangeResult;
+/** True when `version` satisfies every comparator. An unparseable `version` is
+ *  `false` — never a pass, since the caller is asking whether a real runtime is
+ *  admitted and "cannot tell" must not read as "yes". */
+export declare function rangeAccepts(range: VersionRange, version: string): boolean;
+/** The lower-bound comparator, or `undefined` when the range is open below.
+ *  This is the version verification installs and runs as the low edge. */
+export declare function lowerBound(range: VersionRange): VersionComparator | undefined;
+/** The upper-bound comparator, or `undefined` when the range is open above —
+ *  the normal case, where the high edge is HEAD and normal CI already covers it. */
+export declare function upperBound(range: VersionRange): VersionComparator | undefined;
+/** True when no version can satisfy the range — `>=0.90.0 <0.80.0`. Reported
+ *  rather than left to fail mysteriously at every consumer. */
+export declare function isUnsatisfiable(range: VersionRange): boolean;
+//# sourceMappingURL=version-range.d.ts.map

package/dist/version-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-range.d.ts","sourceRoot":"","sources":["../src/version-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,iBAAiB,EAAE,CAAC;CAClC;AAED;;+DAE+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GACjC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAuB5C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAkElE;AAED;;yDAEyD;AACzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAgB1E;AAED;0EAC0E;AAC1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAE7E;AAED;oFACoF;AACpF,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAE7E;AAoBD;+DAC+D;AAC/D,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAS5D"}

package/dist/version-range.js

@@ -0,0 +1,173 @@
+/**
+ * The version-range grammar `requires:` declares, and the only one Telo reads.
+ *
+ * Built on `module-version-order.ts`'s precedence rather than the `semver`
+ * package, for that file's reason: the analyzer is browser-safe, so the editor
+ * reaches the identical rule the kernel does. A second implementation of "does
+ * this version satisfy this range" would eventually disagree about what a
+ * manifest means, which is the whole failure this mechanism exists to prevent.
+ *
+ * **A range is a CONJUNCTION of explicit comparators** — `>=0.80.0`,
+ * `>=0.40.0 <0.50.0`, `>=0.40.0,<0.50.0`. That is deliberately narrower than
+ * npm's grammar, and every exclusion pays for itself:
+ *
+ *  - **`^` and `~` are rejected**, not reinterpreted. On a `0.x` version both
+ *    mean a single minor (`^0.40.0` is `>=0.40.0 <0.41.0`, identical to
+ *    `~0.40.0`), and Telo ships breaking changes as minor bumps deliberately. So
+ *    the caret reading is *correct* and therefore useless — every module would
+ *    pin to one breaking-change generation and nobody could move telo without
+ *    the whole standard library republishing. It is also the spelling semver
+ *    intuition reaches for first, so accepting it would make the failure both
+ *    common and silent.
+ *  - **A bare version is rejected.** npm reads `0.80.0` as an exact pin, which is
+ *    the same trap in a different costume; reading it as `>=` would contradict
+ *    every other semver consumer. Refusing it and naming the two spellings is
+ *    the only answer that cannot be misread.
+ *  - **`||`, hyphen ranges, `*` and `x` are rejected.** A disjunction has no
+ *    single low or high edge, and the edges are load-bearing: verification runs
+ *    the CLI *at* them, and a declared upper bound must be checked for existence.
+ *    A grammar whose edges are undefined cannot be verified, and an unverifiable
+ *    bound is what this design forbids everywhere else.
+ *
+ * **Prereleases compare by plain precedence**, with no equivalent of npm's rule
+ * that a prerelease only satisfies a range mentioning one at the same
+ * `[major, minor, patch]`. That rule exists to stop a caret range dragging a
+ * consumer onto an `-rc` build; here the version being tested is *the runtime the
+ * user is already running*, not a candidate being selected for them, so the
+ * honest answer is the precedence one — a developer on `0.81.0-rc.1` satisfies
+ * `>=0.80.0` because they genuinely are past it.
+ */
+import { compareParsedModuleVersions, parseModuleVersion, } from "./module-version-order.js";
+/** Operators longest-first, so `>=` is matched before `>`. */
+const OPERATORS = [">=", "<=", ">", "<"];
+function refuse(message, hint) {
+    return { ok: false, error: hint === undefined ? { message } : { message, hint } };
+}
+/**
+ * Refuse with `>=<version>` as the hint — but only when that hint would itself
+ * parse.
+ *
+ * A hint is a repair the author is meant to paste, so one this parser would
+ * reject on the next run is worse than no hint at all: it converts a diagnostic
+ * the author can act on into a loop. Everything unparseable (a two-segment
+ * version, a date, a leftover placeholder) falls back to the message alone,
+ * which still names what is wrong.
+ */
+function hintedRefusal(message, version) {
+    return parseModuleVersion(version) ? refuse(message, `>=${version}`) : refuse(message);
+}
+/**
+ * Parse a range, or explain why it cannot be one. Never throws and never
+ * degrades to a permissive reading: a range this refuses is reported, not
+ * silently treated as "no requirement".
+ */
+export function parseVersionRange(raw) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+        return refuse(`expected a version range string, got ${describe(raw)}`);
+    }
+    const text = raw.trim();
+    if (text.includes("||")) {
+        return refuse(`'${text}' is a disjunction. A range must be a conjunction of comparators, because ` +
+            `verification runs the CLI at its lowest and highest bound and a disjunction has neither`);
+    }
+    if (/\s-\s/.test(text)) {
+        return refuse(`'${text}' is a hyphen range`, `${text.split(/\s-\s/)[0]?.trim() ?? ""} rewritten as '>=' and '<=' comparators`);
+    }
+    const terms = text.split(/[\s,]+/).filter((t) => t !== "");
+    const comparators = [];
+    for (const term of terms) {
+        if (term.startsWith("^") || term.startsWith("~")) {
+            const version = term.slice(1);
+            const parsed = parseModuleVersion(version);
+            const upper = parsed && parsed.major === 0 ? `0.${parsed.minor + 1}.0` : `${(parsed?.major ?? 0) + 1}.0.0`;
+            return refuse(`'${term}' is not accepted. Pre-1.0, '${term[0]}' allows only ${version} up to ` +
+                `${upper}, and Telo ships breaking changes as minor bumps — so it pins this module to ` +
+                `a single release generation, which is almost never what is meant`, `>=${version}`);
+        }
+        // Any `x`/`*` placeholder, at any position — `*`, `x`, `1.x`, `1.2.x`,
+        // `1.2.*`. Catching only some of them sent the rest to the no-comparator
+        // branch below, which suggested `>=1.2.*` — a hint this very parser rejects,
+        // which is worse than the value it was rejecting.
+        if (/(^|\.)[x*]$/i.test(term) || /(^|\.)[x*]\./i.test(term)) {
+            return refuse(`'${term}' is a wildcard range; write explicit comparators instead`);
+        }
+        if (term.startsWith("=")) {
+            return hintedRefusal(`'${term}' pins one exact version`, term.replace(/^=+/, ""));
+        }
+        const operator = OPERATORS.find((op) => term.startsWith(op));
+        if (!operator) {
+            return hintedRefusal(`'${term}' has no comparator. A bare version reads as an exact pin in semver, which is ` +
+                `almost never meant here`, term);
+        }
+        const version = term.slice(operator.length).trim();
+        const parsed = parseModuleVersion(version);
+        if (!parsed) {
+            return refuse(`'${version}' in '${term}' is not a three-part version (X.Y.Z, optionally -prerelease)`);
+        }
+        comparators.push({ operator, raw: version, parsed });
+    }
+    if (comparators.length === 0)
+        return refuse(`'${text}' declares no comparator`);
+    return { ok: true, range: { raw: text, comparators } };
+}
+/** True when `version` satisfies every comparator. An unparseable `version` is
+ *  `false` — never a pass, since the caller is asking whether a real runtime is
+ *  admitted and "cannot tell" must not read as "yes". */
+export function rangeAccepts(range, version) {
+    const parsed = parseModuleVersion(version);
+    if (!parsed)
+        return false;
+    return range.comparators.every((c) => {
+        const cmp = compareParsedModuleVersions(parsed, c.parsed);
+        switch (c.operator) {
+            case ">=":
+                return cmp >= 0;
+            case ">":
+                return cmp > 0;
+            case "<=":
+                return cmp <= 0;
+            case "<":
+                return cmp < 0;
+        }
+    });
+}
+/** The lower-bound comparator, or `undefined` when the range is open below.
+ *  This is the version verification installs and runs as the low edge. */
+export function lowerBound(range) {
+    return highest(range.comparators.filter((c) => c.operator === ">=" || c.operator === ">"));
+}
+/** The upper-bound comparator, or `undefined` when the range is open above —
+ *  the normal case, where the high edge is HEAD and normal CI already covers it. */
+export function upperBound(range) {
+    return lowest(range.comparators.filter((c) => c.operator === "<=" || c.operator === "<"));
+}
+/** The tightest of several same-direction bounds wins; a range may legitimately
+ *  state more than one, and only the binding bound is an edge worth testing. */
+function highest(list) {
+    return list.reduce((best, c) => best === undefined || compareParsedModuleVersions(c.parsed, best.parsed) > 0 ? c : best, undefined);
+}
+function lowest(list) {
+    return list.reduce((best, c) => best === undefined || compareParsedModuleVersions(c.parsed, best.parsed) < 0 ? c : best, undefined);
+}
+/** True when no version can satisfy the range — `>=0.90.0 <0.80.0`. Reported
+ *  rather than left to fail mysteriously at every consumer. */
+export function isUnsatisfiable(range) {
+    const low = lowerBound(range);
+    const high = upperBound(range);
+    if (!low || !high)
+        return false;
+    const cmp = compareParsedModuleVersions(low.parsed, high.parsed);
+    if (cmp > 0)
+        return true;
+    // `>=X <X` and `>X <=X` admit nothing; `>=X <=X` admits exactly X.
+    if (cmp === 0)
+        return low.operator === ">" || high.operator === "<";
+    return false;
+}
+function describe(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "an array";
+    return typeof value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.61.0",
+  "version": "0.62.1",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -49,7 +49,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.75.0"
+    "@telorun/sdk": "0.77.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"