@ingestron/core 0.12.0

package/dist/core/project-build.d.ts

@@ -0,0 +1,13 @@
+export declare function buildProject(root: string, environment: string, args: any): {
+    files: number;
+    digest: string;
+    directory: any;
+    nodes: number;
+    packages: any[];
+    scope: {
+        projectBuild: boolean;
+        flow?: any;
+        provider?: any;
+    };
+    evidence: string;
+};

package/dist/core/project-build.js

@@ -0,0 +1,266 @@
+/** One build path: native compilation and connector preparation feed provider assembly. */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { validateProviderFiles } from "../plugins/generation.js";
+import { inspectProject, planProject } from "./planner.js";
+import { canonical, check, digest, isMap } from "./errors.js";
+import { canonicalPackageReference, fence, packageYaml, providerPackageSchema, resolvePackage, } from "./packages.js";
+import { checkProviderCompatibility } from "../plugins/compatibility.js";
+import { prepareConnection } from "./connections.js";
+import { runProviderCommand } from "./provider-commands.js";
+import { deliveryExports } from "./delivery-exports.js";
+import { renderProject, validateGeneratedFiles, writeOutput, } from "./generate.js";
+import { compilerFingerprint } from "./fingerprint.js";
+import { version } from "../version.js";
+export function buildProject(root, environment, args) {
+    const { project, flows, reader, profile } = inspectProject(root, environment);
+    check(!(args.provider && args.flow), "SELECT", "Choose provider or flow, not both");
+    check(!args.table && !args.step, "SELECT", "Project packages contain complete flows; select flow, not individual tables or steps");
+    if (args.provider)
+        check(project.providers.configurations[args.provider], "PROVIDER", `Unknown provider configuration ${args.provider}`);
+    const owner = (f) => f.provider ?? project.defaults.provider ?? "";
+    const wanted = new Set();
+    const active = new Set();
+    const include = (id) => {
+        check(!active.has(id), "CYCLE", `Flow dependency cycle at ${id}`);
+        if (wanted.has(id))
+            return;
+        const flow = flows.find((f) => f.id === id);
+        check(flow, "SELECT", `Unknown flow ${id}`);
+        active.add(id);
+        for (const r of Object.values(flow.requires)) {
+            const parts = r.dataset.split(".");
+            check(parts[0] === project.id && parts.length >= 3, "DATASET", `Unknown project dataset ${r.dataset}`);
+            include(parts[1]);
+        }
+        active.delete(id);
+        wanted.add(id);
+    };
+    flows
+        .filter((f) => args.flow
+        ? f.id === args.flow
+        : args.provider
+            ? owner(f) === args.provider
+            : true)
+        .forEach((f) => include(f.id));
+    if (args.flow)
+        include(args.flow);
+    check(wanted.size, "INPUT", "No buildable flows; add a flow and contract before building");
+    // The existing planner owns native standards, resources, handovers and dependency validation.
+    const targetNames = new Set(flows.filter((f) => wanted.has(f.id)).map(owner));
+    const candidates = new Set(flows
+        .filter((f) => !f.ingestion?.connection && targetNames.has(owner(f)))
+        .map((f) => f.id));
+    const addNativeParents = (id, visiting = new Set()) => {
+        check(!visiting.has(id), "CYCLE", `Flow dependency cycle at ${id}`);
+        visiting.add(id);
+        const f = flows.find((f) => f.id === id);
+        for (const r of Object.values(f.requires)) {
+            const parent = r.dataset.split(".")[1];
+            const producer = flows.find((f) => f.id === parent);
+            check(producer && !producer.ingestion?.connection, "DATASET", "Connector-to-native dataset handovers require an explicit supported publication contract");
+            candidates.add(parent);
+            addNativeParents(parent, new Set(visiting));
+        }
+    };
+    [...candidates].forEach((id) => addNativeParents(id));
+    const nativePlan = planProject(root, environment, {
+        nativeOnly: true,
+        flowIds: [...candidates],
+        delivery: true,
+        projectBuild: true,
+    });
+    // A partial build must include every flow sharing an owned native resource.
+    let changed = true;
+    while (changed) {
+        const before = wanted.size;
+        const claims = new Set(nativePlan.nodes
+            .filter((n) => wanted.has(n.flow))
+            .flatMap((n) => (n.resources ?? []).map((r) => canonical([n.platform, r.scope, r.kind, r.name]))));
+        for (const n of nativePlan.nodes)
+            if ((n.resources ?? []).some((r) => claims.has(canonical([n.platform, r.scope, r.kind, r.name]))))
+                include(n.flow);
+        for (const f of flows.filter((f) => wanted.has(f.id) && f.export))
+            flows
+                .filter((p) => p.export === f.export && owner(p) === owner(f))
+                .forEach((p) => include(p.id));
+        changed = before !== wanted.size;
+    }
+    const nativeBody = {
+        ...nativePlan,
+        nodes: nativePlan.nodes.filter((n) => wanted.has(n.flow)),
+        flows: nativePlan.flows.filter((f) => wanted.has(f.id)),
+    };
+    const { digest: _old, ...body } = nativeBody;
+    const selectedNative = { ...body, digest: digest(canonical(body)) };
+    const nativeGroups = deliveryExports(selectedNative);
+    const configurations = [
+        ...new Set(flows.filter((f) => wanted.has(f.id)).map(owner)),
+    ].sort();
+    check(!(args.flow ||
+        configurations.some((configuration) => flows.filter((f) => owner(f) === configuration && wanted.has(f.id))
+            .length !== flows.filter((f) => owner(f) === configuration).length)) || !nativeGroups.some((g) => g.imports.length), "HANDOVER", "Partial cross-target native handovers require path rebinding; build the complete project instead");
+    const deploymentRoots = new Set();
+    const files = {};
+    const packages = [];
+    const add = (path, content) => {
+        check(!Object.hasOwn(files, path), "OWNER", `Duplicate assembled file ${path}`);
+        check(typeof content === "string" &&
+            !path.startsWith("/") &&
+            !path.includes("\\") &&
+            path.split("/").every((p) => p && p !== "." && p !== ".."), "PATH", "Unsafe assembled file path");
+        check(path !== "ingestron-manifest.json" && path !== "ingestron-project.json", "OWNER", "Provider cannot replace host build manifests");
+        files[path] = content;
+    };
+    for (const configuration of configurations) {
+        const selected = flows.filter((f) => wanted.has(f.id) && owner(f) === configuration);
+        const config = project.providers.configurations[configuration];
+        check(config, "PROVIDER", `Unknown provider configuration ${configuration}`);
+        const pkg = project.providers.packages[config.package];
+        check(pkg, "PACKAGE", `Missing execution package ${config.package}`);
+        const reference = canonicalPackageReference(`${pkg.source}@${pkg.version}`);
+        const locked = pkg.source.startsWith(".")
+            ? { file: reader.path(pkg.source), root, entry: undefined }
+            : resolvePackage(root, reference);
+        const manifest = providerPackageSchema.parse(packageYaml(locked.file));
+        checkProviderCompatibility(manifest);
+        const partial = !!args.flow ||
+            selected.length !==
+                flows.filter((f) => owner(f) === configuration).length;
+        const scope = {
+            partial,
+            id: partial
+                ? "subset_" +
+                    digest(canonical(selected.map((f) => f.id).sort())).slice(0, 12)
+                : "full",
+            flows: selected.map((f) => f.id).sort(),
+        };
+        const identity = { project: project.id, environment, configuration, scope };
+        const native = nativeGroups.find((g) => g.id === configuration);
+        const nativeFiles = native ? renderProject(root, native.plan) : {};
+        const connections = selected
+            .filter((f) => f.ingestion?.connection)
+            .map((f) => {
+            check(manifest.projectAssembly, "CAPABILITY", `${configuration}: install a provider with project assembly support`);
+            const prepared = prepareConnection(root, environment, f.id, false, undefined, (execution) => {
+                const configured = runProviderCommand(root, environment, {
+                    configuration,
+                    command: manifest.projectAssembly.command,
+                    input: {
+                        phase: "configure",
+                        ...identity,
+                        flow: f.id,
+                        execution,
+                        binding: profile.bindings[config.binding],
+                        options: config.options,
+                    },
+                });
+                check(isMap(configured.result) && isMap(configured.result.execution), "PROVIDER", "Invalid project execution configuration");
+                return configured.result.execution;
+            });
+            return {
+                flow: f.id,
+                artifacts: prepared.result.artifacts,
+                inputDigest: prepared.inputDigest,
+            };
+        });
+        let artifacts = nativeFiles;
+        let details = {
+            resources: native?.resources ?? [],
+            execution: "not-run",
+        };
+        if (manifest.projectAssembly) {
+            const assembled = runProviderCommand(root, environment, {
+                configuration,
+                command: manifest.projectAssembly.command,
+                input: {
+                    phase: "assemble",
+                    ...identity,
+                    binding: profile.bindings[config.binding],
+                    options: config.options,
+                    nativeFiles,
+                    connections,
+                    dependencies: native?.imports ?? [],
+                },
+            });
+            check(assembled.result?.apiVersion === "ingestron.project-package/v1" &&
+                isMap(assembled.result.artifacts), "PROVIDER", "Invalid assembled project package");
+            artifacts = assembled.result.artifacts;
+            details = assembled.result.details;
+        }
+        else
+            check(!partial, "CAPABILITY", `${configuration}: partial project builds require project assembly support`);
+        if (manifest.lifecycle) {
+            const asset = (path) => reader.text(fence(locked.root, relative(locked.root, resolve(dirname(locked.file), path))));
+            validateProviderFiles(asset(manifest.lifecycle.module), Object.fromEntries(Object.entries(manifest.outputSchemas ?? {}).map(([key, path]) => [
+                key,
+                asset(path),
+            ])), artifacts);
+        }
+        if (details?.workspaceRoot) {
+            const rootIdentity = canonical([
+                manifest.platform,
+                profile.bindings[config.binding]?.host,
+                details.workspaceRoot,
+            ]);
+            check(!deploymentRoots.has(rootIdentity), "OWNER", "Provider configurations cannot share a deployment root");
+            deploymentRoots.add(rootIdentity);
+        }
+        const directory = configurations.length === 1 ? "" : `providers/${configuration}/`;
+        for (const [name, content] of Object.entries(artifacts))
+            add(directory + name, content);
+        packages.push({
+            configuration,
+            platform: manifest.platform,
+            directory: directory || ".",
+            reference,
+            commit: locked.entry?.commit,
+            scope,
+            details,
+            needs: native?.needs ?? [],
+            imports: native?.imports ?? [],
+        });
+    }
+    check(Object.keys(files).length <= 10000 &&
+        Buffer.byteLength(JSON.stringify(files)) <= 10 * 1024 * 1024, "LIMIT", "Project output exceeds 10000 files or 10 MiB");
+    const selection = {
+        projectBuild: true,
+        ...(args.flow ? { flow: args.flow } : {}),
+        ...(args.provider ? { provider: args.provider } : {}),
+    };
+    const metadata = {
+        apiVersion: "ingestron.project-build/v1",
+        project: project.id,
+        environment,
+        compilerVersion: version,
+        compilerDigest: compilerFingerprint(),
+        selection,
+        complete: !args.flow && !args.provider,
+        requestedFlows: args.flow ? [args.flow] : undefined,
+        includedFlows: [...wanted].sort(),
+        packages,
+        deployment: { executed: false, omissionMeansDeletion: false },
+        files: Object.fromEntries(Object.entries(files).map(([n, t]) => [n, digest(t)])),
+        sourceFiles: { ...reader.files, ...nativePlan.files },
+        packageLockSha256: existsSync(fence(root, "packages.lock.yaml"))
+            ? digest(readFileSync(fence(root, "packages.lock.yaml")))
+            : undefined,
+    };
+    files["ingestron-project.json"] = JSON.stringify(metadata, null, 2) + "\n";
+    validateGeneratedFiles(files);
+    const output = writeOutput(fence(root, args.out), {
+        project: project.id,
+        environment,
+        selection,
+        digest: digest(canonical(metadata)),
+    }, files, args.ownership);
+    return {
+        ...output,
+        directory: args.out,
+        nodes: selectedNative.nodes.length +
+            flows.filter((f) => wanted.has(f.id) && f.ingestion?.connection).length,
+        packages: packages.map((p) => p.configuration),
+        scope: selection,
+        evidence: "Project assets generated locally; no deployment or source execution",
+    };
+}

