@ingestron/core 0.12.0

package/dist/core/installed-plugins.js

@@ -0,0 +1,92 @@
+/** Discover only packages present in the caller's integrity-checked lock/cache. */
+import { check } from "./errors.js";
+import { packageLock, packageYaml, resolvePackage, providerPackageSchema, extensionPackSchema, } from "./packages.js";
+import { connectorPackageSchema } from "./connector-package.js";
+import { validateModelPack } from "./model-pack-schema.js";
+import { reportPackSchema } from "./report-pack-schema.js";
+export const pluginKindLabel = (kind) => ({
+    provider: "Provider",
+    connector: "Connector",
+    "model-pack": "Model pack",
+    "activity-pack": "Activity preset pack",
+    "report-pack": "Report pack",
+})[kind];
+export function browseProviders(root, query = "", kind, filters = {}) {
+    check(!kind ||
+        Object.hasOwn({
+            provider: 1,
+            connector: 1,
+            "model-pack": 1,
+            "activity-pack": 1,
+            "report-pack": 1,
+        }, kind), "INPUT", "Unknown plugin category");
+    const needle = query.toLowerCase();
+    const entries = Object.keys(packageLock(root).packages)
+        .sort()
+        .flatMap((reference) => {
+        const source = resolvePackage(root, reference);
+        const raw = packageYaml(source.file);
+        let kind;
+        let manifest;
+        switch (raw.apiVersion) {
+            case "ingestron.provider/v1":
+                kind = "provider";
+                manifest = providerPackageSchema.parse(raw);
+                break;
+            case "ingestron.connector/v1":
+                kind = "connector";
+                manifest = connectorPackageSchema.parse(raw);
+                break;
+            case "ingestron.extension-pack/v1":
+                kind = "activity-pack";
+                manifest = extensionPackSchema.parse(raw);
+                break;
+            case "ingestron.extension-pack/v2":
+                kind = "model-pack";
+                manifest = validateModelPack(raw);
+                break;
+            case "ingestron.extension-pack/v3":
+                kind = "report-pack";
+                manifest = reportPackSchema.parse(raw);
+                break;
+            default:
+                return [];
+        }
+        const url = `https://github.com/${source.entry.repository}/tree/${source.entry.commit}`;
+        return [
+            {
+                id: manifest.id,
+                name: manifest.id,
+                version: manifest.version,
+                kind,
+                kindLabel: pluginKindLabel(kind),
+                reference,
+                commit: source.entry.commit,
+                repository: source.entry.repository,
+                description: (manifest.description ?? ""),
+                engines: kind === "connector"
+                    ? [
+                        ...new Set(Object.values(manifest.execution).flatMap((e) => e.modes)),
+                    ]
+                    : [manifest.platform].filter(Boolean),
+                availability: "installed",
+                installable: false,
+                documentation: (manifest.documentation ?? url),
+                licence: (manifest.upstream?.licence ??
+                    "See the installed package licence files"),
+                url,
+                evidence: "Locked package metadata; capabilities are declared by the package, not verified target support.",
+            },
+        ];
+    });
+    return entries.filter((p) => (!kind || p.kind === kind) &&
+        (!filters.engine || p.engines.includes(filters.engine)) &&
+        (!filters.installable || p.installable) &&
+        `${p.id} ${p.description} ${p.reference}`.toLowerCase().includes(needle));
+}
+export function pluginDetails(root, id) {
+    const entries = browseProviders(root).filter((p) => p.id === id || p.reference === id);
+    check(entries.length > 0, "PACKAGE", "No installed package matches; inspect packages_list or install an explicit repository reference");
+    check(entries.length === 1, "PACKAGE", "Multiple installed packages match; select an exact reference");
+    return entries[0];
+}

