@telorun/analyzer 0.15.0 → 0.16.1

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuhB/F,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,GAAE,qBAA0B;IAI/C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAimBvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CACP,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,EAI1B,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,GACtC,gBAAgB,EAAE;IAqBrB,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB;QAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAsB5F"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuhB/F,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,GAAE,qBAA0B;IAI/C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAypBvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CACP,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,EAI1B,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,GACtC,gBAAgB,EAAE;IAqBrB,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB;QAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAsB5F"}

package/dist/analyzer.js

@@ -498,6 +498,11 @@ export class StaticAnalyzer {
             }
         }
         const aliasesByModule = ctx?.aliasesByModule ?? new Map();
+        // Per-module-scope seen aliases for DUPLICATE_IMPORT_ALIAS. Authored
+        // Telo.Import docs and synthetic-from-inline-`imports:` share one alias
+        // namespace per module, so a repeat — across either form — is an error
+        // rather than the silent last-writer-wins the resolver would otherwise do.
+        const seenAliasByScope = new Map();
         for (const m of manifests) {
             if (isModuleKind(m.kind)) {
                 const namespace = m.metadata.namespace ?? null;
@@ -535,6 +540,34 @@ export class StaticAnalyzer {
                 const resolvedModuleName = m.metadata.resolvedModuleName;
                 const resolvedNamespace = m.metadata.resolvedNamespace;
                 const ownModule = m.metadata?.module;
+                if (alias) {
+                    const scopeKey = ownModule ?? "";
+                    let seen = seenAliasByScope.get(scopeKey);
+                    if (!seen) {
+                        seen = new Set();
+                        seenAliasByScope.set(scopeKey, seen);
+                    }
+                    if (seen.has(alias)) {
+                        diagnostics.push({
+                            severity: DiagnosticSeverity.Error,
+                            code: "DUPLICATE_IMPORT_ALIAS",
+                            source: SOURCE,
+                            message: `Duplicate import alias '${alias}'. An alias may be declared once per module — ` +
+                                `across both inline 'imports:' entries and 'Telo.Import' documents. ` +
+                                `Rename or remove the duplicate.`,
+                            data: {
+                                resource: { kind: "Telo.Import", name: alias },
+                                filePath: m.metadata?.source,
+                                path: "metadata.name",
+                            },
+                        });
+                        // Keep the first alias→target mapping intact; don't re-register the
+                        // duplicate (last-writer-wins would shadow the original and cascade
+                        // misleading follow-on diagnostics).
+                        continue;
+                    }
+                    seen.add(alias);
+                }
                 if (alias && source) {
                     const targetModule = resolvedModuleName ?? source.split("/").filter(Boolean).pop() ?? source;
                     // Module identity is registered globally so x-telo-ref resolution sees
@@ -557,6 +590,29 @@ export class StaticAnalyzer {
                 }
             }
         }
+        // Seed `Self` for every module that contributes definitions but whose own
+        // Telo.Library doc isn't in this manifest set. `flattenForAnalyzer` forwards an
+        // imported library's definitions/abstracts/imports but NOT its module doc, so the
+        // module-doc loop above can't register `Self` for imported modules. Without this, a
+        // definition's `extends: Self.X` (a kind defined in the same library as the abstract)
+        // can't resolve and its `extendedBy` edge mis-keys under the literal "Self.X" — which
+        // stays invisible until another module also implements that abstract and flips the
+        // reference check from lenient to strict. `Self` always maps a module to its own name.
+        for (const m of manifests) {
+            if (m.kind !== "Telo.Definition" && m.kind !== "Telo.Abstract")
+                continue;
+            const ownModule = m.metadata?.module;
+            if (!ownModule || rootModules.has(ownModule))
+                continue;
+            let libResolver = aliasesByModule.get(ownModule);
+            if (!libResolver) {
+                libResolver = new AliasResolver();
+                aliasesByModule.set(ownModule, libResolver);
+            }
+            if (!libResolver.hasAlias("Self")) {
+                libResolver.registerImport("Self", ownModule, []);
+            }
+        }
         // Register definitions from Telo.Definition AND Telo.Abstract resources.
         // Abstracts declare contracts that implementations target via `extends` (canonical)
         // or `capability: <AbstractKind>` (legacy). Until they're registered, validateReferences

package/dist/builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,eAAO,MAAM,eAAe,EAAE,kBAAkB,EA4Z/C,CAAC"}
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,eAAO,MAAM,eAAe,EAAE,kBAAkB,EAsd/C,CAAC"}

package/dist/builtins.js

@@ -299,6 +299,37 @@ export const KERNEL_BUILTINS = [
                     type: "array",
                     items: { type: "string" },
                 },
+                // Inline imports — name-keyed map sugar for separate `Telo.Import`
+                // documents. The key is the PascalCase alias (the import's
+                // `metadata.name`). Each value is either a bare source string
+                // (shorthand for `{ source }`) or the full object form. The loader
+                // desugars each entry into a synthetic `Telo.Import` before discovery;
+                // authored `Telo.Import` docs keep working alongside this. See
+                // analyzer/nodejs/src/inline-imports.ts.
+                imports: {
+                    type: "object",
+                    additionalProperties: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                type: "object",
+                                required: ["source"],
+                                properties: {
+                                    source: { type: "string" },
+                                    variables: { type: "object" },
+                                    secrets: { type: "object" },
+                                    runtime: {
+                                        oneOf: [
+                                            { type: "string" },
+                                            { type: "array", items: { type: "string" } },
+                                        ],
+                                    },
+                                },
+                                additionalProperties: false,
+                            },
+                        ],
+                    },
+                },
                 // 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