package/dist/core/provider-commands.d.ts

@@ -0,0 +1,83 @@
+export declare function validateSchemaShape(schema: unknown): void;
+export declare function providerCommands(root: string, environment: string, configuration: string): {
+    apiVersion: string;
+    configuration: string;
+    environment: string;
+    provider: string;
+    version: string;
+    reference: string;
+    commit: string;
+    execution: "offline-json";
+    commands: {
+        name: string;
+        description: string;
+        reportPack?: boolean | undefined;
+        examples?: string[] | undefined;
+        resultSchema?: Record<string, unknown> | undefined;
+        inputSchema: Record<string, unknown>;
+    }[];
+};
+export declare function runProviderCommand(root: string, environment: string, args: {
+    configuration: string;
+    command: string;
+    input: Record<string, unknown>;
+}): {
+    project: string;
+    environment: string;
+    configuration: string;
+    provider: string;
+    version: string;
+    commit: string;
+    apiVersion: string;
+    command: string;
+    execution: string;
+    inputDigest: string;
+    reportLock?: Record<string, unknown> | undefined;
+    result: import("../plugins/provider-renderer.js").ProviderAssets;
+};
+/** Core names are reserved even when a compatibility command is hidden. */
+export declare const reservedCommandNamespaces: Set<string>;
+/** Data-only discovery; resolvePackage verifies locked bytes but never runs the guest. */
+export declare function pluginCommands(root: string, environment: string): {
+    apiVersion: string;
+    bindings: {
+        apiVersion: string;
+        configuration: string;
+        environment: string;
+        provider: string;
+        version: string;
+        reference: string;
+        commit: string;
+        execution: "offline-json";
+        commands: {
+            name: string;
+            description: string;
+            reportPack?: boolean | undefined;
+            examples?: string[] | undefined;
+            resultSchema?: Record<string, unknown> | undefined;
+            inputSchema: Record<string, unknown>;
+        }[];
+        namespace: string;
+        effects: "offline-json";
+        availability: "implemented";
+    }[];
+};
+export declare function runPluginCommand(root: string, environment: string, args: {
+    namespace: string;
+    target?: string;
+    command: string;
+    input: Record<string, unknown>;
+}): {
+    project: string;
+    environment: string;
+    configuration: string;
+    provider: string;
+    version: string;
+    commit: string;
+    apiVersion: string;
+    command: string;
+    execution: string;
+    inputDigest: string;
+    reportLock?: Record<string, unknown> | undefined;
+    result: import("../plugins/provider-renderer.js").ProviderAssets;
+};

