@telorun/kernel 0.75.0 → 0.77.0

package/src/kernel.ts

@@ -49,6 +49,7 @@ import { ambientInvokeContext } from "./evaluation-context.js";
 import { ModuleContext } from "./module-context.js";
 import { ResourceContextImpl } from "./resource-context.js";
 import { mintResourceHandle } from "./resource-handle.js";
+import { nodeHostVersions } from "./host-versions.js";
 import { nodeCelHandlers } from "./cel-handlers.js";
 import { parseRef, seedInvokeSource } from "./invoke-dispatch.js";
 import { stripCompiledValues } from "./schema-compiled-values.js";
@@ -64,12 +65,17 @@ import {
   resolveCacheRoot,
   resolveEntryDir,
 } from "./manifest-sources/local-manifest-cache-source.js";
-import { readOwnerManifest } from "./bundle/module-manifest.js";
+import { readOwnerManifest, type OwnerManifest } from "./bundle/module-manifest.js";
 import {
   moduleArtifactFor,
   moduleDirectoryFor,
   type ModuleArtifact,
 } from "./bundle/module-artifact.js";
+import {
+  NO_SIBLING_LIBRARIES,
+  buildSiblingLibraries,
+  type SiblingLibraryMap,
+} from "./controller-loaders/sibling-libraries.js";
 import { defaultTransportRegistry } from "./transports/transport-registry.js";
 import {
   collectDeclaredEnvKeys,
@@ -159,6 +165,10 @@ export class Kernel implements IKernel {
   /** Per-module artifact handles, keyed by canonical manifest source. Rebuilt on
    *  every `load()`; empty for a graph of purely local / manifest-only modules. */
   private readonly moduleArtifacts = new Map<string, ModuleArtifact>();
+  /** Per-module sibling-library resolution, keyed by the same canonical manifest
+   *  source: which bare specifiers this module's controller bundles import, and
+   *  which module's library layer each resolves to. Rebuilt on every `load()`. */
+  private readonly siblingLibraries = new Map<string, SiblingLibraryMap>();
   private _loadedGraph?: LoadedGraph;
   // Lifecycle state — guards boot/runTargets/teardown/invoke transitions.
   // teardown() is the only idempotent method; everything else throws on misuse.
@@ -547,7 +557,11 @@ export class Kernel implements IKernel {
       // Imported libraries' full documents, for the zone stage's per-library
       // export derivation: `flattenForAnalyzer` forwards only each library's
       // export surface, never its internal dispatch chain.
-      { skipValidation, moduleDocuments: collectZoneModuleDocuments(analysisGraph) },
+      {
+        skipValidation,
+        moduleDocuments: collectZoneModuleDocuments(analysisGraph),
+        hostVersions: nodeHostVersions(),
+      },
       this.registry,
     );
     if (errors.length > 0) {
@@ -1014,7 +1028,9 @@ export class Kernel implements IKernel {
   }
 
   /**
-   * Build one {@link ModuleArtifact} per loaded module that ships a payload.
+   * Read every loaded module's owner manifest once, and build from it the two
+   * things a controller resolution needs: the module's artifact, and the sibling
+   * libraries its bundles import by bare specifier.
    *
    * Here, and not inside a controller loader, because this is the only point
    * where both halves are in hand: the **pinned** ref the importer wrote
@@ -1038,26 +1054,48 @@ export class Kernel implements IKernel {
    */
   private buildModuleArtifacts(graph: LoadedGraph, manifestsDir: string | undefined): void {
     this.moduleArtifacts.clear();
+    this.siblingLibraries.clear();
     const transports = defaultTransportRegistry(this.registryUrl);
     const entryDir = this._entryUrl ? resolveEntryDir(this._entryUrl) ?? "" : "";
+    // Parsed once per module and shared with the sibling-library join below: a
+    // `telo.yaml` is a large multi-document file, and re-reading each target's
+    // once per import edge put dozens of redundant full-YAML parses on the boot
+    // path of every standard-library app.
+    const owners = new Map<string, OwnerManifest>();
+    const directories = new Map<string, string | undefined>();
     for (const [, module] of graph.modules) {
       const file = module.owner;
-      if (this.moduleArtifacts.has(file.source)) continue;
+      if (owners.has(file.source)) continue;
+      const owner = readOwnerManifest(file.text);
+      owners.set(file.source, owner);
+      const moduleDir = moduleDirectoryFor(
+        file.requestedUrl,
+        file.source,
+        entryDir,
+        this.registryUrl,
+        manifestsDir,
+      );
+      directories.set(file.source, moduleDir ?? undefined);
       const artifact = moduleArtifactFor({
         pinnedRef: file.requestedUrl,
-        layers: readOwnerManifest(file.text).layers,
-        moduleDir: moduleDirectoryFor(
-          file.requestedUrl,
-          file.source,
-          entryDir,
-          this.registryUrl,
-          manifestsDir,
-        ),
+        layers: owner.layers,
+        moduleDir,
         transports,
         log: this.logging.kernelLogger(),
       });
       if (artifact) this.moduleArtifacts.set(file.source, artifact);
     }
+
+    // The sibling-library join is a pure function of the graph and these three
+    // lookups; it lives beside the model it produces (`sibling-libraries.ts`).
+    for (const [source, map] of buildSiblingLibraries(graph, {
+      ownerManifests: owners,
+      artifactFor: (source) => this.moduleArtifacts.get(source),
+      directoryFor: (source) => directories.get(source),
+      log: this.logging.kernelLogger(),
+    })) {
+      this.siblingLibraries.set(source, map);
+    }
   }
 
   /** The artifact of the module whose manifest resolved from `source`, or
@@ -1067,6 +1105,12 @@ export class Kernel implements IKernel {
     return source ? this.moduleArtifacts.get(source) : undefined;
   }
 
+  /** The module-owned libraries the module at `source` imports by bare
+   *  specifier. Empty for a module that imports none. */
+  getSiblingLibraries(source: string | undefined): SiblingLibraryMap {
+    return (source ? this.siblingLibraries.get(source) : undefined) ?? NO_SIBLING_LIBRARIES;
+  }
+
   /** Authored `kind` of a declared resource by name, from the static manifest
    *  set. Init-order-independent (unlike `resourceInstances`), so a controller
    *  resolving a `!ref <name>` sentinel before the target initializes can still

package/src/manifest-schemas.ts

@@ -1,7 +1,9 @@
 import AjvModule from "ajv";
 import addFormats from "ajv-formats";
-// One definition of the `status:` block's shape, shared with `telo check` — the
-// `required:` restriction is reported by the analyzer, which can name the fix.
+// The loader's shape check for a `status:` block. `telo check` narrows it
+// further through the `JsonSchema7` fragment, which can name the offending
+// keyword and its line; keeping this permissive is what stops a sloppy keyword
+// in an already-published manifest from becoming a boot failure.
 import { OBSERVED_STATE_SCHEMA, registerTeloKeywords } from "@telorun/analyzer";
 const Ajv = AjvModule.default ?? AjvModule;
 
@@ -12,11 +14,15 @@ const Ajv = AjvModule.default ?? AjvModule;
 // only at runtime, invisible to `telo check` and to the editor.
 export {
   InvokeStepSchema,
+  isSchemaFragment,
+  JsonSchema7Schema,
+  KindSchemaSchema,
   MANIFEST_SCHEMA_URI,
   ManifestRootSchema,
   manifestFragmentRef,
   ResourceRefSchema,
   RetryPolicySchema,
+  withSchemaFragments,
 } from "@telorun/analyzer";
 
 const metadataSchema = {

package/src/manifest-sources/local-manifest-cache-source.ts

@@ -179,13 +179,29 @@ export async function writeManifestCache(
   return written;
 }
 
+/** Matches a URL scheme, as distinct from a Windows drive letter. `D:\src`
+ *  satisfies RFC 3986's scheme grammar, so the second character is required:
+ *  no registered scheme is one letter, and every drive is. */
+const URL_SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]+:/;
+
 /** Resolve the entry-anchor directory for the manifest cache.
  *
  * For a file path or `file://` URL: returns the containing directory.
  * For a directory path: returns the directory itself.
- * For an HTTP(S) URL: returns `null` (no local anchor; cache writes skipped). */
+ * For ANY other scheme: returns `null` (no local anchor; cache writes skipped).
+ *
+ * The rule is the scheme, not a list of known ones. Testing only for http(s)
+ * left every other scheme falling through to `path.resolve`, which reads it as
+ * a relative path: a `memory://app/telo.yaml` entry anchored its cache at
+ * `<cwd>/memory:/app/.telo`. On POSIX that is a legal directory name, so the
+ * kernel silently created one inside whatever directory it was run from and the
+ * cache appeared to work; on Windows `:` is illegal in a filename, so the same
+ * load failed at `mkdir`. A transient source has no local anchor by
+ * construction — that is what the whole-scheme test says, and it now covers
+ * `oci://` and any scheme added later without another edit here. */
 export function resolveEntryDir(entryPath: string): string | null {
-  if (entryPath.startsWith("http://") || entryPath.startsWith("https://")) {
+  const scheme = URL_SCHEME.exec(entryPath)?.[0];
+  if (scheme !== undefined && scheme !== "file:") {
     return null;
   }
   let absolute: string;
@@ -208,7 +224,8 @@ export function resolveEntryDir(entryPath: string): string | null {
  *
  *  `TELO_CACHE_DIR` (the relocated root a prebuilt image bakes its deps into)
  *  wins; otherwise the root sits beside the entry at `<entry-dir>/.telo`.
- *  Returns `null` for http(s) entries with no local anchor (disk cache skipped).
+ *  Returns `null` for an entry with no local anchor — an http(s), `memory://`
+ *  or any other non-`file:` scheme — in which case the disk cache is skipped.
  *  Consumers append the conventional subdirs: `manifests/`, `manifests/__validators/`,
  *  `npm/`. */
 export function resolveCacheRoot(entryPath: string): string | null {

package/src/resource-context.ts

@@ -35,6 +35,7 @@ import * as path from "path";
 import { pathToFileURL } from "url";
 import { withBigIntsAsNumbers } from "./bigint-schema-view.js";
 import type { ModuleArtifact } from "./bundle/module-artifact.js";
+import type { SiblingLibraryMap } from "./controller-loaders/sibling-libraries.js";
 import { resolveModuleFileUri } from "./module-file-resolution.js";
 import { hostEnv } from "./host-env.js";
 import type { LoggingHost } from "./logging/logging-host.js";
@@ -781,6 +782,13 @@ export class ResourceContextImpl implements ResourceContext {
     return this.kernel.getModuleArtifact(source);
   }
 
+  /** The module-owned libraries the module at `source` imports by bare specifier
+   *  — how a controller bundle's `@telorun/kv-store` finds the module that owns
+   *  it. Kernel-only, on the same seam as {@link getModuleArtifact}. */
+  getSiblingLibraries(source: string | undefined): SiblingLibraryMap {
+    return this.kernel.getSiblingLibraries(source);
+  }
+
   /**
    * Resolve a module-relative reference against the declaring module's own
    * directory, materializing the layers that could carry it on first use.

package/src/runtime-seam.ts

@@ -22,6 +22,7 @@ import {
   type RuntimeSeam,
 } from "@telorun/sdk";
 import { Writable } from "stream";
+import { nodeHostVersions } from "./host-versions.js";
 import { nodeCelHandlers } from "./cel-handlers.js";
 import type { Kernel } from "./kernel.js";
 import { defaultTransportRegistry } from "./transports/transport-registry.js";
@@ -285,6 +286,7 @@ export class KernelRuntimeSeam implements RuntimeSeam {
     // nothing was migrated.
     const analysis = new StaticAnalyzer({ celHandlers: nodeCelHandlers }).analyze(manifests, {
       moduleDocuments,
+      hostVersions: nodeHostVersions(),
     });
     const diagnostics = remapMigratedPaths(loadedGraph, analysis);
     return {