@@ -392,6 +423,33 @@ export const KERNEL_BUILTINS = [
                     type: "array",
                     items: { type: "string" },
                 },
+                // Inline imports — same name-keyed map sugar as Telo.Application; the
+                // loader desugars each entry into a synthetic Telo.Import. See the
+                // Application schema above and analyzer/nodejs/src/inline-imports.ts.
+                imports: {
+                    type: "object",
+                    additionalProperties: {
+                        oneOf: [
+                            { type: "string" },
+                            {
+                                type: "object",
+                                required: ["source"],
+                                properties: {
+                                    source: { type: "string" },
+                                    variables: { type: "object" },
+                                    secrets: { type: "object" },
+                                    runtime: {
+                                        oneOf: [
+                                            { type: "string" },
+                                            { type: "array", items: { type: "string" } },
+                                        ],
+                                    },
+                                },
+                                additionalProperties: false,
+                            },
+                        ],
+                    },
+                },
                 exports: {
                     type: "object",
                     properties: {

package/dist/index.d.ts

@@ -9,6 +9,8 @@ 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 { desugarLoadedFile, inlineImportManifests } from "./inline-imports.js";
+export type { SyntheticImport } from "./inline-imports.js";
 export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
 export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, } from "./position-metadata.js";
 export type { DocumentPosition } from "./position-metadata.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EACR,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EACR,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -5,6 +5,7 @@ export { visitManifest } from "./manifest-visitor.js";
 export { Loader } from "./manifest-loader.js";
 export { isModuleKind, MODULE_KINDS } from "./module-kinds.js";
 export { parseLoadedFile } from "./parse-loaded-file.js";
+export { desugarLoadedFile, inlineImportManifests } from "./inline-imports.js";
 export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
 export { buildDocumentPositions, buildLineOffsets, buildPositionIndex, documentLineOffsets, } from "./position-metadata.js";
 export { HttpSource } from "./sources/http-source.js";

package/dist/inline-imports.d.ts

@@ -0,0 +1,34 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { LoadedFile } from "./loaded-types.js";
+import type { DocumentPosition } from "./position-metadata.js";
+/** A synthetic `Telo.Import` produced by desugaring an `imports:` map entry,
+ *  paired with the position metadata that pins its diagnostics back to the
+ *  authoring line in the module document. */
+export interface SyntheticImport {
+    manifest: ResourceManifest;
+    position: DocumentPosition;
+}
+/**
+ * Desugar a module document's inline `imports:` map into synthetic
+ * `Telo.Import` manifests. Each entry value is either a bare source string
+ * (shorthand for `{ source }`) or the full object form carrying
+ * `variables` / `secrets` / `runtime`. Malformed entries (object without a
+ * string `source`) are skipped here — the module document's own schema
+ * validation reports them against the precise `imports.<Alias>.source` path.
+ *
+ * The synthetic manifests are indistinguishable from authored `Telo.Import`
+ * documents downstream (alias registration, discovery, the kernel's
+ * import-controller), so the feature is purely additive at the declaration
+ * site. Pure and browser-safe — no I/O, no Node built-ins.
+ */
+export declare function inlineImportManifests(moduleManifest: ResourceManifest, modulePosition: DocumentPosition | undefined): SyntheticImport[];
+/** Returns a copy of `file` with synthetic `Telo.Import` manifests (from the
+ *  module document's inline `imports:` map) appended to `manifests` and
+ *  `positions`. `documents` is intentionally left untouched: it is the raw
+ *  YAML-AST array round-trip consumers pair by index, and a synthetic import
+ *  has no backing node. Every flatten/discovery loop iterates `manifests` and
+ *  indexes `positions[i]` — never `documents[i]` in lockstep — so the trailing
+ *  synthetics are visible to resolution while the AST round-trip stays intact.
+ *  Returns `file` unchanged when there is no module doc or no inline imports. */
+export declare function desugarLoadedFile(file: LoadedFile): LoadedFile;
+//# sourceMappingURL=inline-imports.d.ts.map

package/dist/inline-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-imports.d.ts","sourceRoot":"","sources":["../src/inline-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D;;6CAE6C;AAC7C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,gBAAgB,EAChC,cAAc,EAAE,gBAAgB,GAAG,SAAS,GAC3C,eAAe,EAAE,CA0BnB;AAED;;;;;;;iFAOiF;AACjF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAmB9D"}

package/dist/inline-imports.js

@@ -0,0 +1,106 @@
+import { isModuleKind } from "./module-kinds.js";
+/**
+ * Desugar a module document's inline `imports:` map into synthetic
+ * `Telo.Import` manifests. Each entry value is either a bare source string
+ * (shorthand for `{ source }`) or the full object form carrying
+ * `variables` / `secrets` / `runtime`. Malformed entries (object without a
+ * string `source`) are skipped here — the module document's own schema
+ * validation reports them against the precise `imports.<Alias>.source` path.
+ *
+ * The synthetic manifests are indistinguishable from authored `Telo.Import`
+ * documents downstream (alias registration, discovery, the kernel's
+ * import-controller), so the feature is purely additive at the declaration
+ * site. Pure and browser-safe — no I/O, no Node built-ins.
+ */
+export function inlineImportManifests(moduleManifest, modulePosition) {
+    const raw = moduleManifest.imports;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const [alias, value] of Object.entries(raw)) {
+        const scalar = typeof value === "string";
+        const entry = scalar
+            ? { source: value }
+            : value && typeof value === "object" && !Array.isArray(value)
+                ? value
+                : undefined;
+        if (!entry || typeof entry.source !== "string")
+            continue;
+        const manifest = {
+            kind: "Telo.Import",
+            metadata: { name: alias },
+            source: entry.source,
+            ...(entry.variables !== undefined ? { variables: entry.variables } : {}),
+            ...(entry.secrets !== undefined ? { secrets: entry.secrets } : {}),
+            ...(entry.runtime !== undefined ? { runtime: entry.runtime } : {}),
+        };
+        out.push({ manifest, position: synthPosition(modulePosition, alias, scalar) });
+    }
+    return out;
+}
+/** Returns a copy of `file` with synthetic `Telo.Import` manifests (from the
+ *  module document's inline `imports:` map) appended to `manifests` and
+ *  `positions`. `documents` is intentionally left untouched: it is the raw
+ *  YAML-AST array round-trip consumers pair by index, and a synthetic import
+ *  has no backing node. Every flatten/discovery loop iterates `manifests` and
+ *  indexes `positions[i]` — never `documents[i]` in lockstep — so the trailing
+ *  synthetics are visible to resolution while the AST round-trip stays intact.
+ *  Returns `file` unchanged when there is no module doc or no inline imports. */
+export function desugarLoadedFile(file) {
+    let moduleIndex = -1;
+    for (let i = 0; i < file.manifests.length; i++) {
+        const m = file.manifests[i];
+        if (m && isModuleKind(m.kind)) {
+            moduleIndex = i;
+            break;
+        }
+    }
+    if (moduleIndex < 0)
+        return file;
+    const synthetic = inlineImportManifests(file.manifests[moduleIndex], file.positions[moduleIndex]);
+    if (synthetic.length === 0)
+        return file;
+    return {
+        ...file,
+        manifests: [...file.manifests, ...synthetic.map((s) => s.manifest)],
+        positions: [...file.positions, ...synthetic.map((s) => s.position)],
+    };
+}
+/** Build a `DocumentPosition` for a synthetic import by re-rooting the module
+ *  document's `imports.<Alias>` position subtree at the import manifest's own
+ *  paths (`source`, `variables.*`, `metadata.name`, …). This makes a
+ *  diagnostic on the synthetic's `source` land on the `imports:` entry's
+ *  authoring line rather than a phantom document. */
+function synthPosition(modulePosition, alias, scalar) {
+    if (!modulePosition)
+        return { sourceLine: 0, positionIndex: new Map() };
+    const base = modulePosition.positionIndex;
+    const index = new Map();
+    const keyRange = base.get(`@key:imports.${alias}`);
+    const valueRange = base.get(`imports.${alias}`);
+    if (keyRange) {
+        index.set("metadata.name", keyRange);
+        index.set("@key:metadata.name", keyRange);
+    }
+    if (scalar) {
+        // `Console: std/console@1.2.3` — the entry value IS the source scalar.
+        if (valueRange)
+            index.set("source", valueRange);
+    }
+    else {
+        const valuePrefix = `imports.${alias}.`;
+        const keyPrefix = `@key:imports.${alias}.`;
+        for (const [path, range] of base) {
+            if (path.startsWith(valuePrefix)) {
+                index.set(path.slice(valuePrefix.length), range);
+            }
+            else if (path.startsWith(keyPrefix)) {
+                index.set(`@key:${path.slice(keyPrefix.length)}`, range);
+            }
+        }
+    }
+    if (valueRange)
+        index.set("", valueRange);
+    const sourceLine = (keyRange ?? valueRange)?.start.line ?? modulePosition.sourceLine;
+    return { sourceLine, positionIndex: index };
+}

