@telorun/analyzer 0.11.0 → 1.2.0

package/dist/validate-references.js

@@ -1,4 +1,4 @@
-import { isRefEntry, isScopeEntry, isSchemaFromEntry, isInlineResource, resolveFieldValues } from "./reference-field-map.js";
+import { isRefEntry, isScopeEntry, isSchemaFromEntry, isInlineResource, resolveFieldEntries, resolveFieldValues } from "./reference-field-map.js";
 import { navigateJsonPointer } from "./schema-compat.js";
 import { DiagnosticSeverity } from "./types.js";
 const SOURCE = "telo-analyzer";
@@ -119,7 +119,7 @@ export function validateReferences(resources, context) {
                     }
                 }
             }
-            for (const val of resolveFieldValues(r, fieldPath)) {
+            for (const { value: val, path: concretePath } of resolveFieldEntries(r, fieldPath)) {
                 if (!val)
                     continue;
                 // Name-only reference (plain string) — look up by name to validate.
@@ -142,8 +142,8 @@ export function validateReferences(resources, context) {
                             severity: DiagnosticSeverity.Error,
                             code: "UNRESOLVED_REFERENCE",
                             source: SOURCE,
-                            message: `${resourceLabel}: reference at '${fieldPath}' → resource '${val}' not found`,
-                            data: { resource: resourceData, filePath, path: fieldPath },
+                            message: `${resourceLabel}: reference at '${concretePath}' → resource '${val}' not found`,
+                            data: { resource: resourceData, filePath, path: concretePath },
                         });
                         continue;
                     }
@@ -153,8 +153,8 @@ export function validateReferences(resources, context) {
                             severity: DiagnosticSeverity.Error,
                             code: "REFERENCE_KIND_MISMATCH",
                             source: SOURCE,
-                            message: `${resourceLabel}: reference at '${fieldPath}' → ${kindErrors.join("; ")}`,
-                            data: { resource: resourceData, filePath, path: fieldPath },
+                            message: `${resourceLabel}: reference at '${concretePath}' → ${kindErrors.join("; ")}`,
+                            data: { resource: resourceData, filePath, path: concretePath },
                         });
                     }
                     continue;
@@ -171,8 +171,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "INVALID_REFERENCE",
                         source: SOURCE,
-                        message: `${resourceLabel}: reference at '${fieldPath}' must have string 'kind' and 'name' fields`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: reference at '${concretePath}' must have string 'kind' and 'name' fields`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                     continue;
                 }
@@ -183,8 +183,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "REFERENCE_KIND_MISMATCH",
                         source: SOURCE,
-                        message: `${resourceLabel}: reference at '${fieldPath}' → ${kindErrors.join("; ")}`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: reference at '${concretePath}' → ${kindErrors.join("; ")}`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                 }
                 // 3. Resolution check — resource with this name must exist.
@@ -195,8 +195,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "UNRESOLVED_REFERENCE",
                         source: SOURCE,
-                        message: `${resourceLabel}: reference at '${fieldPath}' → resource '${refVal.name}' not found`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: reference at '${concretePath}' → resource '${refVal.name}' not found`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                 }
             }
@@ -279,7 +279,7 @@ export function validateReferences(resources, context) {
                     });
                     continue;
                 }
-                for (const fieldValue of resolveFieldValues(r, fieldPath)) {
+                for (const { value: fieldValue, path: concretePath } of resolveFieldEntries(r, fieldPath)) {
                     if (fieldValue == null)
                         continue;
                     const issues = registry.validateWithRefs(fieldValue, subSchema);
@@ -288,8 +288,8 @@ export function validateReferences(resources, context) {
                             severity: DiagnosticSeverity.Error,
                             code: "DEPENDENT_SCHEMA_MISMATCH",
                             source: SOURCE,
-                            message: `${resourceLabel}: '${fieldPath}' does not match schema from '${anchorName}${jsonPointer}': ${issue}`,
-                            data: { resource: resourceData, filePath, path: fieldPath },
+                            message: `${resourceLabel}: '${concretePath}' does not match schema from '${anchorName}${jsonPointer}': ${issue}`,
+                            data: { resource: resourceData, filePath, path: concretePath },
                         });
                     }
                 }
@@ -309,9 +309,9 @@ export function validateReferences(resources, context) {
             const anchorValues = resolveFieldValues(r, anchorPath);
             if (anchorValues.length === 0)
                 continue; // anchor field not set — nothing to validate
-            const fieldValues = resolveFieldValues(r, fieldPath);
-            for (let i = 0; i < fieldValues.length; i++) {
-                const fieldValue = fieldValues[i];
+            const fieldEntries = resolveFieldEntries(r, fieldPath);
+            for (let i = 0; i < fieldEntries.length; i++) {
+                const { value: fieldValue, path: concretePath } = fieldEntries[i];
                 if (fieldValue == null)
                     continue;
                 // For absolute paths, the single anchor applies to all field values.
@@ -328,8 +328,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "SCHEMA_FROM_MISSING_PATH",
                         source: SOURCE,
-                        message: `${resourceLabel}: x-telo-schema-from at '${fieldPath}' → kind '${refVal.kind}' has no schema`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: x-telo-schema-from at '${concretePath}' → kind '${refVal.kind}' has no schema`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                     continue;
                 }
