@telorun/kernel 0.87.0 → 0.89.0

package/src/kernel.ts

@@ -7,6 +7,7 @@ import {
   diffManifests,
   flattenForAnalyzer,
   flattenLoadedModule,
+  implicitEvalSites,
   isModuleKind,
   nodeIdFor,
   Loader,
@@ -1022,7 +1023,26 @@ export class Kernel implements IKernel {
         );
         if (manifest.kind === "Telo.Application") {
           rootApplicationManifest = manifest;
-          this._appName = (manifest.metadata as { name?: string } | undefined)?.name;
+          const appName = (manifest.metadata as { name?: string } | undefined)?.name;
+          this._appName = appName;
+          // `Self` names the declaring module's own kinds, ungated — the import
+          // controller registers it for every imported library, and the
+          // analyzer registers it for a root module too. Without the kernel's
+          // half a root Application declaring its own `Telo.Definition` and
+          // instantiating it as `kind: Self.<Kind>` passed `telo check` and
+          // failed at boot with "no module imported with alias 'Self'".
+          //
+          // The module's OWN NAME resolves the same kinds, for the same reason
+          // it needs no import: `<module>.<Kind>` IS the canonical identity the
+          // registry keys on and every diagnostic prints, so an author reading
+          // one copies that spelling back into the manifest. The analyzer
+          // resolves it (it is canonical, not an alias), the kernel did not, and
+          // the gap passed `telo check` and failed at boot with "no module
+          // imported with alias '<name>'".
+          if (appName) {
+            this.rootContext.registerUngatedAlias("Self", appName);
+            this.rootContext.registerUngatedAlias(appName, appName);
+          }
         }
       }
       this.rootContext.registerManifest(manifest);
@@ -1671,7 +1691,11 @@ export class Kernel implements IKernel {
     const ownEval = definition?.schema
       ? buildEvalPaths(definition.schema)
       : { compile: [], runtime: [] };
-    const compile = [...parentEval.compile, ...ownEval.compile];
+    // A base-form child's own fields are construction inputs read once by
+    // `base:`, so they are compile-eval without annotation — the rule is the
+    // analyzer's, shared so `telo check` and dispatch agree on it.
+    const implicitEval = implicitEvalSites(definition);
+    const compile = [...parentEval.compile, ...ownEval.compile, ...implicitEval.compile];
     const runtime = [...parentEval.runtime, ...ownEval.runtime];
 
     // Embedded files are read here, at the single instance-production site, and

package/src/manifest-schemas.ts

@@ -118,41 +118,40 @@ const KNOWN_CAPABILITIES = [
 /** Rule 8: `throws:` is only meaningful on Telo.Invocable or Telo.Runnable.
  *  On Service/Mount/Provider/Type/etc. a thrown error is a boot-time failure,
  *  not a structured runtime error for a downstream caller, so declaring one
- *  is a schema error. */
-const forbidThrows = { not: { required: ["throws"] } };
+ *  is a schema error.
+ *
+ *  Spelled as a `false` schema at the property rather than `not: {required}` so
+ *  the failure NAMES THE KEY: AJV reports `not` at the document root with
+ *  nothing about the inner schema, which left the whole union unable to say
+ *  which key was at fault — and the reducer then preferred a branch whose
+ *  `capability` const merely disagreed, reporting `/capability must be equal to
+ *  constant` about a document whose capability was right and whose `throws:` was
+ *  wrong. This form reports `/throws is not allowed here`. */
+/** One capability's branch. `throws` and `capability` live in ONE `properties`
+ *  map, built here — spreading a second object carrying `properties` silently
+ *  REPLACES the capability constant, which turns every forbidding branch into
+ *  "any definition with a capability and no throws" and makes the whole `oneOf`
+ *  match several branches at once. */
+const capabilityBranch = (capability: string, mayThrow: boolean) => ({
+  required: ["capability"],
+  properties: {
+    capability: { const: capability },
+    ...(mayThrow ? {} : { throws: false }),
+  },
+});
 
 export const ResourceDefinitionSchema = {
   ...baseDefinition,
   oneOf: [
-    {
-      required: ["capability"],
-      properties: { capability: { const: "Telo.Service" } },
-      ...forbidThrows,
-    },
-    { required: ["capability"], properties: { capability: { const: "Telo.Runnable" } } },
-    { required: ["capability"], properties: { capability: { const: "Telo.Invocable" } } },
-    {
-      required: ["capability"],
-      properties: { capability: { const: "Telo.Provider" } },
-      ...forbidThrows,
-    },
-    {
-      required: ["capability"],
-      properties: { capability: { const: "Telo.Type" } },
-      ...forbidThrows,
-    },
-    {
-      required: ["capability"],
-      properties: { capability: { const: "Telo.Mount" } },
-      ...forbidThrows,
-    },
-    {
-      // A sink is written to directly, never dispatched, so a thrown error is a
-      // boot-time failure rather than a structured runtime error for a caller.
-      required: ["capability"],
-      properties: { capability: { const: "Telo.Sink" } },
-      ...forbidThrows,
-    },
+    capabilityBranch("Telo.Service", false),
+    capabilityBranch("Telo.Runnable", true),
+    capabilityBranch("Telo.Invocable", true),
+    capabilityBranch("Telo.Provider", false),
+    capabilityBranch("Telo.Type", false),
+    capabilityBranch("Telo.Mount", false),
+    // A sink is written to directly, never dispatched, so a thrown error is a
+    // boot-time failure rather than a structured runtime error for a caller.
+    capabilityBranch("Telo.Sink", false),
     // Unknown/absent capability: open schema for third-party extensibility
     {
       not: {