@ingestron/core 0.12.0

package/dist/core/execution.js

@@ -0,0 +1,297 @@
+/** Explicit execution boundary. Compilation never calls this module's launcher. */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, rmSync, } from "node:fs";
+import { resolve, relative } from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { parseEnv } from "node:util";
+import { z } from "zod";
+import { check, digest, canonical, Problem } from "./errors.js";
+import { fence, resolvePackage, packageYaml, providerPackageSchema, } from "./packages.js";
+import { validateOutput } from "./generate.js";
+import { checkProviderCompatibility } from "../plugins/compatibility.js";
+const id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/);
+const selection = {
+    from: z.string().optional(),
+    provider: id.optional(),
+    flow: id.optional(),
+};
+export const executionSchemas = {
+    runtime_prepare: z
+        .object({ ...selection, python: z.string().optional() })
+        .strict(),
+    run: z
+        .object({
+        ...selection,
+        action: z.enum(["discover", "review", "approve", "run"]).default("run"),
+        runId: id.optional(),
+        retry: id.optional(),
+        envFile: z.string().optional(),
+    })
+        .strict(),
+    run_status: z.object({ id }).strict(),
+};
+const now = () => new Date().toISOString();
+function store(file, value) {
+    const temp = file + "." + randomUUID() + ".tmp";
+    writeFileSync(temp, JSON.stringify(value, null, 2) + "\n", {
+        mode: 0o600,
+        flag: "wx",
+    });
+    renameSync(temp, file);
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function receipt(root, runId) {
+    const file = fence(root, `.ingestron/runs/${runId}.json`);
+    check(existsSync(file), "RUN", "Unknown run identity");
+    const value = JSON.parse(readFileSync(file, "utf8"));
+    check(value.apiVersion === "ingestron.run/v1", "RUN", "Invalid run receipt");
+    if (value.status === "running" && !alive(value.pid))
+        value.status = "indeterminate";
+    return value;
+}
+async function launch(python, entry, request, cwd, env) {
+    return await new Promise((done, reject) => {
+        const child = spawn(python, [entry], {
+            cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+        });
+        let output = "", bytes = 0, stopped = false;
+        const signal = (s) => {
+            try {
+                process.platform === "win32"
+                    ? child.kill(s)
+                    : process.kill(-child.pid, s);
+            }
+            catch { }
+        };
+        let killTimer;
+        const stop = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            signal("SIGINT");
+            killTimer = setTimeout(() => signal("SIGKILL"), 10000);
+        };
+        const timer = setTimeout(stop, 30 * 60 * 1000);
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        const cleanup = () => {
+            clearTimeout(timer);
+            clearTimeout(killTimer);
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+        };
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > 10_000_000)
+                stop();
+            else
+                output += chunk;
+        });
+        child.stderr.on("data", () => { }); // Source errors may contain credentials.
+        child.stdin.on("error", () => { });
+        child.on("error", () => {
+            cleanup();
+            reject(new Problem("RUNTIME", "Python could not start; install python3 for the local execution adapter"));
+        });
+        child.on("close", (code) => {
+            cleanup();
+            if (stopped) {
+                reject(new Problem("INTERRUPTED", "Execution interrupted or timed out; inspect its receipt before retrying"));
+                return;
+            }
+            try {
+                const result = JSON.parse(output);
+                check(result.apiVersion === "ingestron.execution-result/v1", "RUNTIME", "Invalid provider execution result");
+                check(code === 0 && result.status === "succeeded", "RUNTIME", result.message ?? "Provider execution failed");
+                done(result);
+            }
+            catch (error) {
+                reject(error instanceof Problem
+                    ? error
+                    : new Problem("RUNTIME", "Provider execution failed; upstream output withheld"));
+            }
+        });
+        child.stdin.end(JSON.stringify(request));
+    });
+}
+export async function performExecution(context, operation, args) {
+    const root = resolve(context.root), environment = context.environment ?? "dev";
+    if (operation === "run_status")
+        return receipt(root, args.id);
+    check(context.allowExecute && context.allowWrite, "PERMISSION", "Execution requires allowExecute and allowWrite in the operation context");
+    check(process.platform !== "win32", "CAPABILITY", "Local connector execution currently requires POSIX; use a supported Linux environment");
+    if (operation === "runtime_prepare")
+        check(context.allowNetwork, "PERMISSION", "Runtime preparation requires dependency-network access");
+    check(!(args.flow && args.provider), "SELECT", "Choose flow or provider");
+    check(!(args.retry &&
+        (args.flow || args.provider || args.runId || args.action !== "run")), "SELECT", "Retry uses the recorded run selection and identity");
+    const previous = args.retry ? receipt(root, args.retry) : undefined;
+    if (previous) {
+        check(previous.action === "run" && previous.environment === environment, "RUN", "Retry requires a data run in the selected environment");
+        check(previous.status !== "running", "RUN", "Run is still active");
+    }
+    check(!previous || !args.from || args.from === previous.from, "SELECT", "Retry uses its recorded build directory");
+    const from = previous?.from ?? args.from ?? "build/generated";
+    const directory = fence(root, from);
+    check(existsSync(resolve(directory, "ingestron-project.json")), "BUILD", "Build the project first; supply from to select a different output directory");
+    const checked = validateOutput(directory);
+    check(checked.ownership === "managed", "OWNERSHIP", "Execution requires an unchanged managed build");
+    const build = JSON.parse(readFileSync(resolve(directory, "ingestron-project.json"), "utf8"));
+    check(build.apiVersion === "ingestron.project-build/v1" &&
+        build.environment === environment, "BUILD", "Build environment differs; rebuild for this environment");
+    for (const [file, hash] of Object.entries(build.sourceFiles ?? {}))
+        check(existsSync(fence(root, file)) &&
+            digest(readFileSync(fence(root, file))) === hash, "STALE", `Project input changed: ${file}; rebuild before execution`);
+    check(build.packageLockSha256 ===
+        digest(readFileSync(fence(root, "packages.lock.yaml"))), "STALE", "Package lock changed; rebuild before execution");
+    const candidates = build.packages.filter((p) => previous
+        ? p.configuration === previous.configuration
+        : args.provider
+            ? p.configuration === args.provider
+            : args.flow
+                ? p.scope.flows.includes(args.flow)
+                : true);
+    check(candidates.length === 1, "SELECT", "Select one execution target with provider or flow");
+    const pkg = candidates[0];
+    const installed = resolvePackage(root, pkg.reference);
+    check(installed.entry.commit === pkg.commit, "STALE", "Execution provider changed; rebuild");
+    const manifest = providerPackageSchema.parse(packageYaml(installed.file));
+    checkProviderCompatibility(manifest);
+    const capability = manifest.execution;
+    check(capability, "NOT_IMPLEMENTED", `${pkg.configuration}: run and runtime preparation are not implemented by this provider; build remains available. Cloud deployment requires separate review`);
+    check(capability.transport === "local-python/v1", "NOT_IMPLEMENTED", "This execution transport is not implemented by this host");
+    const action = operation === "runtime_prepare" ? "prepare" : args.action;
+    check(capability.actions.includes(action), "NOT_IMPLEMENTED", "Provider does not support this execution action");
+    const flows = previous?.flows ?? (args.flow ? [args.flow] : pkg.scope.flows);
+    const fingerprint = digest(canonical({
+        plan: checked.planDigest,
+        configuration: pkg.configuration,
+        flows,
+    }));
+    if (previous)
+        check(previous.fingerprint === fingerprint, "STALE", "Retry requires the same build and flow selection");
+    const target = fence(directory, pkg.directory === "."
+        ? capability.entryPoint
+        : pkg.directory.replace(/\/$/, "") + "/" + capability.entryPoint);
+    const packageRoot = pkg.directory === "."
+        ? directory
+        : fence(directory, pkg.directory.replace(/\/$/, ""));
+    const cache = fence(root, ".ingestron/runtimes");
+    mkdirSync(cache, { recursive: true });
+    const runs = fence(root, ".ingestron/runs");
+    mkdirSync(runs, { recursive: true });
+    const runId = previous?.id ?? args.runId ?? randomUUID();
+    const file = fence(runs, runId + ".json");
+    check(previous || !existsSync(file), "RUN", "Run identity already exists; supply retry to repeat it");
+    const guard = fence(runs, runId + ".lock");
+    if (previous?.status === "indeterminate" && existsSync(guard))
+        rmSync(guard, { recursive: true });
+    try {
+        mkdirSync(guard);
+    }
+    catch {
+        throw new Problem("RUN", "Run is already active");
+    }
+    const record = {
+        apiVersion: "ingestron.run/v1",
+        id: runId,
+        action,
+        status: "running",
+        pid: process.pid,
+        environment,
+        project: build.project,
+        provider: pkg.reference,
+        providerCommit: pkg.commit,
+        from: relative(root, directory),
+        configuration: pkg.configuration,
+        flows,
+        fingerprint,
+        attempt: (previous?.attempt ?? 0) + 1,
+        startedAt: now(),
+    };
+    try {
+        store(file, record);
+        const env = {};
+        for (const key of [
+            "PATH",
+            "HOME",
+            "TMPDIR",
+            "LANG",
+            "SSL_CERT_FILE",
+            "HTTPS_PROXY",
+            "HTTP_PROXY",
+            "NO_PROXY",
+        ])
+            if (process.env[key])
+                env[key] = process.env[key];
+        const provided = args.envFile
+            ? parseEnv(readFileSync(fence(root, args.envFile), "utf8"))
+            : {};
+        const allow = new Set();
+        const secrets = (value) => {
+            if (!value || typeof value !== "object")
+                return;
+            if (value.$secret?.env)
+                allow.add(value.$secret.env);
+            for (const v of Object.values(value))
+                secrets(v);
+        };
+        for (const flow of flows) {
+            const config = JSON.parse(readFileSync(fence(packageRoot, `flows/${flow}/connector.json`), "utf8"));
+            secrets(config.sourceSettings);
+            if (config.configEnv)
+                allow.add(config.configEnv);
+        }
+        for (const name of allow) {
+            check(/^[A-Za-z_][A-Za-z0-9_]*$/.test(name), "SECRET", "Invalid environment reference");
+            check(!/^(PYTHON|PIP|LD_|DYLD_)/.test(name) &&
+                !["PATH", "HOME", "TMPDIR"].includes(name), "SECRET", "Secret names cannot override execution environment controls");
+            const value = provided[name] ?? process.env[name];
+            if (value !== undefined)
+                env[name] = value;
+        }
+        env.PYTHONNOUSERSITE = "1";
+        env.PYTHONDONTWRITEBYTECODE = "1";
+        const result = await launch("python3", target, {
+            apiVersion: "ingestron.execution-request/v1",
+            action,
+            flows,
+            runId,
+            cache,
+            python: args.python,
+        }, packageRoot, env);
+        const complete = {
+            ...record,
+            status: "succeeded",
+            finishedAt: now(),
+            result,
+        };
+        store(file, complete);
+        return complete;
+    }
+    catch (error) {
+        store(file, {
+            ...record,
+            status: error instanceof Problem && error.code === "INTERRUPTED"
+                ? "interrupted"
+                : "failed",
+            finishedAt: now(),
+            error: "Execution failed; source details withheld",
+        });
+        throw new Problem(error instanceof Problem ? error.code : "RUNTIME", `${error instanceof Problem ? error.message : "Execution failed"}. Run ${runId}; inspect run_status for this run identity`);
+    }
+    finally {
+        rmSync(guard, { recursive: true, force: true });
+    }
+}