@@ -339,8 +339,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "SCHEMA_FROM_MISSING_PATH",
                         source: SOURCE,
-                        message: `${resourceLabel}: x-telo-schema-from at '${fieldPath}' → kind '${refVal.kind}' has no schema path '${jsonPointer}'`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: x-telo-schema-from at '${concretePath}' → kind '${refVal.kind}' has no schema path '${jsonPointer}'`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                     continue;
                 }
@@ -350,8 +350,8 @@ export function validateReferences(resources, context) {
                         severity: DiagnosticSeverity.Error,
                         code: "DEPENDENT_SCHEMA_MISMATCH",
                         source: SOURCE,
-                        message: `${resourceLabel}: '${fieldPath}' does not match schema from '${refVal.kind}${jsonPointer}': ${issue}`,
-                        data: { resource: resourceData, filePath, path: fieldPath },
+                        message: `${resourceLabel}: '${concretePath}' does not match schema from '${refVal.kind}${jsonPointer}': ${issue}`,
+                        data: { resource: resourceData, filePath, path: concretePath },
                     });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.11.0",
+  "version": "1.2.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -29,7 +29,8 @@
       "bun": "./src/index.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist/**",
@@ -41,14 +42,16 @@
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
     "yaml": "^2.8.3",
-    "@telorun/sdk": "0.11.1",
-    "@telorun/templating": "0.2.3"
+    "@telorun/templating": "1.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8"
   },
+  "peerDependencies": {
+    "@telorun/sdk": "1.0.0"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.lib.json",
     "test": "vitest run",

package/src/analysis-registry.ts

@@ -101,6 +101,43 @@ export class AnalysisRegistry {
     return computeSuggestKind(badKind, this.aliases, this.defs);
   }
 
+  /** Returns every user-facing (alias-form) kind that satisfies the given
+   *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
+   *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to
+   *  the set of definitions extending them; concrete targets yield just themselves.
+   *  Returns `undefined` when the ref can't be resolved (e.g. unregistered identity),
+   *  so callers can fall back to the unfiltered kind list. */
+  userFacingKindsForRef(xTeloRef: string): string[] | undefined {
+    const targetKind = this.defs.resolveRef(xTeloRef);
+    if (!targetKind) return undefined;
+    const targetDef = this.defs.resolve(targetKind);
+    if (!targetDef) return undefined;
+
+    const canonicalKinds: string[] = [];
+    if (targetDef.kind === "Telo.Abstract") {
+      for (const def of this.defs.getByExtends(targetKind)) {
+        const module = (def.metadata as { module?: string } | undefined)?.module;
+        if (module && def.metadata?.name) {
+          canonicalKinds.push(`${module}.${def.metadata.name as string}`);
+        }
+      }
+    } else {
+      canonicalKinds.push(targetKind);
+    }
+
+    const out = new Set<string>();
+    for (const kind of canonicalKinds) {
+      const dot = kind.indexOf(".");
+      if (dot === -1) continue;
+      const moduleName = kind.slice(0, dot);
+      const typeName = kind.slice(dot + 1);
+      for (const alias of this.aliases.aliasesFor(moduleName)) {
+        out.add(`${alias}.${typeName}`);
+      }
+    }
+    return Array.from(out);
+  }
+
   /** @internal Bridge for StaticAnalyzer — do not use outside the analyzer package. */
   _context(): AnalysisContext {
     return { aliases: this.aliases, definitions: this.defs, aliasesByModule: this.aliasesByModule };

package/src/analyzer.ts

@@ -14,6 +14,7 @@ import { buildKernelGlobalsSchema, mergeKernelGlobalsIntoContext } from "./kerne
 import { computeSuggestKind } from "./kind-suggest.js";
 import { isModuleKind } from "./module-kinds.js";
 import { normalizeInlineResources } from "./normalize-inline-resources.js";
+import { rewriteSyntheticOrigins } from "./rewrite-synthetic-origins.js";
 import {
   celTypeSatisfiesJsonSchema,
   substituteCelFields,
@@ -28,6 +29,7 @@ import {
   resolveTypeFieldToSchema,
 } from "./validate-cel-context.js";
 import { validateExtends } from "./validate-extends.js";
+import { validateProviderCoherence } from "./validate-provider-coherence.js";
 import { validateReferences } from "./validate-references.js";
 import { validateThrowsCoverage } from "./validate-throws-coverage.js";
 
@@ -621,6 +623,16 @@ export class StaticAnalyzer {
     // Phase 2: extract inline resources from x-telo-ref slots into first-class manifests
     const allManifests = normalizeInlineResources(manifests, defs, aliases, aliasesByModule);
 
+    // Trusted-input fast path: when the caller has already attested that
+    // this exact manifest set passes analysis (e.g. via the kernel's
+    // hash-stamped `.validated.json` cache), skip the validation walk.
+    // Registration of identities / aliases / definitions and inline-resource
+    // normalisation have already run above; that's all downstream
+    // consumers (prepare, init loop) require.
+    if (options?.skipValidation) {
+      return diagnostics;
+    }
+
     // Build a name→manifest map for looking up referenced resources
     const byName = new Map<string, ResourceManifest>();
     for (const m of allManifests) {
@@ -629,6 +641,35 @@ export class StaticAnalyzer {
       }
     }
 
+    // Library env: rejection — `env:` on a Library `variables` / `secrets`
+    // entry is forbidden. The Library entry schema is otherwise open so that
+    // any JSON Schema property schema is valid; this targeted check produces
+    // a clear diagnostic instead of a generic "additional property" error.
+    for (const m of allManifests) {
+      if (m.kind !== "Telo.Library") continue;
+      const filePath = (m.metadata as { source?: string } | undefined)?.source;
+      const moduleName = m.metadata?.name as string | undefined;
+      const resource = moduleName ? { kind: m.kind, name: moduleName } : undefined;
+      for (const block of ["variables", "secrets"] as const) {
+        const entries = (m as Record<string, any>)[block];
+        if (!entries || typeof entries !== "object" || Array.isArray(entries)) continue;
+        for (const [entryName, entry] of Object.entries(entries)) {
+          if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+          if ("env" in (entry as Record<string, unknown>)) {
+            diagnostics.push({
+              severity: DiagnosticSeverity.Error,
+              code: "LIBRARY_ENV_KEY_REJECTED",
+              source: SOURCE,
+              message:
+                `Telo.Library ${block}/${entryName}: 'env:' is only permitted on Telo.Application entries. ` +
+                `Libraries must receive values from importers via the parent manifest's variables / secrets block.`,
+              data: { resource, filePath, path: `${block}.${entryName}.env` },
+            });
+          }
+        }
+      }
+    }
+
     // Build typed kernel globals schema so x-telo-context chain validation
     // recognises variables, secrets, resources, env automatically
     const kernelGlobals = buildKernelGlobalsSchema(allManifests);
