@telorun/analyzer 0.72.0 → 0.74.0

package/dist/schema-walk.js

@@ -9,8 +9,7 @@
  * scope rule is consumed by the IDE, which must not pull the pass in behind it.
  */
 import { MANIFEST_SCHEMA_URI, ManifestRootSchema } from "./manifest-schemas.js";
-import { readRefSlot } from "./ref-slot.js";
-import { readStepSlot } from "./step-slot.js";
+import { buildDrivenSlotMap, refSlotOfEntry } from "./reference-field-map.js";
 /** Resolve a local `$ref` (only `#/$defs/<name>` form) against the root schema.
  *  Non-refs and unresolved refs pass through unchanged. */
 export function resolveLocalRef(schema, root) {
@@ -126,45 +125,166 @@ export function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit
         }
     });
 }
+/**
+ * Every slot a kind's schema declares through which its resources drive
+ * another — the schema-only mode of {@link forEachDrivenSlot}, read off the
+ * same {@link buildDrivenSlotMap}.
+ */
+export function forEachDeclaredSlot(schema, visit) {
+    if (!schema || typeof schema !== "object")
+        return;
+    for (const [path, at] of buildDrivenSlotMap(schema).paths) {
+        if (at.steps.length > 0)
+            visit({ kind: "step", slots: at.steps, path });
+        if (at.refs.length > 0)
+            visit({ kind: "ref", slots: at.refs.map(refSlotOfEntry), path });
+    }
+}
 /**
  * Every slot of one resource through which it drives another, schema and data in
  * tandem.
  *
- * One traversal with two consumers — the inherited union here, and the catch
- * scope enclosure in `validate-throws-coverage.ts` — because both ask the same
- * structural question and two copies would eventually disagree about where the
- * walk stops. It terminates on the manifest's own depth, and it stops AT a step
- * slot (that traversal owns everything below it, `try`/`catch` subtraction
- * included) and AT a reference slot (a resolved ref is a leaf, `{kind, name}`,
- * with nothing beneath it to visit).
+ * One traversal for every throws question — a kind's `inherit` union, a scope
+ * list's denominator, catch-scope enclosure, and whether `inherit` is legal —
+ * because they ask the same structural question and two copies would eventually
+ * disagree about where the walk stops. The slots are the driven-slot map's, so
+ * the reach is the reference field map's plus local `$ref`; a step slot is a
+ * stop (that traversal owns everything below it, `try`/`catch` subtraction
+ * included) and so is a reference slot (a resolved ref is a leaf).
+ *
+ * Each concrete site is visited once, with every slot that reaches it. A
+ * map-value (`additionalProperties`) slot applies only to keys its schema does
+ * not declare, and never to the resource envelope at the root, as JSON Schema
+ * applies it. A recursive schema's back-edge is followed as deep as the data
+ * goes, guarded against data that aliases one of its own ancestors. A schema
+ * whose map holds no step or reference slot is not walked at all.
  */
