Repository navigation
Telo v0.119.0
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.checkthat readloadErroron an import failure. The seam now answers with exactly the diagnosticstelo checkreports — built by the same assembler, with the same codes, messages and locations (line/columnset wherevertelo checklocates one) — so a failed import is its coded diagnostic atimports.<alias>(INVALID_IMPORT_SOURCE,IMPORT_UNRESOLVED,INVALID_IMPORT_TARGET,KIND_PREFIX_RESERVED), andloadErroris 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 asloadError, 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_TARGETorERR_KIND_PREFIX_RESERVED(a loader error carrying a code of its own keeps it), sotelo runprints theimports:linetelo checkprints 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 isERR_INVALID_IMPORT_TARGETin both kernels (it wasERR_MANIFEST_VALIDATION_FAILED). ATelo.Importdeclared in awith: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 isERR_IMPORT_UNRESOLVEDand a malformed oneERR_INVALID_IMPORT_SOURCE(both were the bare loader error), an application target isERR_INVALID_IMPORT_TARGETin the loader's words (it wasERR_MANIFEST_VALIDATION_FAILED), and so is a target with noTelo.Library(it was an uncoded error).@telorun/analyzerexports that step,loadImportTarget, andimportFailureDiagnosticsfor 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 spuriousrestartRequiredafter the edit was reverted. - Breaking for a consumer of
@telorun/ide-support's diagnostic assembly:assembleGraphDiagnostics,compromisedFiles,findPositionsandresolveRangemoved to@telorun/analyzer, which also exportslocateDiagnostic(a diagnostic's file and range, as every host reports it).@telorun/ide-supportno 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