@@ -776,17 +817,15 @@ export class StaticAnalyzer {
         }
       }
 
-      // Top-level `result:` (a sibling, only meaningful with `provide:`) is a
-      // post-call mapping that must satisfy the abstract this definition
-      // `extends` (`outputType`). The target's outputType lives on `provide.kind`
+      // Top-level `result:` is a post-call mapping that must satisfy the abstract
+      // this definition `extends` (`outputType`). It's a sibling of whichever
+      // dispatch entry-point declared a kind-typed target (`provide:` or
+      // `invoke:`). The target's outputType lives on the dispatcher's `kind`
       // and is what `result` is typed against *inside* CEL — separate role.
-      if (
-        provide &&
-        typeof provide === "object" &&
-        !Array.isArray(provide) &&
-        md.result &&
-        typeof md.result === "object"
-      ) {
+      const hasDispatchObject =
+        (provide && typeof provide === "object" && !Array.isArray(provide)) ||
+        (invoke && typeof invoke === "object" && !Array.isArray(invoke));
+      if (hasDispatchObject && md.result && typeof md.result === "object") {
         const extendsValue = md.extends as string | undefined;
         if (typeof extendsValue === "string" && extendsValue.length > 0) {
           const abstractSchema = lookupDefinitionTypeField(
@@ -920,10 +959,15 @@ export class StaticAnalyzer {
     // Validate `extends` fields and flag legacy `capability: <UserAbstract>` overload.
     diagnostics.push(...validateExtends(allManifests, defs, aliases));
 
+    // Validate provider coherence rules for `provide:` template-target definitions.
+    diagnostics.push(...validateProviderCoherence(allManifests, defs, aliases));
+
     // Validate throws: declarations and catches: coverage (rules 1, 2, 4, 7)
     diagnostics.push(...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv));
 
-    return diagnostics;
+    // Reroute diagnostics on synthetic (inline-extracted) resources back to
+    // the chain root so position-index lookups land on the parent doc.
+    return rewriteSyntheticOrigins(diagnostics, allManifests);
   }
 
   analyzeErrors(

package/src/builtins.ts

@@ -149,7 +149,12 @@ export const KERNEL_BUILTINS: ResourceDefinition[] = [
             additionalProperties: false,
             properties: {
               self: { "x-telo-context-from-root": "schema" },
-              result: { "x-telo-context-from-ref-kind": "provide/kind#outputType" },
+              result: {
+                "x-telo-context-from-ref-kind": [
+                  "provide/kind#outputType",
+                  "invoke/kind#outputType",
+                ],
+              },
             },
           },
         },
@@ -222,6 +227,44 @@ export const KERNEL_BUILTINS: ResourceDefinition[] = [
           type: "array",
           items: { type: "string" },
         },
+        // Application-level environment contract. Each entry layers `env:`
+        // (required, names the source env var) and `default:` (optional, used
+        // when the env var is unset) on top of an open JSON Schema property
+        // schema. `type:` constrains the coercion rule applied to the raw env
+        // string (scalars per-type; `object` / `array` via JSON.parse with the
+        // matching top-level type). All other JSON Schema keywords are passed
+        // through unchanged and applied to the coerced value via the standard
+        // schema validator. See kernel/nodejs/src/application-env.ts.
+        variables: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            required: ["env", "type"],
+            properties: {
+              env: { type: "string" },
+              type: {
+                type: "string",
+                enum: ["string", "integer", "number", "boolean", "object", "array"],
+              },
+              default: {},
+            },
+          },
+        },
+        secrets: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            required: ["env", "type"],
+            properties: {
+              env: { type: "string" },
+              type: {
+                type: "string",
+                enum: ["string", "integer", "number", "boolean", "object", "array"],
+              },
+              default: {},
+            },
+          },
+        },
       },
       required: ["metadata"],
       additionalProperties: false,