-export function forEachDrivenSlot(schema, data, visit, path = "") {
+export function forEachDrivenSlot(schema, data, visit) {
     if (!schema || typeof schema !== "object" || data === undefined || data === null)
         return;
-    const node = schema;
-    const stepSlot = readStepSlot(node);
-    if (stepSlot) {
-        if (Array.isArray(data))
-            visit({ kind: "step", slot: stepSlot, data, path });
-        return;
-    }
-    const refSlot = readRefSlot(node);
-    if (refSlot) {
-        visit({ kind: "ref", slot: refSlot, data, path });
+    const driven = buildDrivenSlotMap(schema);
+    if (!driven.drives)
         return;
-    }
-    const props = node.properties;
-    if (props && typeof data === "object" && !Array.isArray(data)) {
-        const obj = data;
-        for (const [key, propSchema] of Object.entries(props)) {
-            if (obj[key] === undefined)
+    const sites = new Map();
+    const onData = new Set([data]);
+    const walk = (prefix, value, base) => {
+        for (const [fieldPath, at] of driven.paths) {
+            const rel = relativeFieldPath(fieldPath, prefix);
+            if (rel === undefined)
                 continue;
-            forEachDrivenSlot(propSchema, obj[key], visit, path ? `${path}.${key}` : key);
+            for (const found of resolveSites(value, rel, prefix, driven)) {
+                const path = joinConcrete(base, found.path);
+                if (at.steps.length > 0 || at.refs.length > 0) {
+                    let site = sites.get(path);
+                    if (!site) {
+                        site = { data: found.value, steps: [], refs: [], from: new Set() };
+                        sites.set(path, site);
+                    }
+                    for (const step of at.steps) {
+                        if (site.from.has(step))
+                            continue;
+                        site.from.add(step);
+                        site.steps.push(step);
+                    }
+                    for (const entry of at.refs) {
+                        if (site.from.has(entry))
+                            continue;
+                        site.from.add(entry);
+                        site.refs.push({ slot: refSlotOfEntry(entry), fieldPath });
+                    }
+                }
+                if (at.recurse.length === 0)
+                    continue;
+                if (!found.value || typeof found.value !== "object" || onData.has(found.value))
+                    continue;
+                onData.add(found.value);
+                for (const to of at.recurse)
+                    walk(to, found.value, path);
+                onData.delete(found.value);
+            }
+        }
+    };
+    walk("", data, "");
+    for (const [path, site] of sites) {
+        if (site.steps.length > 0 && Array.isArray(site.data)) {
+            visit({ kind: "step", slots: site.steps, data: site.data, path });
+        }
+        else if (site.refs.length > 0) {
+            visit({ kind: "ref", slots: site.refs, data: site.data, path });
         }
     }
-    if (node.items && Array.isArray(data)) {
-        for (const [i, item] of data.entries()) {
-            forEachDrivenSlot(node.items, item, visit, `${path}[${i}]`);
+}
+/** The values at `rel` below `value`, where `rel` is relative to the field path
+ *  `prefix`. A `{}` segment skips the keys the driven map records as declared
+ *  for that map path; each `[]` iterates one array level. */
+function resolveSites(value, rel, prefix, driven) {
+    let sites = [{ value, path: "" }];
+    let field = prefix;
+    for (const part of rel.split(".")) {
+        const next = [];
+        if (part === "{}") {
+            field = joinKey(field, "{}");
+            const declared = driven.declaredKeys.get(field);
+            for (const site of sites) {
+                if (!site.value || typeof site.value !== "object" || Array.isArray(site.value))
+                    continue;
+                for (const [key, entry] of Object.entries(site.value)) {
+                    if (entry == null || declared?.has(key))
+                        continue;
+                    next.push({ value: entry, path: joinKey(site.path, key) });
+                }
+            }
         }
+        else {
+            const key = part.replace(/(\[\])+$/, "");
+            const depth = (part.length - key.length) / 2;
+            field = key ? joinKey(field, part) : `${field}${part}`;
+            for (const site of sites) {
+                let level;
+                if (key) {
+                    if (!site.value || typeof site.value !== "object")
+                        continue;
+                    const entry = site.value[key];
+                    if (entry == null)
+                        continue;
+                    level = [{ value: entry, path: joinKey(site.path, key) }];
+                }
+                else {
+                    level = [site];
+                }
+                for (let d = 0; d < depth; d++) {
+                    const items = [];
+                    for (const holder of level) {
+                        if (!Array.isArray(holder.value))
+                            continue;
+                        holder.value.forEach((item, i) => {
+                            if (item != null)
+                                items.push({ value: item, path: `${holder.path}[${i}]` });
+                        });
+                    }
+                    level = items;
+                }
+                next.push(...level);
+            }
+        }
+        sites = next;
     }
+    return sites;
+}
+const joinKey = (path, key) => (path ? `${path}.${key}` : key);
+/** `fieldPath` relative to `prefix`, or undefined when it is not strictly
+ *  below it. A result starting `[]` iterates the value at `prefix` itself. */
+function relativeFieldPath(fieldPath, prefix) {
+    if (prefix === "")
+        return fieldPath;
+    if (fieldPath.startsWith(`${prefix}.`))
+        return fieldPath.slice(prefix.length + 1);
+    if (fieldPath.startsWith(`${prefix}[]`))
+        return fieldPath.slice(prefix.length);
+    return undefined;
+}
+function joinConcrete(base, rel) {
+    if (!base)
+        return rel;
+    return rel.startsWith("[") ? `${base}${rel}` : `${base}.${rel}`;
 }

package/dist/scope-declarations.d.ts

@@ -0,0 +1,59 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import { type ReferenceFieldMap } from "./reference-field-map.js";
+/**
+ * The execution scopes ONE resource declares — the `x-telo-scope` arrays it
+ * holds — read off its kind's field map, which is the analyzer's single
+ * definition of "scope" (the same one `resolve-ref-sentinels` and
+ * `manifest-visitor` read). Inferring a scope from shape instead would give one
+ * to any kind that happens to carry an array of named declarations.
+ *
+ * Browser-safe.
+ */
+/** One declared scope: the array a scope run creates, and where its names resolve. */
+export interface DeclaredScope {
+    /** Concrete path of the scope slot on its resource (`with`). */
+    path: string;
+    /** The declaration array itself — what a scope run registers and tears down. */
+    declarations: unknown[];
+    /** Dot-form prefixes of every region its names resolve in (`steps`, `targets`). */
+    regions: string[];
+}
+export type ScopeMember = ResourceManifest & {
+    metadata: {
+        name: string;
+    };
+};
+/** Every scope `resource` declares, in field-map order. A scope slot left unset
+ *  declares nothing: no scope run happens, so nothing is created in one. */
+export declare function declaredScopes(resource: Record<string, unknown>, fieldMap: ReferenceFieldMap | undefined): DeclaredScope[];
+/** True when `path` — a field-map path (`steps[].invoke`) or a concrete one
+ *  (`steps[0].invoke`) — lies inside one of the scope's regions. */
+export declare function scopeEncloses(scope: DeclaredScope, path: string): boolean;
+/** A scope's inline resource declarations. A `!ref` entry is a category error
+ *  (`SCOPE_ENTRY_NOT_INLINE`), not a member. */
+export declare function scopeMembers(scope: DeclaredScope): ScopeMember[];
+/** True when a scope array entry is an inline resource declaration. */
+export declare function isScopeMember(value: unknown): value is ScopeMember;
+/**
+ * A scope an extracted declaration was WRITTEN inside and is NOT created in.
+ *
+ * An inline declaration is created in the set its owner is declared in, never in
+ * a scope its owner declares — moving it there would make every step target of a
+ * sequence with a `with:` block a scoped resource, which is a change of durable
+ * identity. So a declaration written in `steps:` next to a `with:` block is
+ * lexically inside that scope and lives outside it, and the names the scope
+ * declares are out of its reach. Recorded at extraction, where both facts are in
+ * hand, as `metadata.xTeloOrigin.outsideScopes`.
+ */
+export interface OutsideScope {
+    /** The resource declaring the scope, as its manifest spells it. */
+    ownerKind: string;
+    ownerName: string;
+    /** The scope slot (`with`). */
+    field: string;
+    /** Every name the scope declares. */
+    names: string[];
+}
+/** The scopes recorded as out of reach for an extracted declaration. */
+export declare function outsideScopesOf(manifest: unknown): OutsideScope[];
+//# sourceMappingURL=scope-declarations.d.ts.map

package/dist/scope-declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-declarations.d.ts","sourceRoot":"","sources":["../src/scope-declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAqC,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAErG;;;;;;;;GAQG;AAEH,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,YAAY,EAAE,OAAO,EAAE,CAAC;IACxB,mFAAmF;IACnF,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG;IAAE,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAE5E;4EAC4E;AAC5E,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,aAAa,EAAE,CAYjB;AAED;oEACoE;AACpE,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzE;AAED;gDACgD;AAChD,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,EAAE,CAEhE;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAOlE;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,YAAY,EAAE,CAMjE"}

package/dist/scope-declarations.js

@@ -0,0 +1,45 @@
+import { isRefSentinel } from "@telorun/templating";
+import { isScopeEntry, resolveFieldEntries } from "./reference-field-map.js";
+/** Every scope `resource` declares, in field-map order. A scope slot left unset
+ *  declares nothing: no scope run happens, so nothing is created in one. */
+export function declaredScopes(resource, fieldMap) {
+    if (!fieldMap)
+        return [];
+    const out = [];
+    for (const [fieldPath, entry] of fieldMap) {
+        if (!isScopeEntry(entry))
+            continue;
+        const pointers = Array.isArray(entry.scope) ? entry.scope : [entry.scope];
+        const regions = pointers.map((p) => p.replace(/^\//, "").replace(/\//g, "."));
+        for (const { value, path } of resolveFieldEntries(resource, fieldPath)) {
+            if (Array.isArray(value))
+                out.push({ path, declarations: value, regions });
+        }
+    }
+    return out;
+}
+/** True when `path` — a field-map path (`steps[].invoke`) or a concrete one
+ *  (`steps[0].invoke`) — lies inside one of the scope's regions. */
+export function scopeEncloses(scope, path) {
+    return scope.regions.some((region) => path === region || path.startsWith(`${region}.`) || path.startsWith(`${region}[`));
+}
+/** A scope's inline resource declarations. A `!ref` entry is a category error
+ *  (`SCOPE_ENTRY_NOT_INLINE`), not a member. */
+export function scopeMembers(scope) {
+    return scope.declarations.filter(isScopeMember);
+}
+/** True when a scope array entry is an inline resource declaration. */
+export function isScopeMember(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || isRefSentinel(value)) {
+        return false;
+    }
+    const entry = value;
+    const name = entry.metadata?.name;
+    return typeof entry.kind === "string" && typeof entry.name !== "string" && typeof name === "string";
+}
+/** The scopes recorded as out of reach for an extracted declaration. */
+export function outsideScopesOf(manifest) {
+    const origin = (manifest
+        ?.metadata?.xTeloOrigin)?.outsideScopes;
+    return Array.isArray(origin) ? origin : [];
+}

package/dist/source-entries.d.ts

@@ -0,0 +1,119 @@
+/**
+ * A module's **sources** — the `sources:` block on a `Telo.Library` or
+ * `Telo.Application` doc, saying where every staged file comes from: a pinned
+ * upstream archive, fetched by `telo release stage`.
+ *
+ * ```yaml
+ * sources:
+ *   better-sqlite3:
+ *     version: 12.8.0
+ *     url: https://github.com/WiseLibs/better-sqlite3/releases/download/v{version}/better-sqlite3-v{version}-{upstream}.tar.gz
+ *     archive: tar.gz
+ *     notices: [./notices/better-sqlite3.LICENSE]
+ *     entries:
+ *       ./native/linux-amd64-gnu-node-137/better_sqlite3.node:
+ *         upstream: node-v137-linux-x64
+ *         member: build/Release/better_sqlite3.node
+ *         sha256: 4c9e…
+ *         executable: false
+ *       ./native/linux-amd64-gnu/libvips.so:
+ *         target: libvips.so.42
+ * ```
+ *
+ * Keyed by the module-relative path an entry produces, because the manifest
+ * already names every staged file — a `native:` entry's path or a
+ * platform-qualified controller candidate's `path=`.
+ *
+ * The single reader: every rule decidable from the block alone is a problem
+ * here, so `telo check` (`validate-source-entries.ts`), the stager and the
+ * kernels refuse the same blocks. Browser-safe: string work only.
+ */
+/** The archive formats an upstream may be. */
+export declare const SOURCE_ARCHIVE_FORMATS: readonly ["tar.gz"];
+export type SourceArchiveFormat = (typeof SOURCE_ARCHIVE_FORMATS)[number];
+export interface SourcePin {
+    /** Lowercase hex digest of the file's bytes. */
+    readonly sha256: string;
+    readonly executable: boolean;
+}
+interface SourceEntryBase {
+    /** The key as written, for diagnostic paths. */
+    readonly key: string;
+    /** Module-root-relative POSIX path, normalized. */
+    readonly path: string;
+}
+export type SourceEntry = (SourceEntryBase & {
+    readonly kind: "file";
+    readonly upstream: string;
+    /** Path of the file inside the archive. */
+    readonly member: string;
+    /** Absent until `telo release stage --pin` writes it. */
+    readonly pin?: SourcePin;
+}) | (SourceEntryBase & {
+    readonly kind: "link";
+    /** The link target, exactly as the link stores it. */
+    readonly target: string;
+    /** The module-relative path the target resolves to. */
+    readonly resolved: string;
+});
+/** How a source's files are built in this repository, keyed by build system. */
+export interface SourceBuild {
+    /** Module-root-relative directory of the Cargo crate the files are built
+     *  from, normalized (`""` for the module root). */
+    readonly cargo: string;
+    /** Digest of that crate's build inputs, `sha256-<base64url>`; absent until
+     *  `telo release stage --pin` records it. */
+    readonly inputs?: string;
+}
+export interface ModuleSource {
+    readonly name: string;
+    readonly version: string;
+    /** The URL template, as written. */
+    readonly url: string;
+    readonly archive: SourceArchiveFormat;
+    /** Module-root-relative notice paths, normalized. */
+    readonly notices: readonly string[];
+    readonly entries: readonly SourceEntry[];
+    readonly build?: SourceBuild;
+}
+/**
+ * Why part of the block could not be read.
+ *
+ * `SHAPE` is a missing, mistyped or unknown key the owner doc's JSON Schema
+ * reports in the same pass; every other code is a rule `telo check` reports.
+ */
+export type SourceProblemCode = "SHAPE" | "SOURCE_INVALID" | "SOURCE_URL_PLACEHOLDER_UNKNOWN" | "SOURCE_URL_INSECURE" | "SOURCE_ENTRY_INVALID" | "SOURCE_LINK_TARGET_UNRESOLVED" | "SOURCE_LINK_CYCLE" | "SOURCE_ENTRY_DUPLICATE" | "SOURCE_ENTRY_NESTED";
+export interface SourceProblem {
+    readonly code: SourceProblemCode;
+    /** Dotted path from the module doc root, for `data.path`. */
+    readonly path: string;
+    readonly message: string;
+}
+export interface ModuleSources {
+    readonly sources: ModuleSource[];
+    readonly problems: SourceProblem[];
+}
+/** The URL an entry is fetched from: substitution only. */
+export declare function resolveSourceUrl(source: ModuleSource, upstream: string): string;
+/** Why a url — a template, or the URL a fetch ended at after redirects — may not
+ *  be fetched from, or undefined when it may: https, or plain http to a loopback
+ *  host. */
+export declare function sourceUrlProblem(url: string): {
+    code: SourceProblemCode;
+    detail: string;
+} | undefined;
+/**
+ * Read the `sources:` block off an owner document's JSON projection.
+ *
+ * A source or entry with any problem is left out, never read partially: a
+ * half-read entry would stage a file the author did not declare.
+ *
+ * `ignorePins` reads a file entry's `sha256` / `executable` and a build's
+ * `inputs` as absent — for the one writer of pins, which replaces them whatever
+ * they held.
+ */
+export declare function readModuleSources(ownerJson: unknown, options?: {
+    ignorePins?: boolean;
+}): ModuleSources;
+export {};
+//# sourceMappingURL=source-entries.d.ts.map

package/dist/source-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-entries.d.ts","sourceRoot":"","sources":["../src/source-entries.ts"],"names":[],"mappings":"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"}