package/dist/core/provider-commands.js

@@ -0,0 +1,252 @@
+import { reportPackSchema } from "./report-pack-schema.js";
+import { validateModelPack } from "./model-pack-schema.js";
+/** Provider-owned offline operations. No target access, shell, or filesystem guest APIs. */
+import { readFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { Configuration } from "./config.js";
+import { projectSchema } from "./schema.js";
+import { canonical, check, digest } from "./errors.js";
+import { canonicalPackageReference, fence, packageYaml, providerPackageSchema, resolvePackage, } from "./packages.js";
+import { executeProvider } from "../plugins/provider-renderer.js";
+import { checkProviderCompatibility } from "../plugins/compatibility.js";
+// No references, regular expressions or schema code: validation itself must be bounded.
+export function validateSchemaShape(schema) {
+    let nodes = 0;
+    const allowed = new Set([
+        "type",
+        "oneOf",
+        "properties",
+        "items",
+        "required",
+        "additionalProperties",
+        "enum",
+        "minItems",
+        "maxItems",
+        "minLength",
+        "maxLength",
+        "minimum",
+        "maximum",
+    ]);
+    const walk = (value, depth = 0) => {
+        check(++nodes <= 1000 &&
+            depth <= 20 &&
+            value &&
+            typeof value === "object" &&
+            !Array.isArray(value), "PACKAGE", "Command schema exceeds supported bounds");
+        for (const key of Object.keys(value))
+            check(allowed.has(key), "PACKAGE", `Unsupported command schema keyword ${key}`);
+        if (value.properties)
+            for (const child of Object.values(value.properties))
+                walk(child, depth + 1);
+        if (value.items)
+            walk(value.items, depth + 1);
+        if (value.oneOf !== undefined) {
+            check(Array.isArray(value.oneOf) &&
+                value.oneOf.length >= 2 &&
+                value.oneOf.length <= 4, "PACKAGE", "oneOf requires 2–4 bounded alternatives");
+            for (const child of value.oneOf)
+                walk(child, depth + 1);
+        }
+        if (value.additionalProperties &&
+            typeof value.additionalProperties === "object")
+            walk(value.additionalProperties, depth + 1);
+        check(value.additionalProperties === undefined ||
+            (value.additionalProperties &&
+                typeof value.additionalProperties === "object") ||
+            typeof value.additionalProperties === "boolean", "PACKAGE", "additionalProperties must be boolean");
+    };
+    check(JSON.stringify(schema).length <= 64000, "PACKAGE", "Command schema exceeds 64 KB");
+    walk(schema);
+}
+function selected(root, environment, configuration) {
+    const reader = new Configuration(root);
+    const project = reader.parse(projectSchema, reader.load());
+    check(project.environments[environment], "ENVIRONMENT", `Unknown environment ${environment}`);
+    const configured = project.providers.configurations[configuration];
+    check(configured, "PROVIDER", `Unknown provider configuration ${configuration}`);
+    const pkg = project.providers.packages[configured.package];
+    check(pkg && !pkg.source.startsWith("builtin:") && !pkg.source.startsWith("."), "PACKAGE", "Provider commands require an installed locked provider");
+    const reference = canonicalPackageReference(`${pkg.source}@${pkg.version}`);
+    const source = resolvePackage(reader.root, reference);
+    const manifest = providerPackageSchema.parse(packageYaml(source.file));
+    checkProviderCompatibility(manifest);
+    check(manifest.commands, "PROVIDER", "This provider version does not declare commands");
+    return {
+        reader,
+        project,
+        source,
+        manifest,
+        reference,
+        configuration,
+        environment,
+    };
+}
+export function providerCommands(root, environment, configuration) {
+    const s = selected(root, environment, configuration);
+    return {
+        apiVersion: "ingestron.provider-command-catalogue/v1",
+        configuration,
+        environment,
+        provider: s.manifest.id,
+        version: s.manifest.version,
+        reference: s.reference,
+        commit: s.source.entry.commit,
+        execution: s.manifest.commands.execution,
+        commands: s.manifest.commands.definitions,
+    };
+}
+export function runProviderCommand(root, environment, args) {
+    const s = selected(root, environment, args.configuration), commands = s.manifest.commands;
+    const definition = commands.definitions.find((c) => c.name === args.command);
+    check(definition, "PROVIDER", `Unknown provider command ${args.command}; inspect provider_commands for ${args.configuration}`);
+    check(Buffer.byteLength(JSON.stringify(args.input)) <=
+        (s.manifest.projectAssembly?.command === args.command
+            ? 7_000_000
+            : 2_000_000), "LIMIT", "Command input exceeds its bounded transport limit");
+    const ajv = new Ajv2020({
+        strict: true,
+        allErrors: false,
+        validateFormats: false,
+    });
+    validateSchemaShape(definition.inputSchema);
+    const validate = ajv.compile(definition.inputSchema);
+    check(validate(args.input), "INPUT", `Invalid provider command input: ${ajv.errorsText(validate.errors)}`);
+    const module = fence(s.source.root, relative(s.source.root, resolve(dirname(s.source.file), commands.module)));
+    check(Object.hasOwn(s.source.entry.files, relative(s.source.root, module)), "PACKAGE", "Command module is not in the locked inventory");
+    let input = args.input;
+    let reportLock;
+    if (definition.reportPack) {
+        check(typeof input.reportPack === "string", "REPORT_PACK", "Select an exact installed report pack");
+        const packSource = resolvePackage(s.reader.root, input.reportPack);
+        const pack = reportPackSchema.parse(packageYaml(packSource.file));
+        check(pack.platform === s.manifest.platform, "REPORT_PACK", "Report pack/platform mismatch");
+        const modelSource = resolvePackage(s.reader.root, pack.model);
+        const model = validateModelPack(packageYaml(modelSource.file));
+        reportLock = {
+            reference: input.reportPack,
+            commit: packSource.entry.commit,
+            model: pack.model,
+            modelCommit: modelSource.entry.commit,
+        };
+        input = { ...input, reportPack: pack, modelPack: model, reportLock };
+    }
+    const request = {
+        apiVersion: "ingestron.provider-command-request/v1",
+        command: args.command,
+        context: {
+            project: s.project.id,
+            environment,
+            configuration: args.configuration,
+            provider: s.manifest.id,
+            version: s.manifest.version,
+            commit: s.source.entry.commit,
+        },
+        input,
+    };
+    const result = executeProvider(readFileSync(module, "utf8"), request, false, "command");
+    if (definition.resultSchema) {
+        validateSchemaShape(definition.resultSchema);
+        const validateResult = new Ajv2020({ strict: true }).compile(definition.resultSchema);
+        check(validateResult(result), "PROVIDER_COMMAND", "Provider result does not match its declared schema");
+    }
+    return {
+        apiVersion: "ingestron.provider-command-result/v1",
+        ...request.context,
+        command: args.command,
+        execution: "offline-json",
+        inputDigest: digest(canonical(input)),
+        ...(reportLock ? { reportLock } : {}),
+        result,
+    };
+}
+/** Core names are reserved even when a compatibility command is hidden. */
+export const reservedCommandNamespaces = new Set([
+    "init",
+    "check",
+    "plan",
+    "build",
+    "generate",
+    "validate",
+    "doctor",
+    "schema",
+    "source",
+    "contract",
+    "flow",
+    "step",
+    "table",
+    "dataset",
+    "config",
+    "environment",
+    "environments",
+    "plugin",
+    "plugins",
+    "provider",
+    "providers",
+    "packages",
+    "execution",
+    "runtime",
+    "run",
+    "deploy",
+    "advanced",
+    "mcp",
+    "help",
+    "version",
+    "connection",
+    "connections",
+    "activity",
+    "activities",
+    "standards",
+    "resolve",
+    "diff",
+    "validate-output",
+]);
+/** Data-only discovery; resolvePackage verifies locked bytes but never runs the guest. */
+export function pluginCommands(root, environment) {
+    const reader = new Configuration(root);
+    const project = reader.parse(projectSchema, reader.load());
+    check(project.environments[environment], "ENVIRONMENT", `Unknown environment ${environment}`);
+    const bindings = [];
+    const owners = new Map();
+    for (const [configuration, binding] of Object.entries(project.providers.configurations)) {
+        const pkg = project.providers.packages[binding.package];
+        if (!pkg || pkg.source.startsWith("builtin:") || pkg.source.startsWith("."))
+            continue;
+        const reference = canonicalPackageReference(`${pkg.source}@${pkg.version}`);
+        const source = resolvePackage(reader.root, reference);
+        const manifest = providerPackageSchema.parse(packageYaml(source.file));
+        if (!manifest.commands)
+            continue;
+        const catalogue = providerCommands(root, environment, configuration);
+        const namespace = manifest.commands.namespace ?? manifest.id;
+        check(/^[a-z][a-z0-9-]*$/.test(namespace) &&
+            !reservedCommandNamespaces.has(namespace), "COMMAND_NAMESPACE", `Invalid or reserved plugin namespace ${namespace}`);
+        check(!owners.has(namespace) || owners.get(namespace) === reference, "COMMAND_NAMESPACE", `Multiple packages claim namespace ${namespace}`);
+        owners.set(namespace, reference);
+        const names = catalogue.commands.map((c) => c.name);
+        check(!names.some((name) => names.some((other) => other.startsWith(name + " "))), "COMMAND_NAMESPACE", `Command path cannot also be a command group in ${namespace}`);
+        for (const command of catalogue.commands) {
+            validateSchemaShape(command.inputSchema);
+            if (command.resultSchema)
+                validateSchemaShape(command.resultSchema);
+        }
+        bindings.push({
+            ...catalogue,
+            namespace,
+            effects: "offline-json",
+            availability: "implemented",
+        });
+    }
+    return { apiVersion: "ingestron.plugin-commands/v1", bindings };
+}
+export function runPluginCommand(root, environment, args) {
+    const bindings = pluginCommands(root, environment).bindings.filter((binding) => binding.namespace === args.namespace &&
+        (!args.target || binding.configuration === args.target));
+    check(bindings.length > 0, "COMMAND_NAMESPACE", "No installed plugin binding matches namespace and target");
+    check(bindings.length === 1, "COMMAND_TARGET", "Multiple configurations match; select target explicitly");
+    return runProviderCommand(root, environment, {
+        configuration: bindings[0].configuration,
+        command: args.command,
+        input: args.input,
+    });
+}

package/dist/core/provider-starter.d.ts

@@ -0,0 +1,5 @@
+/** A complete offline example, deliberately without a platform execution adapter. */
+export declare function scaffoldProvider(root: string, args: {
+    id: string;
+    out: string;
+}): import("./authoring.js").Proposal;