package/src/index.ts

@@ -14,6 +14,7 @@ export { isModuleKind, MODULE_KINDS } from "./module-kinds.js";
 export type { ModuleKind } from "./module-kinds.js";
 export { parseLoadedFile } from "./parse-loaded-file.js";
 export type { ParseOptions } from "./parse-loaded-file.js";
+export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
 export {
     buildDocumentPositions,
     buildLineOffsets,

package/src/kernel-globals.ts

@@ -1,4 +1,5 @@
 import type { ResourceManifest } from "@telorun/sdk";
+import { residualEntrySchemaMap } from "./residual-schema.js";
 
 /**
  * Kernel global names available in every CEL evaluation context at runtime.
@@ -72,20 +73,17 @@ export function buildKernelGlobalsSchema(
 }
 
 /** Wrap a JSON Schema property map (like `Telo.Application.variables`) into a
- *  closed object schema suitable for chain-access validation. Falls back to
- *  an open map when the module declares no variables/secrets. */
+ *  closed object schema suitable for chain-access validation. For Application
+ *  entries the per-entry shape carries kernel-specific keys (`env`, `default`)
+ *  on top of an otherwise-standard JSON Schema property schema; those keys are
+ *  stripped via `residualEntrySchemaMap` so CEL sees the coerced shape, not
+ *  the env-binding wrapper. Library entries are pure JSON Schema property
+ *  schemas and pass through the same call unchanged. Falls back to an open map
+ *  when the module declares no variables/secrets. */
 function buildSchemaMapSchema(
   schemaMap: Record<string, any> | null | undefined,
 ): Record<string, any> {
-  if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) {
-    return { type: "object", additionalProperties: true };
-  }
-  const props: Record<string, any> = {};
-  for (const [key, value] of Object.entries(schemaMap)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      props[key] = value;
-    }
-  }
+  const props = residualEntrySchemaMap(schemaMap);
   if (Object.keys(props).length === 0) {
     return { type: "object", additionalProperties: true };
   }

package/src/manifest-loader.ts

