@pipeline-builder/api-core 4.1.13 → 4.1.14

package/lib/validation/plugin-spec-schema.js

@@ -0,0 +1,163 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The plugin PACKAGE schemas: `plugin-spec.yaml` and `config.yaml`, exactly as
+ * the plugin service validates an upload. Shared from api-core so the upload
+ * path (api/plugin) and the CLI (`pipeline-manager plugin validate` /
+ * `plugin publish`) apply ONE schema and can't drift.
+ *
+ * Pure: no YAML parsing, no filesystem. Callers parse (with their own size and
+ * alias bounds) and hand the resulting object to {@link checkPluginSpec} /
+ * {@link checkPluginConfig}.
+ */
+import { z } from 'zod';
+import { PLUGIN_CHANGELOG_MAX_BYTES } from '../types/plugin-catalog.js';
+import { IconKeySchema, PLUGIN_CATALOG_FIELD_SCHEMAS, ProjectUrlSchema, isAllowedSpdxId, } from './plugin-catalog-metadata.js';
+// -----------------------------------------------------------------------------
+// Vocabularies
+// -----------------------------------------------------------------------------
+export const PLUGIN_TYPES = ['CodeBuildStep', 'ShellStep', 'ManualApprovalStep'];
+export const PLUGIN_COMPUTE_TYPES = ['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE'];
+export const PLUGIN_FAILURE_BEHAVIORS = ['fail', 'warn', 'ignore'];
+export const PLUGIN_BUILD_TYPES = ['build_image', 'prebuilt', 'metadata_only'];
+/** Plugin name: lowercase letters, digits and hyphens. */
+export const PLUGIN_NAME_PATTERN = /^[a-z0-9-]+$/;
+/** Plugin version: semver, with optional `-prerelease` and `+build` metadata. */
+export const PLUGIN_VERSION_PATTERN = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+// -----------------------------------------------------------------------------
+// network.egress (spec-only trust metadata)
+// -----------------------------------------------------------------------------
+/** Max declared `network.egress` hostnames. */
+export const EGRESS_MAX_HOSTS = 50;
+/**
+ * A bare DNS hostname, optionally with ONE leading `*.` wildcard label. No
+ * scheme, port, path, userinfo or IP literal — a declared egress target is a
+ * name the reviewer can read.
+ */
+const EGRESS_HOST_PATTERN = /^(?:\*\.)?(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z][a-z0-9-]{0,61}[a-z0-9]$/;
+/** True when `host` is an acceptable `network.egress` entry. */
+export function isValidEgressHost(host) {
+    return host.length <= 253 && EGRESS_HOST_PATTERN.test(host);
+}
+// -----------------------------------------------------------------------------
+// config.yaml
+// -----------------------------------------------------------------------------
+export const PluginConfigSchema = z.object({
+    pluginSpec: z.string().optional(),
+    dockerfile: z.string().optional(),
+    buildType: z.enum(PLUGIN_BUILD_TYPES).optional(),
+    // Deterministic build tag written by build-plugin-images.sh
+    // (`p-<name>-<sha256:12>`). Informational only on the upload path —
+    // the platform doesn't act on it, but it lives in the same config
+    // file as the rest of the build metadata so re-runs can short-circuit
+    // unchanged plugins without needing a separate .image-hash sidecar.
+    imageTag: z.string().optional(),
+}).strict()
+    .refine(d => !(d.buildType === 'prebuilt' && d.dockerfile), {
+    message: 'dockerfile is not allowed when buildType is prebuilt',
+})
+    .refine(d => !(d.buildType === 'metadata_only' && d.dockerfile), {
+    message: 'dockerfile is not allowed when buildType is metadata_only',
+});
+// -----------------------------------------------------------------------------
+// plugin-spec.yaml
+// -----------------------------------------------------------------------------
+// name/version/commands are the required-field contract, but they're checked by
+// {@link pluginSpecRequiredFieldsProblem} (the stable "name, version, and
+// commands are required" message and the ManualApprovalStep carve-out). Here
+// they're optional strings; the schema's job is to reject malformed *types* on
+// the fields that flow downstream unchecked.
+export const PluginSpecSchema = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
+    category: z.string().optional(),
+    version: z.string().optional(),
+    pluginType: z.enum(PLUGIN_TYPES).optional(),
+    computeType: z.enum(PLUGIN_COMPUTE_TYPES).optional(),
+    // >= 0 minutes: ManualApprovalStep specs legitimately declare `timeout: 0`.
+    timeout: z.number().int().nonnegative().optional(),
+    failureBehavior: z.enum(PLUGIN_FAILURE_BEHAVIORS).optional(),
+    secrets: z.array(z.object({
+        name: z.string().min(1),
+        required: z.boolean(),
+        description: z.string().optional(),
+    })).optional(),
+    // Accept an explicit `primaryOutputDirectory: null` (a ManualApprovalStep /
+    // output-less step legitimately declares it) and normalize it to `undefined`.
+    // Without `.nullish()` a present YAML `null` fails the bare string check and
+    // 400s the whole upload.
+    primaryOutputDirectory: z.string().nullish().transform((v) => v ?? undefined),
+    metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+    dockerfile: z.string().optional(),
+    installCommands: z.array(z.string()).optional(),
+    commands: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    buildArgs: z.record(z.string(), z.string()).optional(),
+    requiredMetadata: z.array(z.string()).optional(),
+    requiredVars: z.array(z.string()).optional(),
+    // Kept as free-string maps rather than a value enum: shipped specs use both
+    // `bool` and `boolean`, and the coercion-vs-declared-type consistency is
+    // enforced separately by the template contract check. The schema only
+    // guarantees they're string-valued records here.
+    metadataTypes: z.record(z.string(), z.string()).optional(),
+    varsTypes: z.record(z.string(), z.string()).optional(),
+    // A command the build tooling runs against the built image
+    // (build-plugin-images.sh, test-plugins.sh --build, `plugin test`).
+    smokeTest: z.string().optional(),
+    // Documentation + trust metadata. The README is NOT a spec field — it
+    // is README.md at the zip root.
+    license: z.string().refine(isAllowedSpdxId, {
+        message: 'must be a supported SPDX license identifier (e.g. Apache-2.0, MIT)',
+    }).optional(),
+    changelog: z.string().refine((v) => new TextEncoder().encode(v).length <= PLUGIN_CHANGELOG_MAX_BYTES, {
+        message: `must be at most ${PLUGIN_CHANGELOG_MAX_BYTES} bytes`,
+    }).optional(),
+    homepageUrl: ProjectUrlSchema.optional(),
+    sourceUrl: ProjectUrlSchema.optional(),
+    // Catalog metadata: the card one-liner and the docs link. Same
+    // validators as a value typed into the upload form.
+    summary: PLUGIN_CATALOG_FIELD_SCHEMAS.summary.optional(),
+    documentationUrl: ProjectUrlSchema.optional(),
+    icon: z.union([
+        IconKeySchema,
+        z.object({ key: IconKeySchema, badge: IconKeySchema.optional() }).strict(),
+    ]).optional(),
+    network: z.object({
+        egress: z.array(z.string().refine(isValidEgressHost, {
+            message: 'must be a bare hostname (no scheme, port or path; one leading *. allowed)',
+        })).max(EGRESS_MAX_HOSTS).optional(),
+    }).strict().optional(),
+}).strict();
+const isMapping = (raw) => typeof raw === 'object' && raw !== null && !Array.isArray(raw);
+function checkAgainst(file, raw, schema, withPath) {
+    if (!isMapping(raw)) {
+        const message = `${file} must be a YAML mapping`;
+        return { ok: false, issues: [message], message };
+    }
+    const result = schema.safeParse(raw);
+    if (result.success)
+        return { ok: true, value: result.data };
+    const issues = result.error.issues.map(i => (withPath ? `${i.path.join('.') || '(root)'}: ${i.message}` : i.message));
+    return { ok: false, issues, message: `${file}: ${issues.join('; ')}` };
+}
+/** Check a parsed `plugin-spec.yaml` document against {@link PluginSpecSchema}. */
+export function checkPluginSpec(raw) {
+    return checkAgainst('plugin-spec.yaml', raw, PluginSpecSchema, true);
+}
+/** Check a parsed `config.yaml` document against {@link PluginConfigSchema}. */
+export function checkPluginConfig(raw) {
+    return checkAgainst('config.yaml', raw, PluginConfigSchema, false);
+}
+/**
+ * The required-field contract: `name` and `version` always, `commands` for
+ * every type except `ManualApprovalStep`. Returns the upload's message, or null.
+ */
+export function pluginSpecRequiredFieldsProblem(spec) {
+    const isApprovalStep = spec.pluginType === 'ManualApprovalStep';
+    if (!spec.name || !spec.version || (!isApprovalStep && !spec.commands)) {
+        return 'Invalid spec: name, version, and commands are required';
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-spec-schema.js","sourceRoot":"","sources":["../../src/validation/plugin-spec-schema.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin PACKAGE schemas: `plugin-spec.yaml` and `config.yaml`, exactly as\n * the plugin service validates an upload. Shared from api-core so the upload\n * path (api/plugin) and the CLI (`pipeline-manager plugin validate` /\n * `plugin publish`) apply ONE schema and can't drift.\n *\n * Pure: no YAML parsing, no filesystem. Callers parse (with their own size and\n * alias bounds) and hand the resulting object to {@link checkPluginSpec} /\n * {@link checkPluginConfig}.\n */\n\nimport { z } from 'zod';\n\nimport { PLUGIN_CHANGELOG_MAX_BYTES } from '../types/plugin-catalog.js';\nimport {\n  IconKeySchema, PLUGIN_CATALOG_FIELD_SCHEMAS, ProjectUrlSchema, isAllowedSpdxId,\n} from './plugin-catalog-metadata.js';\n\n// -----------------------------------------------------------------------------\n// Vocabularies\n// -----------------------------------------------------------------------------\n\nexport const PLUGIN_TYPES = ['CodeBuildStep', 'ShellStep', 'ManualApprovalStep'] as const;\nexport const PLUGIN_COMPUTE_TYPES = ['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE'] as const;\nexport const PLUGIN_FAILURE_BEHAVIORS = ['fail', 'warn', 'ignore'] as const;\nexport const PLUGIN_BUILD_TYPES = ['build_image', 'prebuilt', 'metadata_only'] as const;\nexport type PluginBuildType = typeof PLUGIN_BUILD_TYPES[number];\n\n/** Plugin name: lowercase letters, digits and hyphens. */\nexport const PLUGIN_NAME_PATTERN = /^[a-z0-9-]+$/;\n/** Plugin version: semver, with optional `-prerelease` and `+build` metadata. */\nexport const PLUGIN_VERSION_PATTERN = /^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$/;\n\n// -----------------------------------------------------------------------------\n// network.egress (spec-only trust metadata)\n// -----------------------------------------------------------------------------\n\n/** Max declared `network.egress` hostnames. */\nexport const EGRESS_MAX_HOSTS = 50;\n\n/**\n * A bare DNS hostname, optionally with ONE leading `*.` wildcard label. No\n * scheme, port, path, userinfo or IP literal — a declared egress target is a\n * name the reviewer can read.\n */\nconst EGRESS_HOST_PATTERN = /^(?:\\*\\.)?(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z][a-z0-9-]{0,61}[a-z0-9]$/;\n\n/** True when `host` is an acceptable `network.egress` entry. */\nexport function isValidEgressHost(host: string): boolean {\n  return host.length <= 253 && EGRESS_HOST_PATTERN.test(host);\n}\n\n// -----------------------------------------------------------------------------\n// config.yaml\n// -----------------------------------------------------------------------------\n\nexport const PluginConfigSchema = z.object({\n  pluginSpec: z.string().optional(),\n  dockerfile: z.string().optional(),\n  buildType: z.enum(PLUGIN_BUILD_TYPES).optional(),\n  // Deterministic build tag written by build-plugin-images.sh\n  // (`p-<name>-<sha256:12>`). Informational only on the upload path —\n  // the platform doesn't act on it, but it lives in the same config\n  // file as the rest of the build metadata so re-runs can short-circuit\n  // unchanged plugins without needing a separate .image-hash sidecar.\n  imageTag: z.string().optional(),\n}).strict()\n  .refine(d => !(d.buildType === 'prebuilt' && d.dockerfile), {\n    message: 'dockerfile is not allowed when buildType is prebuilt',\n  })\n  .refine(d => !(d.buildType === 'metadata_only' && d.dockerfile), {\n    message: 'dockerfile is not allowed when buildType is metadata_only',\n  });\nexport type PluginConfigInput = z.infer<typeof PluginConfigSchema>;\n\n// -----------------------------------------------------------------------------\n// plugin-spec.yaml\n// -----------------------------------------------------------------------------\n\n// name/version/commands are the required-field contract, but they're checked by\n// {@link pluginSpecRequiredFieldsProblem} (the stable \"name, version, and\n// commands are required\" message and the ManualApprovalStep carve-out). Here\n// they're optional strings; the schema's job is to reject malformed *types* on\n// the fields that flow downstream unchecked.\nexport const PluginSpecSchema = z.object({\n  name: z.string().optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  category: z.string().optional(),\n  version: z.string().optional(),\n  pluginType: z.enum(PLUGIN_TYPES).optional(),\n  computeType: z.enum(PLUGIN_COMPUTE_TYPES).optional(),\n  // >= 0 minutes: ManualApprovalStep specs legitimately declare `timeout: 0`.\n  timeout: z.number().int().nonnegative().optional(),\n  failureBehavior: z.enum(PLUGIN_FAILURE_BEHAVIORS).optional(),\n  secrets: z.array(z.object({\n    name: z.string().min(1),\n    required: z.boolean(),\n    description: z.string().optional(),\n  })).optional(),\n  // Accept an explicit `primaryOutputDirectory: null` (a ManualApprovalStep /\n  // output-less step legitimately declares it) and normalize it to `undefined`.\n  // Without `.nullish()` a present YAML `null` fails the bare string check and\n  // 400s the whole upload.\n  primaryOutputDirectory: z.string().nullish().transform((v) => v ?? undefined),\n  metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),\n  dockerfile: z.string().optional(),\n  installCommands: z.array(z.string()).optional(),\n  commands: z.array(z.string()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  buildArgs: z.record(z.string(), z.string()).optional(),\n  requiredMetadata: z.array(z.string()).optional(),\n  requiredVars: z.array(z.string()).optional(),\n  // Kept as free-string maps rather than a value enum: shipped specs use both\n  // `bool` and `boolean`, and the coercion-vs-declared-type consistency is\n  // enforced separately by the template contract check. The schema only\n  // guarantees they're string-valued records here.\n  metadataTypes: z.record(z.string(), z.string()).optional(),\n  varsTypes: z.record(z.string(), z.string()).optional(),\n  // A command the build tooling runs against the built image\n  // (build-plugin-images.sh, test-plugins.sh --build, `plugin test`).\n  smokeTest: z.string().optional(),\n  // Documentation + trust metadata. The README is NOT a spec field — it\n  // is README.md at the zip root.\n  license: z.string().refine(isAllowedSpdxId, {\n    message: 'must be a supported SPDX license identifier (e.g. Apache-2.0, MIT)',\n  }).optional(),\n  changelog: z.string().refine((v) => new TextEncoder().encode(v).length <= PLUGIN_CHANGELOG_MAX_BYTES, {\n    message: `must be at most ${PLUGIN_CHANGELOG_MAX_BYTES} bytes`,\n  }).optional(),\n  homepageUrl: ProjectUrlSchema.optional(),\n  sourceUrl: ProjectUrlSchema.optional(),\n  // Catalog metadata: the card one-liner and the docs link. Same\n  // validators as a value typed into the upload form.\n  summary: PLUGIN_CATALOG_FIELD_SCHEMAS.summary.optional(),\n  documentationUrl: ProjectUrlSchema.optional(),\n  icon: z.union([\n    IconKeySchema,\n    z.object({ key: IconKeySchema, badge: IconKeySchema.optional() }).strict(),\n  ]).optional(),\n  network: z.object({\n    egress: z.array(z.string().refine(isValidEgressHost, {\n      message: 'must be a bare hostname (no scheme, port or path; one leading *. allowed)',\n    })).max(EGRESS_MAX_HOSTS).optional(),\n  }).strict().optional(),\n}).strict();\nexport type PluginSpecInput = z.infer<typeof PluginSpecSchema>;\n\n/**\n * Result of checking a parsed YAML document against a package schema:\n * `issues` are the individual problems, `message` the one-line form the upload\n * API reports (`plugin-spec.yaml: <path>: <problem>; …`).\n */\nexport type PackageCheck<T> = { ok: true; value: T } | { ok: false; issues: string[]; message: string };\n\nconst isMapping = (raw: unknown): raw is Record<string, unknown> =>\n  typeof raw === 'object' && raw !== null && !Array.isArray(raw);\n\nfunction checkAgainst<T>(file: string, raw: unknown, schema: z.ZodType<T>, withPath: boolean): PackageCheck<T> {\n  if (!isMapping(raw)) {\n    const message = `${file} must be a YAML mapping`;\n    return { ok: false, issues: [message], message };\n  }\n  const result = schema.safeParse(raw);\n  if (result.success) return { ok: true, value: result.data };\n  const issues = result.error.issues.map(i => (withPath ? `${i.path.join('.') || '(root)'}: ${i.message}` : i.message));\n  return { ok: false, issues, message: `${file}: ${issues.join('; ')}` };\n}\n\n/** Check a parsed `plugin-spec.yaml` document against {@link PluginSpecSchema}. */\nexport function checkPluginSpec(raw: unknown): PackageCheck<PluginSpecInput> {\n  return checkAgainst('plugin-spec.yaml', raw, PluginSpecSchema, true);\n}\n\n/** Check a parsed `config.yaml` document against {@link PluginConfigSchema}. */\nexport function checkPluginConfig(raw: unknown): PackageCheck<PluginConfigInput> {\n  return checkAgainst('config.yaml', raw, PluginConfigSchema, false);\n}\n\n/**\n * The required-field contract: `name` and `version` always, `commands` for\n * every type except `ManualApprovalStep`. Returns the upload's message, or null.\n */\nexport function pluginSpecRequiredFieldsProblem(spec: Pick<PluginSpecInput, 'name' | 'version' | 'commands' | 'pluginType'>): string | null {\n  const isApprovalStep = spec.pluginType === 'ManualApprovalStep';\n  if (!spec.name || !spec.version || (!isApprovalStep && !spec.commands)) {\n    return 'Invalid spec: name, version, and commands are required';\n  }\n  return null;\n}\n"]}

package/lib/validation/plugin-template-contract.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The plugin spec's `{{ ... }}` TEMPLATE CONTRACT, exactly as the plugin
+ * service checks an upload. Shared from api-core so the upload path
+ * (api/plugin) and the CLI (`pipeline-manager plugin validate` / `test` /
+ * `publish`) apply ONE check and can't drift (plugin-ecosystem W6).
+ *
+ * Pure: it returns issues and never throws. The template engine (tokenizer and
+ * scope validator) lives in pipeline-core, which depends on api-core, so the
+ * caller hands it in as {@link PluginTemplateEngine}; pipeline-core's module
+ * satisfies the interface as-is.
+ */
+/** Scope roots a plugin template may reference. */
+export declare const PLUGIN_TEMPLATE_SCOPE_ROOTS: readonly ['pipeline', 'plugin', 'env'];
+/** Spec fields whose strings may carry `{{ ... }}` templates. */
+export declare const PLUGIN_TEMPLATABLE_FIELDS: readonly ['description', 'commands', 'installCommands', 'env', 'buildArgs'];
+/** True when a walked field path (`commands[2]`, `env.STAGE`) is templatable. */
+export declare function isPluginTemplatableField(field: string): boolean;
+/** The slice of pipeline-core's template engine this check uses. */
+export interface PluginTemplateEngine {
+    allowedScopeRoots(roots: string[]): (path: string[]) => boolean;
+    validateTemplates(doc: object, isTemplatable: (field: string) => boolean, isKnownPath: (path: string[]) => boolean): {
+        errors: ReadonlyArray<{
+            field: string;
+            line?: number;
+            col?: number;
+            message: string;
+        }>;
+    };
+    tokenize(source: string): ReadonlyArray<{
+        kind: string;
+        path?: string[];
+        defaultValue?: string;
+        coerce?: string;
+    }>;
+}
+/**
+ * One template-contract problem.
+ * - `template`: a parse error, unknown scope root or reserved `secrets.*` path.
+ * - `undeclared`: `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` without
+ *   `X` in `requiredMetadata` / `requiredVars` (and no `| default:`).
+ * - `type-mismatch`: a `| number|bool|json` filter whose declared type differs.
+ */
+export interface PluginTemplateIssue {
+    kind: 'template' | 'undeclared' | 'type-mismatch';
+    /** The spec field (`commands[0]`) for `template` issues; the scope path otherwise. */
+    field: string;
+    line?: number;
+    col?: number;
+    message: string;
+}
+/**
+ * Every `{{ ... }}` problem in a plugin spec: parse errors and scope roots
+ * (only `pipeline`, `plugin`, `env`; `secrets` is reserved), then per
+ * `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` reference (a) that `X`
+ * is declared in `requiredMetadata` / `requiredVars` unless it has a
+ * `| default:`, and (b) that a coercion filter matches the declared type in
+ * `metadataTypes` / `varsTypes` (undeclared = `string`; `boolean` = `bool`).
+ *
+ * Takes the raw spec object, so a spec that failed the schema is still checked.
+ * Issues are de-duplicated; an empty array means the spec passes.
+ */
+export declare function checkPluginTemplates(spec: object, engine: PluginTemplateEngine): PluginTemplateIssue[];
+/** One line per issue: `[commands[0]:1:5] message` for template issues, the message otherwise. */
+export declare function formatPluginTemplateIssue(issue: PluginTemplateIssue): string;

package/lib/validation/plugin-template-contract.js

@@ -0,0 +1,113 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The plugin spec's `{{ ... }}` TEMPLATE CONTRACT, exactly as the plugin
+ * service checks an upload. Shared from api-core so the upload path
+ * (api/plugin) and the CLI (`pipeline-manager plugin validate` / `test` /
+ * `publish`) apply ONE check and can't drift (plugin-ecosystem W6).
+ *
+ * Pure: it returns issues and never throws. The template engine (tokenizer and
+ * scope validator) lives in pipeline-core, which depends on api-core, so the
+ * caller hands it in as {@link PluginTemplateEngine}; pipeline-core's module
+ * satisfies the interface as-is.
+ */
+/** Scope roots a plugin template may reference. */
+export const PLUGIN_TEMPLATE_SCOPE_ROOTS = ['pipeline', 'plugin', 'env'];
+/** Spec fields whose strings may carry `{{ ... }}` templates. */
+export const PLUGIN_TEMPLATABLE_FIELDS = ['description', 'commands', 'installCommands', 'env', 'buildArgs'];
+/** True when a walked field path (`commands[2]`, `env.STAGE`) is templatable. */
+export function isPluginTemplatableField(field) {
+    return PLUGIN_TEMPLATABLE_FIELDS.some((f) => field === f || field.startsWith(`${f}[`) || field.startsWith(`${f}.`));
+}
+const COERCE_TO_TYPE = { number: 'number', bool: 'bool', json: 'json' };
+const stringList = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+const stringValues = (v) => (v && typeof v === 'object' && !Array.isArray(v)
+    ? Object.values(v).filter((x) => typeof x === 'string')
+    : []);
+const stringMap = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+/**
+ * Every `{{ ... }}` problem in a plugin spec: parse errors and scope roots
+ * (only `pipeline`, `plugin`, `env`; `secrets` is reserved), then per
+ * `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` reference (a) that `X`
+ * is declared in `requiredMetadata` / `requiredVars` unless it has a
+ * `| default:`, and (b) that a coercion filter matches the declared type in
+ * `metadataTypes` / `varsTypes` (undeclared = `string`; `boolean` = `bool`).
+ *
+ * Takes the raw spec object, so a spec that failed the schema is still checked.
+ * Issues are de-duplicated; an empty array means the spec passes.
+ */
+export function checkPluginTemplates(spec, engine) {
+    const s = spec;
+    const doc = {
+        description: s.description,
+        commands: s.commands,
+        installCommands: s.installCommands,
+        env: s.env,
+        buildArgs: s.buildArgs,
+    };
+    const issues = [];
+    const { errors } = engine.validateTemplates(doc, isPluginTemplatableField, engine.allowedScopeRoots([...PLUGIN_TEMPLATE_SCOPE_ROOTS]));
+    for (const e of errors) {
+        issues.push({ kind: 'template', field: e.field, ...(e.line !== undefined && { line: e.line, col: e.col }), message: e.message });
+    }
+    const required = { metadata: new Set(stringList(s.requiredMetadata)), vars: new Set(stringList(s.requiredVars)) };
+    const types = { metadata: stringMap(s.metadataTypes), vars: stringMap(s.varsTypes) };
+    const sources = [
+        ...(typeof s.description === 'string' ? [s.description] : []),
+        ...stringList(s.commands), ...stringList(s.installCommands), ...stringValues(s.env), ...stringValues(s.buildArgs),
+    ];
+    const seen = new Set();
+    const add = (issue) => {
+        const key = `${issue.kind}\u0000${issue.message}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            issues.push(issue);
+        }
+    };
+    for (const source of sources) {
+        if (!source.includes('{{'))
+            continue;
+        let tokens;
+        try {
+            tokens = engine.tokenize(source);
+        }
+        catch {
+            continue; /* reported as a `template` issue above */
+        }
+        for (const t of tokens) {
+            if (t.kind !== 'expr' || !t.path)
+                continue;
+            const [root, sub, key] = t.path;
+            if (root !== 'pipeline' || (sub !== 'metadata' && sub !== 'vars') || !key)
+                continue;
+            const scopePath = `pipeline.${sub}.${key}`;
+            const declaredIn = sub === 'metadata' ? 'requiredMetadata' : 'requiredVars';
+            const typesIn = sub === 'metadata' ? 'metadataTypes' : 'varsTypes';
+            if (t.defaultValue === undefined && !required[sub].has(key)) {
+                add({ kind: 'undeclared', field: scopePath, message: `${scopePath} is not declared in '${declaredIn}' (declare it, or add '| default: ...')` });
+            }
+            const expected = t.coerce ? COERCE_TO_TYPE[t.coerce] : undefined;
+            if (expected) {
+                // Shipped specs spell the boolean type both `bool` and `boolean`; the
+                // stored contract (and the filter) use `bool`.
+                const raw = types[sub][key] ?? 'string';
+                const declared = raw === 'boolean' ? 'bool' : raw;
+                if (declared !== expected) {
+                    add({
+                        kind: 'type-mismatch',
+                        field: scopePath,
+                        message: `${scopePath} uses '| ${t.coerce}' but declared type is '${declared}' (add '${key}: ${expected}' to ${typesIn})`,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/** One line per issue: `[commands[0]:1:5] message` for template issues, the message otherwise. */
+export function formatPluginTemplateIssue(issue) {
+    if (issue.kind !== 'template')
+        return issue.message;
+    return `[${issue.field}${issue.line !== undefined ? `:${issue.line}:${issue.col}` : ''}] ${issue.message}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-template-contract.js","sourceRoot":"","sources":["../../src/validation/plugin-template-contract.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin spec's `{{ ... }}` TEMPLATE CONTRACT, exactly as the plugin\n * service checks an upload. Shared from api-core so the upload path\n * (api/plugin) and the CLI (`pipeline-manager plugin validate` / `test` /\n * `publish`) apply ONE check and can't drift (plugin-ecosystem W6).\n *\n * Pure: it returns issues and never throws. The template engine (tokenizer and\n * scope validator) lives in pipeline-core, which depends on api-core, so the\n * caller hands it in as {@link PluginTemplateEngine}; pipeline-core's module\n * satisfies the interface as-is.\n */\n\n/** Scope roots a plugin template may reference. */\nexport const PLUGIN_TEMPLATE_SCOPE_ROOTS = ['pipeline', 'plugin', 'env'] as const;\n\n/** Spec fields whose strings may carry `{{ ... }}` templates. */\nexport const PLUGIN_TEMPLATABLE_FIELDS = ['description', 'commands', 'installCommands', 'env', 'buildArgs'] as const;\n\n/** True when a walked field path (`commands[2]`, `env.STAGE`) is templatable. */\nexport function isPluginTemplatableField(field: string): boolean {\n  return PLUGIN_TEMPLATABLE_FIELDS.some((f) => field === f || field.startsWith(`${f}[`) || field.startsWith(`${f}.`));\n}\n\n/** The slice of pipeline-core's template engine this check uses. */\nexport interface PluginTemplateEngine {\n  allowedScopeRoots(roots: string[]): (path: string[]) => boolean;\n  validateTemplates(\n    doc: object,\n    isTemplatable: (field: string) => boolean,\n    isKnownPath: (path: string[]) => boolean,\n  ): { errors: ReadonlyArray<{ field: string; line?: number; col?: number; message: string }> };\n  tokenize(source: string): ReadonlyArray<{ kind: string; path?: string[]; defaultValue?: string; coerce?: string }>;\n}\n\n/**\n * One template-contract problem.\n * - `template`: a parse error, unknown scope root or reserved `secrets.*` path.\n * - `undeclared`: `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` without\n *   `X` in `requiredMetadata` / `requiredVars` (and no `| default:`).\n * - `type-mismatch`: a `| number|bool|json` filter whose declared type differs.\n */\nexport interface PluginTemplateIssue {\n  kind: 'template' | 'undeclared' | 'type-mismatch';\n  /** The spec field (`commands[0]`) for `template` issues; the scope path otherwise. */\n  field: string;\n  line?: number;\n  col?: number;\n  message: string;\n}\n\nconst COERCE_TO_TYPE: Readonly<Record<string, string>> = { number: 'number', bool: 'bool', json: 'json' };\n\nconst stringList = (v: unknown): string[] =>\n  (Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : []);\nconst stringValues = (v: unknown): string[] =>\n  (v && typeof v === 'object' && !Array.isArray(v)\n    ? Object.values(v as Record<string, unknown>).filter((x): x is string => typeof x === 'string')\n    : []);\nconst stringMap = (v: unknown): Record<string, string> =>\n  (v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, string> : {});\n\n/**\n * Every `{{ ... }}` problem in a plugin spec: parse errors and scope roots\n * (only `pipeline`, `plugin`, `env`; `secrets` is reserved), then per\n * `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` reference (a) that `X`\n * is declared in `requiredMetadata` / `requiredVars` unless it has a\n * `| default:`, and (b) that a coercion filter matches the declared type in\n * `metadataTypes` / `varsTypes` (undeclared = `string`; `boolean` = `bool`).\n *\n * Takes the raw spec object, so a spec that failed the schema is still checked.\n * Issues are de-duplicated; an empty array means the spec passes.\n */\nexport function checkPluginTemplates(spec: object, engine: PluginTemplateEngine): PluginTemplateIssue[] {\n  const s = spec as Record<string, unknown>;\n  const doc = {\n    description: s.description,\n    commands: s.commands,\n    installCommands: s.installCommands,\n    env: s.env,\n    buildArgs: s.buildArgs,\n  };\n  const issues: PluginTemplateIssue[] = [];\n\n  const { errors } = engine.validateTemplates(doc, isPluginTemplatableField, engine.allowedScopeRoots([...PLUGIN_TEMPLATE_SCOPE_ROOTS]));\n  for (const e of errors) {\n    issues.push({ kind: 'template', field: e.field, ...(e.line !== undefined && { line: e.line, col: e.col }), message: e.message });\n  }\n\n  const required = { metadata: new Set(stringList(s.requiredMetadata)), vars: new Set(stringList(s.requiredVars)) };\n  const types = { metadata: stringMap(s.metadataTypes), vars: stringMap(s.varsTypes) };\n  const sources = [\n    ...(typeof s.description === 'string' ? [s.description] : []),\n    ...stringList(s.commands), ...stringList(s.installCommands), ...stringValues(s.env), ...stringValues(s.buildArgs),\n  ];\n  const seen = new Set<string>();\n  const add = (issue: PluginTemplateIssue) => {\n    const key = `${issue.kind}\\u0000${issue.message}`;\n    if (!seen.has(key)) { seen.add(key); issues.push(issue); }\n  };\n\n  for (const source of sources) {\n    if (!source.includes('{{')) continue;\n    let tokens;\n    try { tokens = engine.tokenize(source); } catch { continue; /* reported as a `template` issue above */ }\n    for (const t of tokens) {\n      if (t.kind !== 'expr' || !t.path) continue;\n      const [root, sub, key] = t.path;\n      if (root !== 'pipeline' || (sub !== 'metadata' && sub !== 'vars') || !key) continue;\n      const scopePath = `pipeline.${sub}.${key}`;\n      const declaredIn = sub === 'metadata' ? 'requiredMetadata' : 'requiredVars';\n      const typesIn = sub === 'metadata' ? 'metadataTypes' : 'varsTypes';\n\n      if (t.defaultValue === undefined && !required[sub].has(key)) {\n        add({ kind: 'undeclared', field: scopePath, message: `${scopePath} is not declared in '${declaredIn}' (declare it, or add '| default: ...')` });\n      }\n      const expected = t.coerce ? COERCE_TO_TYPE[t.coerce] : undefined;\n      if (expected) {\n        // Shipped specs spell the boolean type both `bool` and `boolean`; the\n        // stored contract (and the filter) use `bool`.\n        const raw = types[sub][key] ?? 'string';\n        const declared = raw === 'boolean' ? 'bool' : raw;\n        if (declared !== expected) {\n          add({\n            kind: 'type-mismatch',\n            field: scopePath,\n            message: `${scopePath} uses '| ${t.coerce}' but declared type is '${declared}' (add '${key}: ${expected}' to ${typesIn})`,\n          });\n        }\n      }\n    }\n  }\n  return issues;\n}\n\n/** One line per issue: `[commands[0]:1:5] message` for template issues, the message otherwise. */\nexport function formatPluginTemplateIssue(issue: PluginTemplateIssue): string {\n  if (issue.kind !== 'template') return issue.message;\n  return `[${issue.field}${issue.line !== undefined ? `:${issue.line}:${issue.col}` : ''}] ${issue.message}`;\n}\n"]}

package/package.json

@@ -10,7 +10,7 @@
     "@stylistic/eslint-plugin": "^2",
     "@types/express": "5.0.6",
     "@types/jsonwebtoken": "9.0.10",
-    "@types/node": "26.1.2",
+    "@types/node": "^24",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
     "@typescript/native": "npm:typescript@^7.0.2",
@@ -94,10 +94,16 @@
       ],
       "metadata-keys": [
         "lib/types/metadata-keys.d.ts"
+      ],
+      "feature-flags": [
+        "lib/types/feature-flags.d.ts"
+      ],
+      "plugin-catalog": [
+        "lib/types/plugin-catalog.d.ts"
       ]
     }
   },
-  "version": "4.1.13",
+  "version": "4.1.14",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },
@@ -161,11 +167,31 @@
     "setupFilesAfterEnv": [
       "<rootDir>/../../jest-env-guard.js"
     ],
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/testing/**",
+      "!src/constants/index.ts",
+      "!src/errors/index.ts",
+      "!src/helpers/index.ts",
+      "!src/index.ts",
+      "!src/middleware/index.ts",
+      "!src/openapi/index.ts",
+      "!src/routes/index.ts",
+      "!src/services/index.ts",
+      "!src/testing/any-fn.ts",
+      "!src/testing/index.ts",
+      "!src/types/audit-events.ts",
+      "!src/types/http.ts",
+      "!src/types/index.ts",
+      "!src/utils/index.ts",
+      "!src/validation/index.ts"
+    ],
     "coverageThreshold": {
       "global": {
         "statements": 95,
-        "branches": 88,
-        "functions": 88,
+        "branches": 91,
+        "functions": 91,
         "lines": 95
       },
       "**/src/utils/audit.ts": {
@@ -191,20 +217,59 @@
       "types": "./lib/types/metadata-keys.d.ts",
       "default": "./lib/types/metadata-keys.js"
     },
+    "./feature-flags": {
+      "types": "./lib/types/feature-flags.d.ts",
+      "default": "./lib/types/feature-flags.js"
+    },
+    "./plugin-catalog": {
+      "types": "./lib/types/plugin-catalog.d.ts",
+      "default": "./lib/types/plugin-catalog.js"
+    },
+    "./testing": {
+      "types": "./lib/testing/index.d.ts",
+      "default": "./lib/testing/index.js"
+    },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },
+  "nx": {
+    "targets": {
+      "build": {
+        "inputs": [
+          "default",
+          "^default",
+          "sharedGlobals",
+          "{workspaceRoot}/docs/environment-variables.md",
+          "!{projectRoot}/lib/**/*",
+          "!{projectRoot}/dist/**/*"
+        ]
+      },
+      "test": {
+        "inputs": [
+          "default",
+          "^default",
+          "sharedGlobals",
+          "{workspaceRoot}/docs/environment-variables.md",
+          "!{projectRoot}/lib/**/*",
+          "!{projectRoot}/dist/**/*"
+        ]
+      }
+    }
+  },
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm dlx projen\".",
   "scripts": {
     "build": "pnpm dlx projen build",
     "compile": "pnpm dlx projen compile",
     "default": "pnpm dlx projen default",
     "eslint": "pnpm dlx projen eslint",
+    "lint:fix": "pnpm dlx projen lint:fix",
     "package": "pnpm dlx projen package",
     "post-compile": "pnpm dlx projen post-compile",
     "pre-compile": "pnpm dlx projen pre-compile",
     "test": "pnpm dlx projen test",
+    "test:update": "pnpm dlx projen test:update",
     "test:watch": "pnpm dlx projen test:watch",
+    "typecheck:tests": "pnpm dlx projen typecheck:tests",
     "watch": "pnpm dlx projen watch",
     "projen": "pnpm dlx projen"
   }