package/dist/core/model-pack-schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const modelPackSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.extension-pack/v2">;
+    kind: z.ZodLiteral<"model">;
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    contracts: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    relationships: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        fields: z.ZodArray<z.ZodString>;
+        to: z.ZodString;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    provenance: z.ZodObject<{
+        sources: z.ZodArray<z.ZodString>;
+        retrieved: z.ZodString;
+        status: z.ZodEnum<{
+            "documented-projection": "documented-projection";
+            "recorded-schema": "recorded-schema";
+        }>;
+        notes: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare function validateModelPack(raw: unknown): {
+    apiVersion: "ingestron.extension-pack/v2";
+    kind: "model";
+    id: string;
+    version: string;
+    description: string;
+    contracts: Record<string, Record<string, unknown>>;
+    relationships: {
+        id: string;
+        from: string;
+        fields: string[];
+        to: string;
+        references: string[];
+    }[];
+    provenance: {
+        sources: string[];
+        retrieved: string;
+        status: "documented-projection" | "recorded-schema";
+        notes: string;
+    };
+};

package/dist/core/model-pack-schema.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { validateContract } from "./contracts.js";
+import { check, isMap } from "./errors.js";
+const name = z.string().regex(/^[a-z][a-z0-9_-]*$/);
+export const modelPackSchema = z
+    .object({
+    apiVersion: z.literal("ingestron.extension-pack/v2"),
+    kind: z.literal("model"),
+    id: name,
+    version: z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: z.string().min(1),
+    contracts: z
+        .record(name, z.record(z.string(), z.unknown()))
+        .refine((v) => Object.keys(v).length > 0 && Object.keys(v).length <= 200, "Export 1–200 contracts"),
+    relationships: z
+        .array(z
+        .object({
+        id: name,
+        from: name,
+        fields: z.array(z.string().min(1)).min(1),
+        to: name,
+        references: z.array(z.string().min(1)).min(1),
+    })
+        .strict())
+        .max(500)
+        .default([]),
+    provenance: z
+        .object({
+        sources: z.array(z.string().min(1)).min(1),
+        retrieved: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+        status: z.enum(["recorded-schema", "documented-projection"]),
+        notes: z.string().min(1),
+    })
+        .strict(),
+})
+    .strict();
+export function validateModelPack(raw) {
+    const pack = modelPackSchema.parse(raw);
+    const noDirectives = (v) => {
+        if (Array.isArray(v))
+            v.forEach(noDirectives);
+        else if (isMap(v))
+            for (const [key, value] of Object.entries(v)) {
+                check(!key.startsWith("$"), "MODEL_PACK", "Model packs cannot contain configuration directives");
+                noDirectives(value);
+            }
+    };
+    noDirectives(pack);
+    const schemas = {};
+    for (const [alias, contract] of Object.entries(pack.contracts)) {
+        validateContract(contract);
+        const schema = contract.schema;
+        check(schema?.length === 1 && schema[0].properties?.length, "MODEL_PACK", `${alias}: export one dataset with properties`);
+        const columns = schema[0].properties;
+        check(new Set(columns.map((c) => c.name)).size === columns.length, "MODEL_PACK", `${alias}: duplicate property`);
+        schemas[alias] = columns;
+    }
+    const ids = new Set();
+    for (const relation of pack.relationships) {
+        check(!ids.has(relation.id), "MODEL_PACK", "Duplicate relationship id");
+        ids.add(relation.id);
+        check(schemas[relation.from] && schemas[relation.to], "MODEL_PACK", `${relation.id}: unknown dataset`);
+        check(relation.fields.length === relation.references.length &&
+            new Set(relation.fields).size === relation.fields.length &&
+            new Set(relation.references).size === relation.references.length, "MODEL_PACK", `${relation.id}: invalid relationship fields`);
+        const keys = schemas[relation.to]
+            .filter((c) => c.primaryKey)
+            .map((c) => c.name)
+            .sort();
+        check(JSON.stringify(keys) === JSON.stringify([...relation.references].sort()), "MODEL_PACK", `${relation.id}: reference the complete target primary key`);
+        relation.fields.forEach((field, index) => {
+            const from = schemas[relation.from].find((c) => c.name === field);
+            const to = schemas[relation.to].find((c) => c.name === relation.references[index]);
+            check(from &&
+                to &&
+                from.logicalType === to.logicalType &&
+                from.physicalType === to.physicalType, "MODEL_PACK", `${relation.id}: missing or incompatible relationship field`);
+        });
+    }
+    return pack;
+}

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

@@ -0,0 +1,4 @@
+import { Configuration } from "./config.js";
+import type { Project, Flow } from "./schema.js";
+/** Read immutable model text, never evaluate it as configuration or plugin code. */
+export declare function resolveModelContracts(reader: Configuration, project: Project, flows: Flow[]): void;

package/dist/core/model-packs.js

@@ -0,0 +1,33 @@
+import { resolvePackage, packageYaml } from "./packages.js";
+import { validateModelPack } from "./model-pack-schema.js";
+import { check } from "./errors.js";
+/** Read immutable model text, never evaluate it as configuration or plugin code. */
+export function resolveModelContracts(reader, project, flows) {
+    const packs = Object.fromEntries(Object.entries(project.modelPacks).map(([alias, selection]) => {
+        const local = selection.source.startsWith(".");
+        const file = local
+            ? reader.path(selection.source)
+            : resolvePackage(reader.root, `${selection.source}@${selection.version}`).file;
+        reader.text(file);
+        if (!local)
+            reader.text("packages.lock.yaml");
+        const pack = validateModelPack(packageYaml(file));
+        check(pack.version === selection.version ||
+            (!local && /^[a-f0-9]{40}$/.test(selection.version)), "MODEL_PACK", `${alias}: model version differs from selector`);
+        return [alias, pack];
+    }));
+    const resolveContract = (contract) => {
+        if (!Object.hasOwn(contract, "$model"))
+            return contract;
+        check(Object.keys(contract).length === 1 && typeof contract.$model === "string", "MODEL_PACK", "Use only {$model: pack:dataset}; model overrides are not supported");
+        const parts = contract.$model.split(":");
+        check(parts.length === 2 && packs[parts[0]]?.contracts[parts[1]], "MODEL_PACK", `Unknown model ${contract.$model}`);
+        return structuredClone(packs[parts[0]].contracts[parts[1]]);
+    };
+    for (const flow of flows) {
+        for (const table of Object.values(flow.tables ?? {}))
+            table.contract = resolveContract(table.contract);
+        for (const output of Object.values(flow.publishes))
+            output.contract = resolveContract(output.contract);
+    }
+}

package/dist/core/operations.d.ts

@@ -0,0 +1,346 @@
+import { z } from "zod";
+export declare const operationSchemas: {
+    readonly provider_scaffold: z.ZodObject<{
+        id: z.ZodString;
+        out: z.ZodString;
+    }, z.core.$strict>;
+    readonly pack_configure: z.ZodObject<{
+        reference: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly flow_connect: z.ZodObject<{
+        id: z.ZodString;
+        input: z.ZodString;
+        dataset: z.ZodString;
+        handover: z.ZodEnum<{
+            files: "files";
+            relation: "relation";
+        }>;
+        table: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly flow_export: z.ZodObject<{
+        id: z.ZodString;
+        group: z.ZodString;
+    }, z.core.$strict>;
+    readonly provider_check: z.ZodObject<{
+        delivery: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly plugin_show: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    readonly plugin_browse: z.ZodObject<{
+        engine: z.ZodOptional<z.ZodString>;
+        installable: z.ZodOptional<z.ZodBoolean>;
+        query: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "activity-pack": "activity-pack";
+            connector: "connector";
+            "model-pack": "model-pack";
+            provider: "provider";
+            "report-pack": "report-pack";
+        }>>;
+    }, z.core.$strict>;
+    readonly plugin_versions: z.ZodObject<{
+        provider: z.ZodString;
+        fromGit: z.ZodOptional<z.ZodString>;
+        tagPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly source_list: z.ZodObject<{}, z.core.$strict>;
+    readonly source_show: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    readonly source_add: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        format: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        execution: z.ZodDefault<z.ZodEnum<{
+            local: "local";
+            manual: "manual";
+        }>>;
+        binding: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly source_configure: z.ZodObject<{
+        id: z.ZodString;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    readonly source_prepare: z.ZodObject<{
+        id: z.ZodString;
+        input: z.ZodString;
+        out: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly source_import: z.ZodObject<{
+        id: z.ZodString;
+        metadata: z.ZodString;
+    }, z.core.$strict>;
+    readonly plugin_configure: z.ZodObject<{
+        reference: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        update: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly contract_list: z.ZodObject<{}, z.core.$strict>;
+    readonly contract_show: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    readonly contract_check: z.ZodObject<{
+        id: z.ZodString;
+        native: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly contract_create: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodString>;
+        entity: z.ZodOptional<z.ZodString>;
+        out: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly flow_create: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            ingestion: "ingestion";
+            transformation: "transformation";
+        }>>;
+        standard: z.ZodOptional<z.ZodString>;
+        sourceKind: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        sourceBinding: z.ZodOptional<z.ZodString>;
+        inputDataset: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        contract: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly flow_show: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    readonly build: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        delivery: z.ZodDefault<z.ZodBoolean>;
+        flow: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        step: z.ZodOptional<z.ZodString>;
+        out: z.ZodDefault<z.ZodString>;
+        ownership: z.ZodDefault<z.ZodEnum<{
+            managed: "managed";
+            team: "team";
+        }>>;
+    }, z.core.$strict>;
+    readonly environments: z.ZodObject<{}, z.core.$strict>;
+    readonly environment_add: z.ZodObject<{
+        name: z.ZodString;
+        from: z.ZodString;
+    }, z.core.$strict>;
+    readonly datasets: z.ZodObject<{}, z.core.$strict>;
+    readonly tables: z.ZodObject<{}, z.core.$strict>;
+    readonly config_explain: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    readonly diff: z.ZodObject<{
+        plan: z.ZodString;
+    }, z.core.$strict>;
+    readonly inspect: z.ZodObject<{}, z.core.$strict>;
+    readonly schema: z.ZodObject<{
+        name: z.ZodEnum<{
+            activity: "activity";
+            "delivery-index": "delivery-index";
+            environment: "environment";
+            "extension-pack": "extension-pack";
+            flow: "flow";
+            project: "project";
+            provider: "provider";
+            source: "source";
+            step: "step";
+        }>;
+    }, z.core.$strict>;
+    readonly read: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    readonly validate: z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            draft: "draft";
+            strict: "strict";
+        }>>;
+        flow: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        step: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly resolve: z.ZodObject<{}, z.core.$strict>;
+    readonly plan: z.ZodObject<{
+        flow: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        step: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly generate: z.ZodObject<{
+        plan: z.ZodString;
+        out: z.ZodString;
+        ownership: z.ZodDefault<z.ZodEnum<{
+            managed: "managed";
+            team: "team";
+        }>>;
+    }, z.core.$strict>;
+    readonly validate_output: z.ZodObject<{
+        directory: z.ZodString;
+    }, z.core.$strict>;
+    readonly catalogue: z.ZodObject<{
+        kind: z.ZodEnum<{
+            activities: "activities";
+            providers: "providers";
+            standards: "standards";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly initialise: z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        environments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly activity_inspect: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    readonly contract_draft: z.ZodObject<{
+        metadata: z.ZodString;
+        id: z.ZodString;
+        out: z.ZodString;
+    }, z.core.$strict>;
+    readonly contract_validate: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    readonly flow_configure: z.ZodObject<{
+        flow: z.ZodString;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    readonly step_add: z.ZodObject<{
+        flow: z.ZodString;
+        step: z.ZodObject<{
+            id: z.ZodString;
+            uses: z.ZodString;
+            provider: z.ZodOptional<z.ZodString>;
+            with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        after: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly flow_add: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            ingestion: "ingestion";
+            transformation: "transformation";
+        }>;
+        standard: z.ZodOptional<z.ZodString>;
+        sourceKind: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        inputDataset: z.ZodOptional<z.ZodString>;
+        sourceBinding: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly table_add: z.ZodObject<{
+        id: z.ZodString;
+        flow: z.ZodString;
+        contract: z.ZodString;
+    }, z.core.$strict>;
+    readonly table_configure: z.ZodObject<{
+        id: z.ZodString;
+        flow: z.ZodString;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    readonly dataset_add: z.ZodObject<{
+        id: z.ZodString;
+        flow: z.ZodString;
+        contract: z.ZodString;
+        from: z.ZodString;
+    }, z.core.$strict>;
+    readonly config_set: z.ZodObject<{
+        path: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strict>;
+    readonly edit: z.ZodObject<{
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    readonly apply: z.ZodObject<{
+        proposal: z.ZodUnknown;
+    }, z.core.$strict>;
+    readonly packages_install: z.ZodObject<{
+        reference: z.ZodString;
+        fromGit: z.ZodOptional<z.ZodString>;
+        update: z.ZodOptional<z.ZodBoolean>;
+        frozen: z.ZodOptional<z.ZodBoolean>;
+        tagPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly provider_migrate: z.ZodObject<{
+        package: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>;
+    readonly provider_export: z.ZodObject<{
+        result: z.ZodString;
+        out: z.ZodString;
+    }, z.core.$strict>;
+    readonly connection_prepare: z.ZodObject<{
+        flow: z.ZodString;
+        validateOnly: z.ZodDefault<z.ZodBoolean>;
+        review: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly plugin_commands: z.ZodObject<{}, z.core.$strict>;
+    readonly plugin_command: z.ZodObject<{
+        namespace: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        command: z.ZodString;
+        input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly provider_commands: z.ZodObject<{
+        configuration: z.ZodString;
+    }, z.core.$strict>;
+    readonly provider_command: z.ZodObject<{
+        configuration: z.ZodString;
+        command: z.ZodString;
+        input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly packages_list: z.ZodObject<{}, z.core.$strict>;
+    readonly doctor: z.ZodObject<{}, z.core.$strict>;
+    readonly runtime_prepare: z.ZodObject<{
+        from: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        flow: z.ZodOptional<z.ZodString>;
+        python: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly run: z.ZodObject<{
+        from: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        flow: z.ZodOptional<z.ZodString>;
+        action: z.ZodDefault<z.ZodEnum<{
+            approve: "approve";
+            discover: "discover";
+            review: "review";
+            run: "run";
+        }>>;
+        runId: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodString>;
+        envFile: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly run_status: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+};
+export type OperationName = keyof typeof operationSchemas;
+export interface Context {
+    root: string;
+    environment?: string;
+    allowWrite?: boolean;
+    allowNetwork?: boolean;
+    allowExecute?: boolean;
+}
+export interface Result {
+    apiVersion: "ingestron.operation/v1";
+    operation: string;
+    ok: boolean;
+    result?: any;
+    diagnostics: {
+        code: string;
+        message: string;
+        file?: string;
+        pointer?: string;
+        hint?: string;
+    }[];
+}
+export declare function execute(context: Context, operation: OperationName, request?: unknown): Result;
+/** Shared CLI/MCP entry point; ordinary compiler operations remain synchronous/offline. */
+export declare function executeAsync(context: Context, operation: OperationName, request?: unknown): Promise<Result>;