@@ -33,6 +33,14 @@ export class Loader {
    *  get distinct entries, so neither sees the wrong manifest tree. */
   private readonly fileCache = new Map<string, LoadedFile>();
 
+  /** requestUrl → canonical `source`. Lets `loadFile` skip the source read
+   *  when a URL it has already canonicalised is requested again — kernel
+   *  load → boot and the import-controller each ask the loader for the same
+   *  modules. Without this fast path every duplicate request re-runs the
+   *  source's `read()` (a `fetch` for `RegistrySource`, a disk read for
+   *  `LocalFileSource`). */
+  private readonly urlToSource = new Map<string, string>();
+
   protected sources: ManifestSource[];
   private readonly celEnv: Environment;
 
@@ -67,8 +75,22 @@ export class Loader {
   }
 
   async resolveEntryPoint(url: string): Promise<string> {
-    const { source } = await this.pick(url).read(url);
-    return source;
+    // Route through `loadFile` so the resolved source URL and parsed
+    // entry are populated in `urlToSource` + `fileCache` in one read.
+    // Callers (kernel.load) immediately call `loadGraph(entryUrl)`
+    // afterwards — without this priming, the entry file would be read
+    // twice (twice over the network for `RegistrySource`).
+    const file = await this.loadFile(url);
+    return file.source;
+  }
+
+  /** Returns the canonical source URL the loader has already mapped `url`
+   *  to during a prior `loadFile`/`loadModule`/`loadGraph` call, or
+   *  `undefined` when the URL has not been seen. Callers use it to test
+   *  set-membership against a previous graph walk's modules without
+   *  triggering an extra source read. */
+  canonicalize(url: string): string | undefined {
+    return this.urlToSource.get(url);
   }
 
   // --- New API: returns LoadedFile / LoadedModule / LoadedGraph ----------
@@ -78,8 +100,42 @@ export class Loader {
    *  private mutable copy must call `parseLoadedFile` directly with the
    *  LoadedFile's `text`. */
   async loadFile(url: string, options?: LoadOptions): Promise<LoadedFile> {
+    const compileKey = options?.compile ? "compiled" : "raw";
+    const knownSource = this.urlToSource.get(url);
+    if (knownSource) {
+      const cached = this.fileCache.get(`${compileKey}:${knownSource}`);
+      if (cached) return cached;
+      // The other compile-mode entry is cached — reparse from its text
+      // instead of re-reading the source.
+      //
+      // NOTE for watch-mode reactivation (cli/nodejs/src/commands/run.ts
+      // currently has `setupWatchMode` commented out): this branch
+      // assumes file contents don't change underneath a single Loader.
+      // Reviving watch mode will need a public `invalidate(url)` (or
+      // similar) that drops both `urlToSource[url]` and the cached
+      // entries for its canonical source before the loader serves the
+      // file again.
+      const altKey = `${compileKey === "compiled" ? "raw" : "compiled"}:${knownSource}`;
+      const alt = this.fileCache.get(altKey);
+      if (alt) {
+        const reparsed = parseLoadedFile(knownSource, url, alt.text, {
+          compile: options?.compile,
+          celEnv: this.celEnv,
+        });
+        this.fileCache.set(`${compileKey}:${knownSource}`, reparsed);
+        return reparsed;
+      }
+    }
+
     const { text, source } = await this.pick(url).read(url);
-    const cacheKey = `${options?.compile ? "compiled" : "raw"}:${source}`;
+    this.urlToSource.set(url, source);
+    // Also map the canonical source to itself so subsequent `loadFile`
+    // calls that already received a canonical URL — `kernel.load` passes
+    // the result of `resolveEntryPoint` to `loadGraph`, which then asks
+    // for that exact URL — hit the urlToSource fast path instead of
+    // falling through to a redundant `pick(url).read(url)`.
+    this.urlToSource.set(source, source);
+    const cacheKey = `${compileKey}:${source}`;
     const cached = this.fileCache.get(cacheKey);
     if (cached && cached.text === text) return cached;
 
@@ -224,7 +280,16 @@ export class Loader {
     return { rootSource, entry, modules, importEdges, errors };
   }
 
-  private resolveImportUrl(fromSource: string, importSource: string): string {
+  /** Resolve an `import` URL against the file it appears in. Relative /
+   *  absolute-path forms run through the owning `ManifestSource`'s
+   *  `resolveRelative`; registry refs and full URLs pass through
+   *  unchanged. Exposed so the import-controller (and any other
+   *  caller-side resolver) lands on the *exact same* canonical URL the
+   *  loader used when walking the entry graph — divergent resolution
+   *  would silently break optimizations like `canonicalize()`-keyed
+   *  cache hits whenever a non-trivial `ManifestSource.resolveRelative`
+   *  is in play. */
+  resolveImportUrl(fromSource: string, importSource: string): string {
     if (importSource.startsWith(".") || importSource.startsWith("/")) {
       return this.pick(fromSource).resolveRelative(fromSource, importSource);
     }