Skip to content

Telo v0.119.0

Choose a tag to compare

@github-actions github-actions released this 18 Oct 15:26
63c81d0

Packages

Package Version
@telorun/cli 0.119.0
@telorun/analyzer 0.119.0
@telorun/cel 0.119.0
@telorun/ide-support 0.119.0
@telorun/kernel 0.119.0
@telorun/language-server 0.119.0
@telorun/sdk 0.119.0
@telorun/templating 0.119.0

Minor

The built-in vocabulary of a release is a document you can read. Every telo release renders it as a Telo.Builtins YAML stream (kernel/specs/builtin-vocabulary.md): a root carrying every shared schema fragment, value type, zone attribute and string format, then one document per built-in kind in its authored form. @telorun/analyzer ships it as src/builtin-vocabulary/builtins.yaml, with its MIT LICENSE beside it, exports the same bytes as BUILTIN_VOCABULARY_ARCHIVE, and refuses to pack unless the archive carries exactly the package's version. telo builtins prints it, and telo builtins Application Step Telo.Url prints only those entries; an unknown name exits 1 listing every name there is. @telorun/analyzer also exports the archive's reader (readBuiltinVocabulary) and the selection both CLIs print with (selectBuiltins, builtinVocabularyEntries). — cli, analyzer, kernel

The archive is read, never run, declared or imported: as the entry of telo check / telo run it is one UNDEFINED_KIND saying what it is, and an import of it is INVALID_IMPORT_TARGET telling you its kinds need no import. telo publish accepts a Telo.Builtins root as a manifest-only artifact — no module analysis runs, the archive's own reader refuses a malformed one, and the published telo.yaml is the archive's bytes with only the layers: index appended — and telo module manifest --json reports one with runtime: null and application: null. Every release is published as oci://ghcr.io/telorun/telo@<version>.

Telo and Self are reserved: a module named either, an import aliased either, and an import reaching a library named either are refused as KIND_PREFIX_RESERVED by telo check and ERR_KIND_PREFIX_RESERVED by both kernels. This is a breaking change: a library named Telo used to be accepted and silently replaced the built-in definitions.

A failed import is reported the same way by telo check, by ctx.runtime.check and by a run. — cli, analyzer, ide-support, kernel, language-server, sdk

  • Breaking for a caller of ctx.runtime.check that read loadError on an import failure. The seam now answers with exactly the diagnostics telo check reports — built by the same assembler, with the same codes, messages and locations (line / column set wherever telo check locates one) — so a failed import is its coded diagnostic at imports.<alias> (INVALID_IMPORT_SOURCE, IMPORT_UNRESOLVED, INVALID_IMPORT_TARGET, KIND_PREFIX_RESERVED), and loadError is set only when the graph could not be loaded at all (an unreadable entry, a refused partial). It used to stop at the first failed import and return its loader message as loadError, and to stop at a parse failure before analysing the rest.
  • A run refused for a failed import carries every import's static diagnostic under ERR_INVALID_IMPORT_SOURCE, ERR_IMPORT_UNRESOLVED, ERR_INVALID_IMPORT_TARGET or ERR_KIND_PREFIX_RESERVED (a loader error carrying a code of its own keeps it), so telo run prints the imports: line telo check prints and a refused child writes [<CODE>] <message> for it. The Node kernel used to raise the loader's bare error for every import failure but a reserved prefix. An import of the built-in vocabulary archive is ERR_INVALID_IMPORT_TARGET in both kernels (it was ERR_MANIFEST_VALIDATION_FAILED). A Telo.Import declared in a with: scope is loaded, when its scope opens, by the same per-import step the graph walk runs and refused the same way: an unresolvable source is ERR_IMPORT_UNRESOLVED and a malformed one ERR_INVALID_IMPORT_SOURCE (both were the bare loader error), an application target is ERR_INVALID_IMPORT_TARGET in the loader's words (it was ERR_MANIFEST_VALIDATION_FAILED), and so is a target with no Telo.Library (it was an uncoded error). @telorun/analyzer exports that step, loadImportTarget, and importFailureDiagnostics for it.
  • A failed Kernel.reconcile() leaves the kernel as it was. A reconcile refused while loading (a failed import, a parse failure) used to keep the refused graph, so the next reconcile diffed against it — missing a library edit, or reporting a spurious restartRequired after the edit was reverted.
  • Breaking for a consumer of @telorun/ide-support's diagnostic assembly: assembleGraphDiagnostics, compromisedFiles, findPositions and resolveRange moved to @telorun/analyzer, which also exports locateDiagnostic (a diagnostic's file and range, as every host reports it). @telorun/ide-support no longer exports them.