package/dist/manifest-loader.d.ts

@@ -30,6 +30,15 @@ export declare class Loader {
      *  private mutable copy must call `parseLoadedFile` directly with the
      *  LoadedFile's `text`. */
     loadFile(url: string, options?: LoadOptions): Promise<LoadedFile>;
+    /** Parse `text` into a LoadedFile, then desugar inline `imports:` when the
+     *  caller opted in. Desugaring lives here, not in the pure `parseLoadedFile`,
+     *  so round-trip consumers (the editor) keep a raw manifest/AST/position
+     *  triple they can pair by index; only resolved consumers that pass
+     *  `desugarImports` see synthetic Telo.Import manifests. */
+    private parseAndMaybeDesugar;
+    /** Raw text of any already-cached variant for `source`, so a cache miss on
+     *  one (compile, desugar) variant reparses without a second source read. */
+    private findCachedText;
     /** Load an owner file plus every partial reachable through its `include:`
      *  list. Globs are expanded via the owning source's `expandGlob`. The
      *  partials list is empty when the owner declares no `include:`. */
@@ -57,7 +66,7 @@ export declare class Loader {
      *  owner) and return the `LoadedGraph` rooted at that owner. Returns
      *  `null` only when `fileUrl` is neither an owner nor reachable from one
      *  via parent-directory traversal. */
-    loadGraphForFile(fileUrl: string): Promise<{
+    loadGraphForFile(fileUrl: string, options?: LoadOptions): Promise<{
         graph: LoadedGraph;
         ownerUrl: string;
     } | null>;

package/dist/manifest-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AASpB,qBAAa,MAAM;IACjB;;;yEAGqE;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAE3D;;;;;8BAK0B;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,qBAAqB,GAAE,cAAc,EAAE,GAAG,iBAAsB;IAmB5E,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKtC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrD;;;;2CAIuC;IACvC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAM7C;;;+BAG2B;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAgDvE;;wEAEoE;IAC9D,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAsB3E;;;qCAGiC;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAwG9E;;;;;;;;sBAQkB;IAClB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAOlE,OAAO,CAAC,6BAA6B;IAarC,OAAO,CAAC,mCAAmC;IAc3C,OAAO,CAAC,2BAA2B;YAkCrB,eAAe;IAmB7B;;;0CAGsC;IAChC,gBAAgB,CACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CA0B5D"}
+{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,YAAY,EACb,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAiBpB,qBAAa,MAAM;IACjB;;;yEAGqE;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAE3D;;;;;8BAK0B;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,qBAAqB,GAAE,cAAc,EAAE,GAAG,iBAAsB;IAmB5E,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKtC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrD;;;;2CAIuC;IACvC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAM7C;;;+BAG2B;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAyCvE;;;;gEAI4D;IAC5D,OAAO,CAAC,oBAAoB;IAa5B;gFAC4E;IAC5E,OAAO,CAAC,cAAc;IAQtB;;wEAEoE;IAC9D,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAsB3E;;;qCAGiC;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAwG9E;;;;;;;;sBAQkB;IAClB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAOlE,OAAO,CAAC,6BAA6B;IAarC,OAAO,CAAC,mCAAmC;IAc3C,OAAO,CAAC,2BAA2B;YAkCrB,eAAe;IAmB7B;;;0CAGsC;IAChC,gBAAgB,CACpB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CA0B5D"}

package/dist/manifest-loader.js

@@ -1,6 +1,7 @@
 import { HttpSource } from "./sources/http-source.js";
 import { RegistrySource } from "./sources/registry-source.js";
 import { buildCelEnvironment } from "./cel-environment.js";
+import { desugarLoadedFile } from "./inline-imports.js";
 import { isModuleKind } from "./module-kinds.js";
 import { parseLoadedFile } from "./parse-loaded-file.js";
 import { DEFAULT_MANIFEST_FILENAME, } from "./types.js";
@@ -10,6 +11,13 @@ const SYSTEM_KINDS = new Set([
     "Telo.Import",
     "Telo.Definition",
 ]);
+/** File cache variant tags: compile (c/r) × desugarImports (d/n). A desugared
+ *  and a raw load of the same file are distinct entries so neither sees the
+ *  wrong manifest tree. */
+const CACHE_VARIANTS = ["rn", "rd", "cn", "cd"];
+function variantKey(options) {
+    return `${options?.compile ? "c" : "r"}${options?.desugarImports ? "d" : "n"}`;
+}
 export class Loader {
     /** LoadedFile cache keyed by `${compile ? "compiled" : "raw"}:${source}`.
      *  Same dual-keying as the legacy ResourceManifest[] cache: a compile-mode
@@ -74,30 +82,26 @@ export class Loader {
      *  private mutable copy must call `parseLoadedFile` directly with the
      *  LoadedFile's `text`. */
     async loadFile(url, options) {
-        const compileKey = options?.compile ? "compiled" : "raw";
+        const variant = variantKey(options);
         const knownSource = this.urlToSource.get(url);
         if (knownSource) {
-            const cached = this.fileCache.get(`${compileKey}:${knownSource}`);
+            const cached = this.fileCache.get(`${variant}:${knownSource}`);
             if (cached)
                 return cached;
-            // The other compile-mode entry is cached — reparse from its text
+            // Another variant of this source 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);
+            // similar) that drops both `urlToSource[url]` and every cached
+            // variant entry for its canonical source before the loader serves
+            // the file again.
+            const altText = this.findCachedText(knownSource);
+            if (altText !== undefined) {
+                const reparsed = this.parseAndMaybeDesugar(knownSource, url, altText, options);
+                this.fileCache.set(`${variant}:${knownSource}`, reparsed);
                 return reparsed;
             }
         }
@@ -109,16 +113,35 @@ export class Loader {
         // 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 cacheKey = `${variant}:${source}`;
         const cached = this.fileCache.get(cacheKey);
         if (cached && cached.text === text)
             return cached;
-        const loaded = parseLoadedFile(source, url, text, {
+        const loaded = this.parseAndMaybeDesugar(source, url, text, options);
+        this.fileCache.set(cacheKey, loaded);
+        return loaded;
+    }
+    /** Parse `text` into a LoadedFile, then desugar inline `imports:` when the
+     *  caller opted in. Desugaring lives here, not in the pure `parseLoadedFile`,
+     *  so round-trip consumers (the editor) keep a raw manifest/AST/position
+     *  triple they can pair by index; only resolved consumers that pass
+     *  `desugarImports` see synthetic Telo.Import manifests. */
+    parseAndMaybeDesugar(source, requestedUrl, text, options) {
+        const loaded = parseLoadedFile(source, requestedUrl, text, {
             compile: options?.compile,
             celEnv: this.celEnv,
         });
-        this.fileCache.set(cacheKey, loaded);
-        return loaded;
+        return options?.desugarImports ? desugarLoadedFile(loaded) : loaded;
+    }
+    /** Raw text of any already-cached variant for `source`, so a cache miss on
+     *  one (compile, desugar) variant reparses without a second source read. */
+    findCachedText(source) {
+        for (const v of CACHE_VARIANTS) {
+            const cached = this.fileCache.get(`${v}:${source}`);
+            if (cached)
+                return cached.text;
+        }
+        return undefined;
     }
     /** Load an owner file plus every partial reachable through its `include:`
      *  list. Globs are expanded via the owning source's `expandGlob`. The
@@ -319,12 +342,12 @@ export class Loader {
      *  owner) and return the `LoadedGraph` rooted at that owner. Returns
      *  `null` only when `fileUrl` is neither an owner nor reachable from one
      *  via parent-directory traversal. */
-    async loadGraphForFile(fileUrl) {
+    async loadGraphForFile(fileUrl, options) {
         try {
-            const owner = await this.loadFile(fileUrl);
+            const owner = await this.loadFile(fileUrl, options);
             const isOwner = owner.manifests.some((m) => m && isModuleKind(m.kind));
             if (isOwner) {
-                const graph = await this.loadGraph(fileUrl);
+                const graph = await this.loadGraph(fileUrl, options);
                 return { graph, ownerUrl: graph.rootSource };
             }
         }
@@ -341,7 +364,7 @@ export class Loader {
         const ownerUrl = await source.resolveOwnerOf(fileUrl);
         if (!ownerUrl)
             return null;
-        const graph = await this.loadGraph(ownerUrl);
+        const graph = await this.loadGraph(ownerUrl, options);
         return { graph, ownerUrl: graph.rootSource };
     }
 }

package/dist/types.d.ts

@@ -57,6 +57,15 @@ export interface LoadOptions {
      *  so the kernel can evaluate them at runtime. Leave unset (false) for static analysis —
      *  the analyzer works on raw strings and does not need compiled values. */
     compile?: boolean;
+    /** When true, each module document's inline `imports:` map is desugared into
+     *  synthetic `Telo.Import` manifests appended to the file's `manifests` /
+     *  `positions` (the AST `documents` array is left raw). On for every resolved
+     *  consumer — the kernel's analysis and runtime loads, and the analyzer — so
+     *  inline imports participate in discovery, alias resolution, and execution.
+     *  Off for the editor's round-trip view, which reads the raw `imports:` map and
+     *  pairs manifests to YAML nodes by index. Folded into the file cache key so a
+     *  desugared and a raw load of the same file never collide. */
+    desugarImports?: boolean;
 }
 export interface LoaderInitOptions {
     /** Sources inserted with highest priority before built-ins. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,cAAc,CAAC;AAErD,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD;;qEAEiE;IACjE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEjE;;qEAEiE;IACjE,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;6FACyF;IACzF,WAAW,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;sDAUkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;IACpE;;;;+EAI2E;IAC3E,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC,CAAC;CAC5E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,cAAc,CAAC;AAErD,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD;;qEAEiE;IACjE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEjE;;qEAEiE;IACjE,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;mEAO+D;IAC/D,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;6FACyF;IACzF,WAAW,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;sDAUkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;IACpE;;;;+EAI2E;IAC3E,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC,CAAC;CAC5E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -48,7 +48,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.16.0"
+    "@telorun/sdk": "0.17.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/analyzer.ts

@@ -621,6 +621,11 @@ export class StaticAnalyzer {
       }
     }
     const aliasesByModule = ctx?.aliasesByModule ?? new Map<string, AliasResolver>();
+    // Per-module-scope seen aliases for DUPLICATE_IMPORT_ALIAS. Authored
+    // Telo.Import docs and synthetic-from-inline-`imports:` share one alias
+    // namespace per module, so a repeat — across either form — is an error
+    // rather than the silent last-writer-wins the resolver would otherwise do.
+    const seenAliasByScope = new Map<string, Set<string>>();
     for (const m of manifests) {
       if (isModuleKind(m.kind)) {
         const namespace = ((m.metadata as any).namespace as string | undefined) ?? null;
@@ -659,6 +664,35 @@ export class StaticAnalyzer {
           | null
           | undefined;
         const ownModule = (m.metadata as { module?: string } | undefined)?.module;
+        if (alias) {
+          const scopeKey = ownModule ?? "";
+          let seen = seenAliasByScope.get(scopeKey);
+          if (!seen) {
+            seen = new Set<string>();
+            seenAliasByScope.set(scopeKey, seen);
+          }
+          if (seen.has(alias)) {
+            diagnostics.push({
+              severity: DiagnosticSeverity.Error,
+              code: "DUPLICATE_IMPORT_ALIAS",
+              source: SOURCE,
+              message:
+                `Duplicate import alias '${alias}'. An alias may be declared once per module — ` +
+                `across both inline 'imports:' entries and 'Telo.Import' documents. ` +
+                `Rename or remove the duplicate.`,
+              data: {
+                resource: { kind: "Telo.Import", name: alias },
+                filePath: (m.metadata as { source?: string } | undefined)?.source,
+                path: "metadata.name",
+              },
+            });
+            // Keep the first alias→target mapping intact; don't re-register the
+            // duplicate (last-writer-wins would shadow the original and cascade
+            // misleading follow-on diagnostics).
+            continue;
+          }
+          seen.add(alias);
+        }
         if (alias && source) {
           const targetModule =
             resolvedModuleName ?? source.split("/").filter(Boolean).pop() ?? source;
@@ -682,6 +716,28 @@ export class StaticAnalyzer {
       }
     }
 
+    // Seed `Self` for every module that contributes definitions but whose own
+    // Telo.Library doc isn't in this manifest set. `flattenForAnalyzer` forwards an
+    // imported library's definitions/abstracts/imports but NOT its module doc, so the
+    // module-doc loop above can't register `Self` for imported modules. Without this, a
+    // definition's `extends: Self.X` (a kind defined in the same library as the abstract)
+    // can't resolve and its `extendedBy` edge mis-keys under the literal "Self.X" — which
+    // stays invisible until another module also implements that abstract and flips the
+    // reference check from lenient to strict. `Self` always maps a module to its own name.
+    for (const m of manifests) {
+      if (m.kind !== "Telo.Definition" && m.kind !== "Telo.Abstract") continue;
+      const ownModule = (m.metadata as { module?: string } | undefined)?.module;
+      if (!ownModule || rootModules.has(ownModule)) continue;
+      let libResolver = aliasesByModule.get(ownModule);
+      if (!libResolver) {
+        libResolver = new AliasResolver();
+        aliasesByModule.set(ownModule, libResolver);
+      }
+      if (!libResolver.hasAlias("Self")) {
+        libResolver.registerImport("Self", ownModule, []);
+      }
+    }
+
     // Register definitions from Telo.Definition AND Telo.Abstract resources.
     // Abstracts declare contracts that implementations target via `extends` (canonical)
     // or `capability: <AbstractKind>` (legacy). Until they're registered, validateReferences

package/src/builtins.ts

@@ -301,6 +301,37 @@ export const KERNEL_BUILTINS: ResourceDefinition[] = [
           type: "array",
           items: { type: "string" },
         },
+        // Inline imports — name-keyed map sugar for separate `Telo.Import`
+        // documents. The key is the PascalCase alias (the import's
+        // `metadata.name`). Each value is either a bare source string
+        // (shorthand for `{ source }`) or the full object form. The loader
+        // desugars each entry into a synthetic `Telo.Import` before discovery;
+        // authored `Telo.Import` docs keep working alongside this. See
+        // analyzer/nodejs/src/inline-imports.ts.
+        imports: {
+          type: "object",
+          additionalProperties: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                required: ["source"],
+                properties: {
+                  source: { type: "string" },
+                  variables: { type: "object" },
+                  secrets: { type: "object" },
+                  runtime: {
+                    oneOf: [
+                      { type: "string" },
+                      { type: "array", items: { type: "string" } },
+                    ],
+                  },
+                },
+                additionalProperties: false,
+              },
+            ],
+          },
+        },
         // 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
@@ -394,6 +425,33 @@ export const KERNEL_BUILTINS: ResourceDefinition[] = [
           type: "array",
           items: { type: "string" },
         },
+        // Inline imports — same name-keyed map sugar as Telo.Application; the
+        // loader desugars each entry into a synthetic Telo.Import. See the
+        // Application schema above and analyzer/nodejs/src/inline-imports.ts.
+        imports: {
+          type: "object",
+          additionalProperties: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                required: ["source"],
+                properties: {
+                  source: { type: "string" },
+                  variables: { type: "object" },
+                  secrets: { type: "object" },
+                  runtime: {
+                    oneOf: [
+                      { type: "string" },
+                      { type: "array", items: { type: "string" } },
+                    ],
+                  },
+                },
+                additionalProperties: false,
+              },
+            ],
+          },
+        },
         exports: {
           type: "object",
           properties: {

package/src/index.ts

@@ -25,6 +25,8 @@ 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 { desugarLoadedFile, inlineImportManifests } from "./inline-imports.js";
+export type { SyntheticImport } from "./inline-imports.js";
 export { residualEntrySchema, residualEntrySchemaMap } from "./residual-schema.js";
 export {
     buildDocumentPositions,

package/src/inline-imports.ts

@@ -0,0 +1,130 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { LoadedFile } from "./loaded-types.js";
+import { isModuleKind } from "./module-kinds.js";
+import type { DocumentPosition } from "./position-metadata.js";
+import type { PositionIndex } from "./types.js";
+
+/** A synthetic `Telo.Import` produced by desugaring an `imports:` map entry,
+ *  paired with the position metadata that pins its diagnostics back to the
+ *  authoring line in the module document. */
+export interface SyntheticImport {
+  manifest: ResourceManifest;
+  position: DocumentPosition;
+}
+
+/**
+ * Desugar a module document's inline `imports:` map into synthetic
+ * `Telo.Import` manifests. Each entry value is either a bare source string
+ * (shorthand for `{ source }`) or the full object form carrying
+ * `variables` / `secrets` / `runtime`. Malformed entries (object without a
+ * string `source`) are skipped here — the module document's own schema
+ * validation reports them against the precise `imports.<Alias>.source` path.
+ *
+ * The synthetic manifests are indistinguishable from authored `Telo.Import`
+ * documents downstream (alias registration, discovery, the kernel's
+ * import-controller), so the feature is purely additive at the declaration
+ * site. Pure and browser-safe — no I/O, no Node built-ins.
+ */
+export function inlineImportManifests(
+  moduleManifest: ResourceManifest,
+  modulePosition: DocumentPosition | undefined,
+): SyntheticImport[] {
+  const raw = (moduleManifest as { imports?: unknown }).imports;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
+
+  const out: SyntheticImport[] = [];
+  for (const [alias, value] of Object.entries(raw as Record<string, unknown>)) {
+    const scalar = typeof value === "string";
+    const entry = scalar
+      ? { source: value as string }
+      : value && typeof value === "object" && !Array.isArray(value)
+        ? (value as Record<string, unknown>)
+        : undefined;
+    if (!entry || typeof entry.source !== "string") continue;
+
+    const manifest = {
+      kind: "Telo.Import",
+      metadata: { name: alias },
+      source: entry.source,
+      ...(entry.variables !== undefined ? { variables: entry.variables } : {}),
+      ...(entry.secrets !== undefined ? { secrets: entry.secrets } : {}),
+      ...(entry.runtime !== undefined ? { runtime: entry.runtime } : {}),
+    } as unknown as ResourceManifest;
+
+    out.push({ manifest, position: synthPosition(modulePosition, alias, scalar) });
+  }
+  return out;
+}
+
+/** Returns a copy of `file` with synthetic `Telo.Import` manifests (from the
+ *  module document's inline `imports:` map) appended to `manifests` and
+ *  `positions`. `documents` is intentionally left untouched: it is the raw
+ *  YAML-AST array round-trip consumers pair by index, and a synthetic import
+ *  has no backing node. Every flatten/discovery loop iterates `manifests` and
+ *  indexes `positions[i]` — never `documents[i]` in lockstep — so the trailing
+ *  synthetics are visible to resolution while the AST round-trip stays intact.
+ *  Returns `file` unchanged when there is no module doc or no inline imports. */
+export function desugarLoadedFile(file: LoadedFile): LoadedFile {
+  let moduleIndex = -1;
+  for (let i = 0; i < file.manifests.length; i++) {
+    const m = file.manifests[i];
+    if (m && isModuleKind(m.kind)) {
+      moduleIndex = i;
+      break;
+    }
+  }
+  if (moduleIndex < 0) return file;
+
+  const synthetic = inlineImportManifests(file.manifests[moduleIndex]!, file.positions[moduleIndex]);
+  if (synthetic.length === 0) return file;
+
+  return {
+    ...file,
+    manifests: [...file.manifests, ...synthetic.map((s) => s.manifest)],
+    positions: [...file.positions, ...synthetic.map((s) => s.position)],
+  };
+}
+
+/** Build a `DocumentPosition` for a synthetic import by re-rooting the module
+ *  document's `imports.<Alias>` position subtree at the import manifest's own
+ *  paths (`source`, `variables.*`, `metadata.name`, …). This makes a
+ *  diagnostic on the synthetic's `source` land on the `imports:` entry's
+ *  authoring line rather than a phantom document. */
+function synthPosition(
+  modulePosition: DocumentPosition | undefined,
+  alias: string,
+  scalar: boolean,
+): DocumentPosition {
+  if (!modulePosition) return { sourceLine: 0, positionIndex: new Map() };
+
+  const base = modulePosition.positionIndex;
+  const index: PositionIndex = new Map();
+
+  const keyRange = base.get(`@key:imports.${alias}`);
+  const valueRange = base.get(`imports.${alias}`);
+
+  if (keyRange) {
+    index.set("metadata.name", keyRange);
+    index.set("@key:metadata.name", keyRange);
+  }
+
+  if (scalar) {
+    // `Console: std/console@1.2.3` — the entry value IS the source scalar.
+    if (valueRange) index.set("source", valueRange);
+  } else {
+    const valuePrefix = `imports.${alias}.`;
+    const keyPrefix = `@key:imports.${alias}.`;
+    for (const [path, range] of base) {
+      if (path.startsWith(valuePrefix)) {
+        index.set(path.slice(valuePrefix.length), range);
+      } else if (path.startsWith(keyPrefix)) {
+        index.set(`@key:${path.slice(keyPrefix.length)}`, range);
+      }
+    }
+  }
+
+  if (valueRange) index.set("", valueRange);
+
+  const sourceLine = (keyRange ?? valueRange)?.start.line ?? modulePosition.sourceLine;
+  return { sourceLine, positionIndex: index };
+}

package/src/manifest-loader.ts

@@ -10,6 +10,7 @@ import type {
   LoadedGraph,
   LoadedModule,
 } from "./loaded-types.js";
+import { desugarLoadedFile } from "./inline-imports.js";
 import { isModuleKind } from "./module-kinds.js";
 import { parseLoadedFile } from "./parse-loaded-file.js";
 import {
@@ -26,6 +27,14 @@ const SYSTEM_KINDS = new Set([
   "Telo.Definition",
 ]);
 
+/** File cache variant tags: compile (c/r) × desugarImports (d/n). A desugared
+ *  and a raw load of the same file are distinct entries so neither sees the
+ *  wrong manifest tree. */
+const CACHE_VARIANTS = ["rn", "rd", "cn", "cd"] as const;
+function variantKey(options?: LoadOptions): string {
+  return `${options?.compile ? "c" : "r"}${options?.desugarImports ? "d" : "n"}`;
+}
+
 export class Loader {
   /** LoadedFile cache keyed by `${compile ? "compiled" : "raw"}:${source}`.
    *  Same dual-keying as the legacy ResourceManifest[] cache: a compile-mode
@@ -100,29 +109,25 @@ 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 variant = variantKey(options);
     const knownSource = this.urlToSource.get(url);
     if (knownSource) {
-      const cached = this.fileCache.get(`${compileKey}:${knownSource}`);
+      const cached = this.fileCache.get(`${variant}:${knownSource}`);
       if (cached) return cached;
-      // The other compile-mode entry is cached — reparse from its text
+      // Another variant of this source 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);
+      // similar) that drops both `urlToSource[url]` and every cached
+      // variant entry for its canonical source before the loader serves
+      // the file again.
+      const altText = this.findCachedText(knownSource);
+      if (altText !== undefined) {
+        const reparsed = this.parseAndMaybeDesugar(knownSource, url, altText, options);
+        this.fileCache.set(`${variant}:${knownSource}`, reparsed);
         return reparsed;
       }
     }
@@ -135,16 +140,41 @@ export class Loader {
     // 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 cacheKey = `${variant}:${source}`;
     const cached = this.fileCache.get(cacheKey);
     if (cached && cached.text === text) return cached;
 
-    const loaded = parseLoadedFile(source, url, text, {
+    const loaded = this.parseAndMaybeDesugar(source, url, text, options);
+    this.fileCache.set(cacheKey, loaded);
+    return loaded;
+  }
+
+  /** Parse `text` into a LoadedFile, then desugar inline `imports:` when the
+   *  caller opted in. Desugaring lives here, not in the pure `parseLoadedFile`,
+   *  so round-trip consumers (the editor) keep a raw manifest/AST/position
+   *  triple they can pair by index; only resolved consumers that pass
+   *  `desugarImports` see synthetic Telo.Import manifests. */
+  private parseAndMaybeDesugar(
+    source: string,
+    requestedUrl: string,
+    text: string,
+    options?: LoadOptions,
+  ): LoadedFile {
+    const loaded = parseLoadedFile(source, requestedUrl, text, {
       compile: options?.compile,
       celEnv: this.celEnv,
     });
-    this.fileCache.set(cacheKey, loaded);
-    return loaded;
+    return options?.desugarImports ? desugarLoadedFile(loaded) : loaded;
+  }
+
+  /** Raw text of any already-cached variant for `source`, so a cache miss on
+   *  one (compile, desugar) variant reparses without a second source read. */
+  private findCachedText(source: string): string | undefined {
+    for (const v of CACHE_VARIANTS) {
+      const cached = this.fileCache.get(`${v}:${source}`);
+      if (cached) return cached.text;
+    }
+    return undefined;
   }
 
   /** Load an owner file plus every partial reachable through its `include:`
@@ -382,12 +412,13 @@ export class Loader {
    *  via parent-directory traversal. */
   async loadGraphForFile(
     fileUrl: string,
+    options?: LoadOptions,
   ): Promise<{ graph: LoadedGraph; ownerUrl: string } | null> {
     try {
-      const owner = await this.loadFile(fileUrl);
+      const owner = await this.loadFile(fileUrl, options);
       const isOwner = owner.manifests.some((m) => m && isModuleKind(m.kind));
       if (isOwner) {
-        const graph = await this.loadGraph(fileUrl);
+        const graph = await this.loadGraph(fileUrl, options);
         return { graph, ownerUrl: graph.rootSource };
       }
     } catch (err) {
@@ -404,7 +435,7 @@ export class Loader {
     if (!source.resolveOwnerOf) return null;
     const ownerUrl = await source.resolveOwnerOf(fileUrl);
     if (!ownerUrl) return null;
-    const graph = await this.loadGraph(ownerUrl);
+    const graph = await this.loadGraph(ownerUrl, options);
     return { graph, ownerUrl: graph.rootSource };
   }
 

package/src/types.ts

@@ -63,6 +63,15 @@ export interface LoadOptions {
    *  so the kernel can evaluate them at runtime. Leave unset (false) for static analysis —
    *  the analyzer works on raw strings and does not need compiled values. */
   compile?: boolean;
+  /** When true, each module document's inline `imports:` map is desugared into
+   *  synthetic `Telo.Import` manifests appended to the file's `manifests` /
+   *  `positions` (the AST `documents` array is left raw). On for every resolved
+   *  consumer — the kernel's analysis and runtime loads, and the analyzer — so
+   *  inline imports participate in discovery, alias resolution, and execution.
+   *  Off for the editor's round-trip view, which reads the raw `imports:` map and
+   *  pairs manifests to YAML nodes by index. Folded into the file cache key so a
+   *  desugared and a raw load of the same file never collide. */
+  desugarImports?: boolean;
 }
 
 export interface LoaderInitOptions {