package/dist/core/extension-packs.d.ts

@@ -0,0 +1,8 @@
+import { Configuration } from "./config.js";
+import { providerPackageSchema } from "./packages.js";
+import type { Project } from "./schema.js";
+/** Resolve explicit direct packs only. Every input is fingerprinted by the host. */
+export declare function extensionActivities(reader: Configuration, project: Project, names: string[], provider: ReturnType<typeof providerPackageSchema.parse>): Record<string, {
+    uses: string;
+    with: Record<string, unknown>;
+}>;

package/dist/core/extension-packs.js

@@ -0,0 +1,34 @@
+import { check } from "./errors.js";
+import { extensionPackSchema, packageYaml, resolvePackage, fence, } from "./packages.js";
+/** Resolve explicit direct packs only. Every input is fingerprinted by the host. */
+export function extensionActivities(reader, project, names, provider) {
+    const result = {};
+    check(new Set(names).size === names.length, "PACK", "Duplicate configured extension pack");
+    for (const name of names) {
+        const selection = project.providers.packs[name];
+        check(selection, "PACK", `Unknown extension pack ${name}`);
+        const source = selection.source.startsWith(".")
+            ? {
+                file: reader.path(fence(reader.root, selection.source.replace(/^\.\//, ""))),
+            }
+            : resolvePackage(reader.root, `${selection.source}@${selection.version}`);
+        const pack = extensionPackSchema.parse(packageYaml(source.file));
+        reader.text(source.file);
+        if (!selection.source.startsWith("."))
+            reader.text("packages.lock.yaml");
+        check(selection.version === pack.version ||
+            (/^[a-f0-9]{40}$/.test(selection.version) &&
+                !selection.source.startsWith(".")), "PACK", `Pack ${name} version differs from selector`);
+        check(pack.extends.provider === provider.id &&
+            pack.extends.version === provider.version &&
+            pack.extends.platform === provider.platform, "PACK", `Pack ${name} requires ${pack.extends.provider}@${pack.extends.version} on ${pack.extends.platform}`);
+        check(provider.capabilities?.packContracts[pack.extends.contract]?.version ===
+            pack.extends.contractVersion, "PACK", `Pack ${name} requires unsupported extension contract ${pack.extends.contract}@${pack.extends.contractVersion}`);
+        for (const [alias, activity] of Object.entries(pack.activities)) {
+            check(provider.capabilities.packContracts[pack.extends.contract].activities.includes(activity.uses), "PACK", `Pack ${name} activity ${activity.uses} is outside extension contract ${pack.extends.contract}`);
+            check(Object.hasOwn(provider.activities, activity.uses), "PACK", `Pack ${name} references unknown provider activity ${activity.uses}`);
+            result[`${name}:${alias}`] = activity;
+        }
+    }
+    return result;
+}

package/dist/core/fingerprint.d.ts

@@ -0,0 +1 @@
+export declare function compilerFingerprint(): string;

package/dist/core/fingerprint.js

@@ -0,0 +1,16 @@
+import { installationRoot } from "./installation.js";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { canonical, digest, check } from "./errors.js";
+export function compilerFingerprint() {
+    const root = installationRoot;
+    const file = resolve(root, "dist/compiler-fingerprint.json");
+    check(existsSync(file), "COMPILER", "Build core before planning (pnpm build)");
+    const manifest = JSON.parse(readFileSync(file, "utf8"));
+    for (const [name, hash] of Object.entries(manifest.files))
+        check(digest(readFileSync(resolve(root, name))) === hash, "COMPILER", "Compiler installation changed; rebuild or reinstall the pinned package");
+    if (import.meta.url.endsWith(".ts"))
+        for (const [name, hash] of Object.entries(manifest.sources))
+            check(digest(readFileSync(resolve(root, name))) === hash, "COMPILER", "Source changed since compilation; run pnpm build before planning");
+    return digest(canonical(manifest));
+}

package/dist/core/generate.d.ts

@@ -0,0 +1,16 @@
+import type { Plan } from "./schema.js";
+export type Files = Record<string, string>;
+export declare function verifyPlan(root: string, plan: Plan): void;
+export declare function validateGeneratedFiles(files: Files): void;
+export declare function renderProject(root: string, plan: Plan): Files;
+export declare function writeOutput(directory: string, plan: Pick<Plan, "project" | "environment" | "selection" | "digest">, files: Files, ownership?: "managed" | "team"): {
+    directory: string;
+    files: number;
+    digest: string;
+};
+export declare function validateOutput(directory: string): {
+    files: number;
+    planDigest: string;
+    evidence: string;
+    ownership: "managed" | "team";
+};

package/dist/core/generate.js

@@ -0,0 +1,198 @@
+import { generateProvider } from "../plugins/generation.js";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, lstatSync, realpathSync, renameSync, rmSync, mkdtempSync, } from "node:fs";
+import { resolve, dirname, isAbsolute } from "node:path";
+import { parseDocument } from "yaml";
+import { parser as pythonParser } from "@lezer/python";
+import { check, canonical, digest, Problem } from "./errors.js";
+import { Configuration } from "./config.js";
+import { compilerFingerprint } from "./fingerprint.js";
+import { version } from "../version.js";
+const json = (value) => JSON.stringify(value, null, 2) + "\n";
+export function verifyPlan(root, plan) {
+    const { digest: expected, ...body } = plan;
+    check(plan.apiVersion === "ingestron.plan/v1" &&
+        digest(canonical(body)) === expected, "PLAN", "Plan content digest is invalid");
+    check(plan.compilerVersion === version, "STALE", "Compiler version changed; create a new plan");
+    for (const [name, hash] of Object.entries(plan.inputDigests))
+        check(process.env[name] !== undefined && digest(process.env[name]) === hash, "STALE", `Environment input changed since planning: ${name}`);
+    check(plan.compilerDigest === compilerFingerprint(), "STALE", "Compiler content changed since planning; create a new plan");
+    const reader = new Configuration(root);
+    for (const [file, hash] of Object.entries(plan.files))
+        check(digest(reader.text(file)) === hash, "STALE", `Input changed since planning: ${file}`);
+}
+export function validateGeneratedFiles(files) {
+    for (const [name, source] of Object.entries(files)) {
+        const pythonSources = name.endsWith(".py")
+            ? [source]
+            : name.endsWith(".ipynb")
+                ? JSON.parse(source)
+                    .cells.filter((cell) => cell.cell_type === "code")
+                    .map((cell) => Array.isArray(cell.source) ? cell.source.join("") : cell.source)
+                : [];
+        for (const python of pythonSources) {
+            let bad = false;
+            pythonParser.parse(python).iterate({
+                enter(node) {
+                    if (node.type.isError)
+                        bad = true;
+                },
+            });
+            check(!bad, "PYTHON", `Generated Python syntax invalid: ${name}`);
+        }
+        if (name.endsWith(".json") || name.endsWith(".ipynb"))
+            JSON.parse(source);
+        if (/\.ya?ml$/.test(name))
+            check(!parseDocument(source, { uniqueKeys: true }).errors.length, "YAML", `Generated YAML syntax invalid: ${name}`);
+    }
+}
+export function renderProject(root, plan) {
+    verifyPlan(root, plan);
+    const files = generateProvider(root, plan);
+    validateGeneratedFiles(files);
+    return files;
+}
+const manifestName = "ingestron-manifest.json";
+function outputPath(root, name) {
+    check(!isAbsolute(name) &&
+        !name.includes("\\") &&
+        name.split("/").every((p) => p && ![".", ".."].includes(p)), "PATH", "Unsafe generated output path");
+    let at = root;
+    for (const p of name.split("/")) {
+        at = resolve(at, p);
+        check(!existsSync(at) || !lstatSync(at).isSymbolicLink(), "PATH", "Generated output cannot cross symlinks");
+    }
+    return at;
+}
+export function writeOutput(directory, plan, files, ownership = "managed") {
+    directory = resolve(directory);
+    check(!existsSync(directory) || !lstatSync(directory).isSymbolicLink(), "PATH", "Output directory cannot be a symlink");
+    mkdirSync(directory, { recursive: true });
+    directory = realpathSync(directory);
+    const manifestFile = outputPath(directory, manifestName), previous = existsSync(manifestFile)
+        ? JSON.parse(readFileSync(manifestFile, "utf8"))
+        : undefined;
+    check(previous?.ownership !== "team", "OWNER", "This project is team-maintained. Generate into a new directory and review the diff; existing source will not be overwritten.");
+    if (ownership === "team") {
+        check(!previous && readdirSync(directory).length === 0, "OWNER", "Team export requires a new or empty output directory");
+        files = {
+            ...files,
+            "OWNERSHIP.md": "# Team-maintained project\n\nThe team owns this source and configuration. Ingestron will not regenerate into this directory. Compiler provenance describes the original export, not subsequent edits. No Ingestron runtime is needed. Review changes through Git and run ingestron validate-output on this directory. Maintain business tests, native acceptance and documentation in your own Git workflow.\n",
+        };
+    }
+    if (previous) {
+        check(canonical(previous.selection) === canonical(plan.selection), "OWNER", "Use a separate output directory for each selected flow/table/step scope");
+        check(previous.apiVersion === "ingestron.output/v1" &&
+            previous.project === plan.project &&
+            previous.environment === plan.environment, "OWNER", "Output directory belongs to another project/environment");
+        for (const [name, hash] of Object.entries(previous.files))
+            check(existsSync(outputPath(directory, name)) &&
+                digest(readFileSync(outputPath(directory, name))) === hash, "CONFLICT", `Generated output was edited or removed: ${name}`);
+    }
+    for (const name of Object.keys(files))
+        check(!existsSync(outputPath(directory, name)) || !!previous?.files[name], "OWNER", `Refusing to overwrite unowned file ${name}`);
+    // Output directories own exactly one generation scope. Remove only unchanged owned files.
+    const merged = Object.fromEntries(Object.entries(files).map(([name, text]) => [
+        name,
+        digest(name.endsWith(".whl") ? Buffer.from(text, "base64") : text),
+    ]));
+    const manifest = {
+        apiVersion: "ingestron.output/v1",
+        project: plan.project,
+        environment: plan.environment,
+        planDigest: plan.digest,
+        selection: plan.selection,
+        files: merged,
+        ownership,
+    };
+    const guard = outputPath(directory, ".ingestron-generate.lock");
+    try {
+        writeFileSync(guard, plan.digest, { flag: "wx" });
+    }
+    catch {
+        throw new Problem("CONFLICT", "Another generator owns this output directory");
+    }
+    const stage = mkdtempSync(resolve(directory, ".generate-")), touched = [], before = new Map();
+    try {
+        for (const [name, hash] of Object.entries(previous?.files ?? {}))
+            check(digest(readFileSync(outputPath(directory, name))) === hash, "CONFLICT", `Output changed while acquiring generation guard: ${name}`);
+        for (const name of new Set([
+            ...Object.keys(files),
+            ...Object.keys(previous?.files ?? {}),
+            manifestName,
+        ]))
+            before.set(name, existsSync(outputPath(directory, name))
+                ? readFileSync(outputPath(directory, name))
+                : null);
+        for (const [name, text] of Object.entries(files)) {
+            const staged = outputPath(stage, name);
+            mkdirSync(dirname(staged), { recursive: true });
+            writeFileSync(staged, name.endsWith(".whl") ? Buffer.from(text, "base64") : text);
+        }
+        for (const name of Object.keys(files)) {
+            const target = outputPath(directory, name);
+            mkdirSync(dirname(target), { recursive: true });
+            renameSync(outputPath(stage, name), target);
+            touched.push(name);
+        }
+        for (const name of Object.keys(previous?.files ?? {}))
+            if (!Object.hasOwn(files, name)) {
+                rmSync(outputPath(directory, name));
+                touched.push(name);
+            }
+        const stagedManifest = resolve(stage, manifestName);
+        writeFileSync(stagedManifest, json(manifest));
+        renameSync(stagedManifest, manifestFile);
+        touched.push(manifestName);
+    }
+    catch (error) {
+        for (const name of touched.reverse()) {
+            const file = outputPath(directory, name), bytes = before.get(name);
+            if (bytes == null)
+                rmSync(file, { force: true });
+            else
+                writeFileSync(file, bytes);
+        }
+        throw error;
+    }
+    finally {
+        rmSync(stage, { recursive: true, force: true });
+        rmSync(guard, { force: true });
+    }
+    return { directory, files: Object.keys(files).length, digest: plan.digest };
+}
+export function validateOutput(directory) {
+    directory = realpathSync(directory);
+    const manifest = JSON.parse(readFileSync(outputPath(directory, manifestName), "utf8"));
+    check(manifest.apiVersion === "ingestron.output/v1", "OUTPUT", "Unknown output manifest version");
+    const files = {};
+    const inventory = manifest.ownership === "team"
+        ? Object.fromEntries(teamFiles(directory).map((name) => [name, ""]))
+        : manifest.files;
+    for (const [name, hash] of Object.entries(inventory)) {
+        const bytes = readFileSync(outputPath(directory, name));
+        const content = bytes.toString(name.endsWith(".whl") ? "base64" : "utf8");
+        check(manifest.ownership === "team" || digest(bytes) === hash, "CONFLICT", `Output hash mismatch: ${name}`);
+        files[name] = content;
+    }
+    validateGeneratedFiles(files);
+    return {
+        files: Object.keys(files).length,
+        planDigest: manifest.planDigest,
+        evidence: "offline",
+        ownership: manifest.ownership ?? "managed",
+    };
+}
+function teamFiles(root, prefix = "") {
+    return readdirSync(resolve(root, prefix), { withFileTypes: true }).flatMap((entry) => {
+        if ([".git", ".venv", "node_modules", "__pycache__", ".ingestron"].includes(entry.name))
+            return [];
+        const name = prefix ? prefix + "/" + entry.name : entry.name;
+        check(!entry.isSymbolicLink(), "PATH", "Team source cannot contain symlinks");
+        if (entry.isDirectory())
+            return teamFiles(root, name);
+        return /\.(py|sql|json|ipynb|ya?ml|whl)$/.test(name) &&
+            name !== manifestName
+            ? [name]
+            : [];
+    });
+}

package/dist/core/installation.d.ts

@@ -0,0 +1,3 @@
+export declare const installationRoot: string;
+export declare const assetPath: (path: string) => string;
+export declare const compiledPath: (path: string) => string;

package/dist/core/installation.js

@@ -0,0 +1,14 @@
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+let directory = dirname(fileURLToPath(import.meta.url));
+while (!existsSync(join(directory, "package.json")) ||
+    !["@ingestron/core"].includes(JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).name)) {
+    const parent = dirname(directory);
+    if (parent === directory)
+        throw new Error("Cannot locate the Ingestron core installation");
+    directory = parent;
+}
+export const installationRoot = directory;
+export const assetPath = (path) => join(installationRoot, "dist/assets", path);
+export const compiledPath = (path) => join(installationRoot, "dist", path);

package/dist/core/installed-plugins.d.ts

@@ -0,0 +1,41 @@
+export type PluginKind = "provider" | "connector" | "model-pack" | "activity-pack" | "report-pack";
+export declare const pluginKindLabel: (kind: PluginKind) => string;
+export declare function browseProviders(root: string, query?: string, kind?: string, filters?: {
+    engine?: string;
+    installable?: boolean;
+}): {
+    id: string;
+    name: string;
+    version: string;
+    kind: PluginKind;
+    kindLabel: string;
+    reference: string;
+    commit: string;
+    repository: string;
+    description: string;
+    engines: string[];
+    availability: string;
+    installable: boolean;
+    documentation: string;
+    licence: string;
+    url: string;
+    evidence: string;
+}[];
+export declare function pluginDetails(root: string, id: string): {
+    id: string;
+    name: string;
+    version: string;
+    kind: PluginKind;
+    kindLabel: string;
+    reference: string;
+    commit: string;
+    repository: string;
+    description: string;
+    engines: string[];
+    availability: string;
+    installable: boolean;
+    documentation: string;
+    licence: string;
+    url: string;
+    evidence: string;
+};