telo module manifest --json reports a need type's runtime reach. A Telo.NeedType declares a kind the kernel serves with its own need-type controller, and runtime.kinds now lists it as the kernels that register that controller — { runtimes: [nodejs], languages: [], portable: false } today — where it used to be missing, so the hub stored every need type as runnable by no kernel and a runtime filter hid it. Which documents declare a kind is read through the analyzer's kindDeclarationOf, and a kernel candidate { runtime: kernel, entry } is hosted by exactly the kernels registering entry: @telorun/kernel exports the entries it registers at boot as BUILTIN_CONTROLLER_ENTRIES, the keys of the one table it registers its built-in controllers from. A Telo.Builtins root still reports runtime: null. — cli, kernel

The built-in vocabulary is data, and the capability roster is closed. Every Telo.* kind — the module, definition, import and need-type documents, the sinks, Telo.JsonSchema, Telo.Function, the capability abstracts, Telo.PublicUrl / Telo.PublicHostPattern — and every telo://manifest#/$defs fragment is one JSON file under sdk/builtins/, read by both analyzers, both kernels and the editor support; the format entries move from analyzer/formats/ to sdk/formats/. Shapes two built-ins share are fragments a module may point at too (LogLevel, LoggingScope, ModuleMetadata, ModuleImports, NativeEntries, PlatformAxes, NeedRequest, ThrowCodes, CallableParams, CallableReturns, CallableType, DispatchTarget, KindMetadata, …). — analyzer, ide-support, kernel

Telo.Definition and Telo.Abstract documents are validated against one built-in schema by telo check and the kernel alike, so a key neither declares (controllrs:) is SCHEMA_VIOLATION and ERR_RESOURCE_SCHEMA_VALIDATION_FAILED rather than passing the check and failing at boot. A capability names a lifecycle a kernel implements, so no module adds one: capability: takes exactly Telo.Callable, Telo.Invocable, Telo.Mount, Telo.Provider, Telo.Runnable, Telo.Service, Telo.Sink or Telo.Type. Anything else is CAPABILITY_UNKNOWN — with the nearest role suggested for a misspelling, and extends: named for a built-in kind that is no role — and Telo.Executable / Telo.Template are CAPABILITY_NOT_DECLARABLE; both are reported for a dependency's definition at the entry's imports: entry through which the dependency is first reached, however deep, and both kernels refuse with the ERR_-prefixed twins before the document's schema is checked. This is a breaking change: a capability a third party invented, which the Node kernel used to accept, is refused. It is breaking a second way: an abstract's schema: and status: are now held to JSON Schema like a definition's, so an abstract's malformed schema: / status: — a keyword JSON Schema refuses — is SCHEMA_VIOLATION at telo check and ERR_RESOURCE_SCHEMA_VALIDATION_FAILED at boot, where the kernel used to accept it. A Telo.Definition / Telo.Abstract declared as a with: scope member is judged by telo check too — its capability: against the roster and the document against its built-in schema, at the member's own line, or for a dependency's at that same imports: entry — so a load refuses it before the scope that would create it ever opens.

The legacy capability: <Alias>.<Kind>, naming a module's kind, is rewritten to extends: at load by the capability-as-extends migration and reported as CAPABILITY_SHADOWS_EXTENDS; telo migrate writes it to the file. A migrated kind is checked as the child it claimed to be — its parent's schema, invocation contract and throws ceiling now apply, so a published dependency that violated its abstract's contract fails where it was skipped. Migration entries gain valuePattern / valueNotPattern, written in the RE2 subset; an entry using lookaround or a backreference is refused. Capability completion and hover offer exactly the declarable roles, each with its roster description. @telorun/analyzer exports the roster readers (capabilityRoster, declarableCapabilities, throwsAllowedCapabilities, capabilityProblem, capabilityDescription, isCapabilityRole, builtinKindNames) and builtinDocumentSchema, and no longer exports THROWS_SCHEMA, ABSTRACT_THROWS_SCHEMA, THROWS_CAPABLE_CAPABILITIES or OBSERVED_STATE_SCHEMA.

Patch

telo --version prints the telo identity: X for a release, and X+unreleased for a build made from a working copy while X is pending — the string a run's Kernel.Starting event and telo builtins' root metadata.version carry. It used to print the CLI package's number, which on a working copy named a release the build is not (0.118.0 where the archive said 0.119.0+unreleased). A release prints the same X as before. The Rust telo gains --version too, printing the same string, read from the built-in vocabulary it embeds. — cli

A child manifest started through ctx.runtime.run that is refused — at load or before it finishes starting — now writes every diagnostic its failure carries to its stderr, after the unchanged headline: one [<CODE>] <message> line each, a diagnostic's details beneath it, an import's nested root causes one level further in, and entries that failed only because another did left out. A refusal by the load's analysis used to write Manifest validation failed alone, so Test.Suite, App.Instance and Assert.Manifest could show — and a runFails: could match — nothing about its cause. The form is documented on RuntimeSeam.run and in the controller protocol spec (§9.2) as what every kernel writes for a refused child. — kernel, sdk


Changelogs: cli · analyzer · cel · ide-support · kernel · language-server · sdk · templating