@intentius/chant-lexicon-gitlab 0.124.31 → 0.124.32

package/dist/coverage.js

@@ -0,0 +1,35 @@
+/**
+ * Coverage analysis for GitLab CI lexicon.
+ *
+ * Measures how many of the CI schema's definitions are covered
+ * by the generated lexicon entities.
+ */
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds, } from "@intentius/chant/codegen/coverage";
+export { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds };
+/**
+ * Run coverage analysis for the GitLab lexicon.
+ */
+export async function analyzeGitLabCoverage(opts) {
+    const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+    const lexiconPath = join(basePath, "src", "generated", "lexicon-gitlab.json");
+    const content = readFileSync(lexiconPath, "utf-8");
+    const report = computeCoverage(content);
+    if (opts?.verbose) {
+        console.error(formatVerbose(report));
+    }
+    else {
+        console.error(formatSummary(report));
+    }
+    if (typeof opts?.minOverall === "number") {
+        const result = checkThresholds(report, { minOverallPct: opts.minOverall });
+        if (!result.ok) {
+            for (const v of result.violations)
+                console.error(`  FAIL: ${v}`);
+            throw new Error("Coverage below threshold");
+        }
+    }
+    return report;
+}

package/dist/generated/index.js

@@ -0,0 +1,25 @@
+// Code generated by chant generate. DO NOT EDIT.
+import { createResource, createProperty } from "./runtime.js";
+export const Default = /* @__PURE__ */ createResource("GitLab::CI::Default", "gitlab", {});
+export const Job = /* @__PURE__ */ createResource("GitLab::CI::Job", "gitlab", {});
+export const Pipeline = /* @__PURE__ */ createResource("GitLab::CI::Pipeline", "gitlab", {});
+export const Workflow = /* @__PURE__ */ createResource("GitLab::CI::Workflow", "gitlab", {});
+export const AllowFailure = /* @__PURE__ */ createProperty("GitLab::CI::AllowFailure", "gitlab");
+export const Artifacts = /* @__PURE__ */ createProperty("GitLab::CI::Artifacts", "gitlab");
+export const AutoCancel = /* @__PURE__ */ createProperty("GitLab::CI::AutoCancel", "gitlab");
+export const Cache = /* @__PURE__ */ createProperty("GitLab::CI::Cache", "gitlab");
+export const Environment = /* @__PURE__ */ createProperty("GitLab::CI::Environment", "gitlab");
+export const Image = /* @__PURE__ */ createProperty("GitLab::CI::Image", "gitlab");
+export const Include = /* @__PURE__ */ createProperty("GitLab::CI::Include", "gitlab");
+export const Inherit = /* @__PURE__ */ createProperty("GitLab::CI::Inherit", "gitlab");
+export const Need = /* @__PURE__ */ createProperty("GitLab::CI::Need", "gitlab");
+export const Parallel = /* @__PURE__ */ createProperty("GitLab::CI::Parallel", "gitlab");
+export const Release = /* @__PURE__ */ createProperty("GitLab::CI::Release", "gitlab");
+export const Retry = /* @__PURE__ */ createProperty("GitLab::CI::Retry", "gitlab");
+export const Rule = /* @__PURE__ */ createProperty("GitLab::CI::Rule", "gitlab");
+export const Service = /* @__PURE__ */ createProperty("GitLab::CI::Service", "gitlab");
+export const Trigger = /* @__PURE__ */ createProperty("GitLab::CI::Trigger", "gitlab");
+export const WorkflowRule = /* @__PURE__ */ createProperty("GitLab::CI::WorkflowRule", "gitlab");
+// Re-exports for convenience
+export { reference } from "../intrinsics.js";
+export { CI } from "../variables.js";

package/dist/generated/runtime.js

@@ -0,0 +1,4 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";

package/dist/graph-edges.js

@@ -0,0 +1,202 @@
+/**
+ * GitLab CI dependencies as graph edges (#3910).
+ *
+ * A GitLab job names everything it depends on as a string: the jobs it
+ * `needs`, the job it `extends`, the pipeline it `trigger`s, and the pipeline
+ * names the files it `include`s. `chant graph` cannot read those, so this
+ * module resolves them against the declared entities and reports each one
+ * through the plugin's `graphEdges` hook:
+ *
+ *  - `needs`    job -> job, from `needs:` (a name, `{ job }`, or the Job
+ *               itself); a job without `needs:` waits for the stages before
+ *               its own, reported as `needs` via `stage`
+ *  - `extends`  job -> the job it inherits from
+ *  - `triggers` job -> the child or multi-project pipeline it starts
+ *  - `includes` pipeline -> each file its `include:` pulls in
+ *
+ * Jobs are named in the YAML by their kebab-cased export name, as
+ * ./serializer.ts writes them. Cross-pipeline references (`trigger:`,
+ * `include:`, `needs: { project }` and `needs: { pipeline }`) name a pipeline
+ * this project does not generate, so they are reported as dangling and
+ * marked `crossPipeline`. So is any job name nothing declares: a hidden
+ * template from an included file, a typo.
+ */
+import { isPropertyDeclarable } from "@intentius/chant/declarable";
+const JOB = "GitLab::CI::Job";
+const PIPELINE = "GitLab::CI::Pipeline";
+const PIPELINE_LEVEL = new Set([PIPELINE, "GitLab::CI::Default", "GitLab::CI::Workflow"]);
+/** The YAML name ./serializer.ts gives a job. */
+function yamlName(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function entityType(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const t = value.entityType;
+    return typeof t === "string" ? t : undefined;
+}
+/** A Declarable's props bag, or the plain object itself. */
+function propsOf(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    if (entityType(value) !== undefined) {
+        const props = value.props;
+        return props && typeof props === "object" ? props : undefined;
+    }
+    return value;
+}
+const asList = (value) => (Array.isArray(value) ? value : value === undefined || value === null ? [] : [value]);
+/** GitLab's default stages, used when nothing declares a `stages:` list. */
+const DEFAULT_STAGES = ["build", "test", "deploy"];
+/**
+ * The stage order GitLab runs, as ./serializer.ts emits it: a Pipeline's
+ * `stages:` first, then every stage a job names that the list leaves out, in
+ * first use. With neither, GitLab's defaults. `.pre` and `.post` always
+ * bracket the list.
+ */
+function stageOrder(pipelines, jobs) {
+    const stages = new Set();
+    for (const p of pipelines)
+        for (const s of asList(p.stages))
+            if (typeof s === "string")
+                stages.add(s);
+    for (const j of jobs)
+        if (typeof j.props.stage === "string")
+            stages.add(j.props.stage);
+    const list = stages.size > 0 ? [...stages] : DEFAULT_STAGES;
+    return [".pre", ...list.filter((s) => s !== ".pre" && s !== ".post"), ".post"];
+}
+/** A file an `include:` or `trigger: { include }` entry names, as written. */
+function includeTarget(entry) {
+    if (typeof entry === "string")
+        return entry;
+    const p = propsOf(entry);
+    if (!p)
+        return undefined;
+    for (const key of ["local", "remote", "template", "component", "artifact"]) {
+        if (typeof p[key] === "string")
+            return p[key];
+    }
+    if (typeof p.project === "string") {
+        const files = asList(p.file).filter((f) => typeof f === "string");
+        const ref = typeof p.ref === "string" ? `@${p.ref}` : "";
+        return `${p.project}${ref}:${files.join(",")}`;
+    }
+    return undefined;
+}
+/** The graph edges and pipeline membership a GitLab CI project declares. */
+export function gitlabGraphEdges(entities) {
+    const names = new Map();
+    const jobs = [];
+    const pipelineNodes = [];
+    const pipelineEntities = [];
+    for (const [name, entity] of entities) {
+        names.set(entity, name);
+        if (isPropertyDeclarable(entity))
+            continue;
+        const type = entityType(entity);
+        if (type === JOB)
+            jobs.push({ node: name, key: yamlName(name), props: propsOf(entity) ?? {} });
+        else if (type && PIPELINE_LEVEL.has(type)) {
+            pipelineNodes.push(name);
+            if (type === PIPELINE)
+                pipelineEntities.push({ node: name, props: propsOf(entity) ?? {} });
+        }
+    }
+    if (jobs.length === 0 && pipelineEntities.length === 0)
+        return undefined;
+    const byKey = new Map(jobs.map((j) => [j.key, j.node]));
+    const references = [];
+    // A job name as written, or a Job object held directly.
+    const jobKey = (value) => {
+        if (typeof value === "string")
+            return value;
+        const name = names.get(value);
+        return name !== undefined && entityType(value) === JOB ? yamlName(name) : undefined;
+    };
+    // Stage order, for the jobs that say nothing about `needs:`.
+    const stages = stageOrder(pipelineEntities.map((p) => p.props), jobs);
+    const stageOf = (j) => stages.indexOf(typeof j.props.stage === "string" ? j.props.stage : "test");
+    const atStage = new Map();
+    for (const j of jobs) {
+        const s = stageOf(j);
+        if (s < 0)
+            continue;
+        const arr = atStage.get(s) ?? [];
+        arr.push(j);
+        atStage.set(s, arr);
+    }
+    for (const job of jobs) {
+        const from = job.node;
+        if (job.props.needs === undefined) {
+            // Stage order: wait for every job in the nearest earlier stage that has
+            // any. Those jobs wait for the stage before them in turn, unless one of
+            // them uses `needs:` and starts early, in which case this job also
+            // waits for the stage before, and so on back.
+            for (let s = stageOf(job) - 1; s >= 0; s--) {
+                const earlier = atStage.get(s);
+                if (!earlier)
+                    continue;
+                for (const e of earlier)
+                    references.push({ from, to: e.node, kind: "needs", viaAttr: "stage" });
+                if (earlier.every((e) => e.props.needs === undefined))
+                    break;
+            }
+        }
+        for (const need of asList(job.props.needs)) {
+            const key = jobKey(need);
+            if (key !== undefined) {
+                const to = byKey.get(key);
+                references.push(to ? { from, to, kind: "needs", viaAttr: "needs" } : { from, to: key, kind: "needs", viaAttr: "needs", dangling: true });
+                continue;
+            }
+            const p = propsOf(need);
+            if (!p || typeof p.job !== "string")
+                continue;
+            if (typeof p.project === "string") {
+                const ref = typeof p.ref === "string" ? `@${p.ref}` : "";
+                references.push({ from, to: `${p.project}${ref}:${p.job}`, kind: "needs", viaAttr: "needs.project", crossPipeline: true, dangling: true });
+            }
+            else if (typeof p.pipeline === "string") {
+                references.push({ from, to: `${p.pipeline}:${p.job}`, kind: "needs", viaAttr: "needs.pipeline", crossPipeline: true, dangling: true });
+            }
+            else {
+                const to = byKey.get(p.job);
+                references.push(to ? { from, to, kind: "needs", viaAttr: "needs" } : { from, to: p.job, kind: "needs", viaAttr: "needs", dangling: true });
+            }
+        }
+        for (const parent of asList(job.props.extends)) {
+            const key = jobKey(parent);
+            if (key === undefined)
+                continue;
+            const to = byKey.get(key);
+            references.push(to ? { from, to, kind: "extends", viaAttr: "extends" } : { from, to: key, kind: "extends", viaAttr: "extends", dangling: true });
+        }
+        const trigger = job.props.trigger;
+        if (typeof trigger === "string") {
+            references.push({ from, to: trigger, kind: "triggers", viaAttr: "trigger", crossPipeline: true, dangling: true });
+        }
+        else {
+            const t = propsOf(trigger);
+            if (t && typeof t.project === "string") {
+                const branch = typeof t.branch === "string" ? `@${t.branch}` : "";
+                references.push({ from, to: `${t.project}${branch}`, kind: "triggers", viaAttr: "trigger.project", crossPipeline: true, dangling: true });
+            }
+            for (const entry of asList(t?.include)) {
+                const file = includeTarget(entry);
+                if (file)
+                    references.push({ from, to: file, kind: "triggers", viaAttr: "trigger.include", crossPipeline: true, dangling: true });
+            }
+        }
+    }
+    for (const p of pipelineEntities) {
+        for (const entry of asList(p.props.include)) {
+            const file = includeTarget(entry);
+            if (file)
+                references.push({ from: p.node, to: file, kind: "includes", viaAttr: "include", crossPipeline: true, dangling: true });
+        }
+    }
+    // One project, one `.gitlab-ci.yml`: every job and pipeline-level entity is in it.
+    const members = [...pipelineNodes, ...jobs.map((j) => j.node)].sort();
+    return { references, pipelines: { ".gitlab-ci.yml": members } };
+}

package/dist/import/generator.js

@@ -0,0 +1,196 @@
+/**
+ * TypeScript code generator for GitLab CI import.
+ *
+ * Converts a TemplateIR (from parsed .gitlab-ci.yml) into TypeScript
+ * source code using the @intentius/chant-lexicon-gitlab constructors.
+ */
+/**
+ * Map GitLab CI entity types to their constructor names.
+ */
+const TYPE_TO_CLASS = {
+    "GitLab::CI::Job": "Job",
+    "GitLab::CI::Default": "Default",
+    "GitLab::CI::Workflow": "Workflow",
+    "GitLab::CI::Pipeline": "Pipeline",
+};
+/**
+ * Composite IR types emit as `FunctionName({...})` factory calls rather
+ * than `new ClassName({...})` constructors. The `chant migrate --use-
+ * composites` rewriter rewrites recognised IR shapes into these sentinel
+ * types (see `lexicons/gitlab/src/migrate/from-github/composites/`).
+ */
+const COMPOSITE_TYPE_TO_FN = {
+    "GitLab::Composite::NodePipeline": "NodePipeline",
+    "GitLab::Composite::NodeCI": "NodeCI",
+};
+/**
+ * Properties that reference known property entities.
+ */
+const PROPERTY_CONSTRUCTORS = {
+    artifacts: "Artifacts",
+    cache: "Cache",
+    image: "Image",
+    retry: "Retry",
+    allow_failure: "AllowFailure",
+    parallel: "Parallel",
+    environment: "Environment",
+    trigger: "Trigger",
+    auto_cancel: "AutoCancel",
+    inherit: "Inherit",
+};
+/** An object key as TypeScript accepts it: bare when it is an identifier, quoted otherwise. */
+const tsKey = (key) => (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key));
+/**
+ * Generate TypeScript source code from a GitLab CI IR.
+ */
+export class GitLabGenerator {
+    generate(ir) {
+        const lines = [];
+        // Collect which constructors are needed
+        const usedConstructors = new Set();
+        for (const resource of ir.resources) {
+            const cls = TYPE_TO_CLASS[resource.type];
+            if (cls)
+                usedConstructors.add(cls);
+            const fn = COMPOSITE_TYPE_TO_FN[resource.type];
+            if (fn)
+                usedConstructors.add(fn);
+            // Check properties for nested constructors
+            this.collectNestedConstructors(resource.properties, usedConstructors);
+        }
+        // Import statement
+        const imports = [...usedConstructors].sort().join(", ");
+        lines.push(`import { ${imports} } from "@intentius/chant-lexicon-gitlab";`);
+        lines.push("");
+        // A Pipeline resource declares the stages and includes (#3742); without
+        // one, the metadata is written as comments.
+        const hasPipeline = ir.resources.some((r) => r.type === "GitLab::CI::Pipeline");
+        // Emit stages if present in metadata
+        if (!hasPipeline && ir.metadata?.stages && Array.isArray(ir.metadata.stages)) {
+            lines.push(`// Pipeline stages: ${ir.metadata.stages.join(", ")}`);
+            lines.push("");
+        }
+        // Emit includes as comments
+        if (!hasPipeline && ir.metadata?.include) {
+            lines.push("// Imported includes (not converted):");
+            const includes = Array.isArray(ir.metadata.include) ? ir.metadata.include : [ir.metadata.include];
+            for (const inc of includes) {
+                if (typeof inc === "string") {
+                    lines.push(`//   - ${inc}`);
+                }
+                else if (typeof inc === "object" && inc !== null) {
+                    lines.push(`//   - ${JSON.stringify(inc)}`);
+                }
+            }
+            lines.push("");
+        }
+        // Emit resources
+        for (const resource of ir.resources) {
+            const cls = TYPE_TO_CLASS[resource.type];
+            const fn = COMPOSITE_TYPE_TO_FN[resource.type];
+            if (!cls && !fn)
+                continue;
+            const varName = resource.logicalId;
+            const propsStr = this.emitProps(resource.properties, 1);
+            if (fn) {
+                lines.push(`export const ${varName} = ${fn}(${propsStr});`);
+            }
+            else {
+                lines.push(`export const ${varName} = new ${cls}(${propsStr});`);
+            }
+            lines.push("");
+        }
+        return [{ path: "main.ts", content: lines.join("\n") }];
+    }
+    collectNestedConstructors(props, used) {
+        for (const [key, value] of Object.entries(props)) {
+            const constructor = PROPERTY_CONSTRUCTORS[key];
+            if (constructor && typeof value === "object" && value !== null && !Array.isArray(value)) {
+                used.add(constructor);
+            }
+            if (key === "rules" && Array.isArray(value)) {
+                used.add("Rule");
+            }
+            if (key === "include" && (Array.isArray(value) ? value : [value]).some((i) => typeof i === "object" && i !== null)) {
+                used.add("Include");
+            }
+        }
+    }
+    emitProps(props, depth) {
+        const indent = "  ".repeat(depth);
+        const innerIndent = "  ".repeat(depth + 1);
+        const entries = [];
+        for (const [key, value] of Object.entries(props)) {
+            if (value === undefined || value === null)
+                continue;
+            const emitted = this.emitValue(key, value, depth + 1);
+            entries.push(`${innerIndent}${tsKey(key)}: ${emitted},`);
+        }
+        if (entries.length === 0)
+            return "{}";
+        return `{\n${entries.join("\n")}\n${indent}}`;
+    }
+    emitValue(key, value, depth) {
+        if (value === null || value === undefined)
+            return "undefined";
+        // Check if this key maps to a property constructor
+        const constructor = PROPERTY_CONSTRUCTORS[key];
+        if (constructor && typeof value === "object" && !Array.isArray(value)) {
+            const propsStr = this.emitProps(value, depth);
+            return `new ${constructor}(${propsStr})`;
+        }
+        // A Pipeline's include: each object is an Include, a string stays a string.
+        if (key === "include") {
+            const item = (i, d) => typeof i === "object" && i !== null && !Array.isArray(i) ? `new Include(${this.emitProps(i, d)})` : this.emitLiteral(i, d);
+            if (!Array.isArray(value))
+                return item(value, depth);
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            return `[\n${value.map((i) => `${innerIndent}${item(i, depth + 1)},`).join("\n")}\n${indent}]`;
+        }
+        // Rules array — wrap each item in Rule constructor
+        if (key === "rules" && Array.isArray(value)) {
+            const items = value.map((item) => {
+                if (typeof item === "object" && item !== null) {
+                    const propsStr = this.emitProps(item, depth + 1);
+                    return `new Rule(${propsStr})`;
+                }
+                return JSON.stringify(item);
+            });
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+        }
+        return this.emitLiteral(value, depth);
+    }
+    emitLiteral(value, depth) {
+        if (value === null || value === undefined)
+            return "undefined";
+        if (typeof value === "string")
+            return JSON.stringify(value);
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return "[]";
+            const items = value.map((item) => this.emitLiteral(item, depth + 1));
+            // Short arrays on one line
+            const oneLine = `[${items.join(", ")}]`;
+            if (oneLine.length < 80)
+                return oneLine;
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+        }
+        if (typeof value === "object") {
+            const entries = Object.entries(value);
+            if (entries.length === 0)
+                return "{}";
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            const items = entries.map(([k, v]) => `${innerIndent}${tsKey(k)}: ${this.emitLiteral(v, depth + 1)},`);
+            return `{\n${items.join("\n")}\n${indent}}`;
+        }
+        return String(value);
+    }
+}

package/dist/import/parser.js

@@ -0,0 +1,111 @@
+/**
+ * GitLab CI YAML parser for `chant import`.
+ *
+ * Parses an existing .gitlab-ci.yml file into the core TemplateIR format,
+ * mapping GitLab CI constructs to resources and property types.
+ */
+import { parseYAML } from "@intentius/chant/yaml";
+/**
+ * Reserved top-level keys in .gitlab-ci.yml that are NOT job definitions.
+ */
+/**
+ * Convert snake_case to camelCase — used only for TS variable names (logicalId),
+ * NOT for spec property names.
+ */
+function snakeToCamelCase(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+const RESERVED_KEYS = new Set([
+    "stages",
+    "variables",
+    "default",
+    "workflow",
+    "include",
+    "image",
+    "services",
+    "before_script",
+    "after_script",
+    "cache",
+    "pages",
+]);
+/**
+ * GitLab CI YAML parser implementation.
+ */
+export class GitLabParser {
+    parse(content) {
+        const doc = parseYAML(content);
+        const resources = [];
+        // Extract default
+        if (doc.default && typeof doc.default === "object") {
+            resources.push({
+                logicalId: "defaults",
+                type: "GitLab::CI::Default",
+                properties: doc.default,
+            });
+        }
+        // Extract workflow
+        if (doc.workflow && typeof doc.workflow === "object") {
+            resources.push({
+                logicalId: "workflow",
+                type: "GitLab::CI::Workflow",
+                properties: doc.workflow,
+            });
+        }
+        // Extract jobs — any top-level key not in RESERVED_KEYS
+        for (const [key, value] of Object.entries(doc)) {
+            if (RESERVED_KEYS.has(key))
+                continue;
+            if (typeof value !== "object" || value === null)
+                continue;
+            // Check if it looks like a job (has script, stage, trigger, extends, etc.)
+            const obj = value;
+            if (obj.script !== undefined ||
+                obj.stage !== undefined ||
+                obj.trigger !== undefined ||
+                obj.extends !== undefined ||
+                obj.rules !== undefined ||
+                obj.needs !== undefined) {
+                resources.push({
+                    logicalId: snakeToCamelCase(key.replace(/-/g, "_")),
+                    type: "GitLab::CI::Job",
+                    properties: obj,
+                    metadata: {
+                        originalName: key,
+                        stage: typeof obj.stage === "string" ? obj.stage : undefined,
+                    },
+                });
+            }
+        }
+        // The file's top-level include, stages and variables are a Pipeline
+        // (#3742), so a rebuild writes them back: stages as written, a stage no
+        // job uses and the declared order included.
+        const pipeline = {};
+        if (doc.include !== undefined && doc.include !== null)
+            pipeline.include = doc.include;
+        if (Array.isArray(doc.stages))
+            pipeline.stages = doc.stages;
+        if (doc.variables && typeof doc.variables === "object")
+            pipeline.variables = doc.variables;
+        if (Object.keys(pipeline).length > 0) {
+            const taken = new Set(resources.map((r) => r.logicalId));
+            resources.unshift({
+                logicalId: taken.has("pipeline") ? "pipelineConfig" : "pipeline",
+                type: "GitLab::CI::Pipeline",
+                properties: pipeline,
+            });
+        }
+        // Also kept as metadata, for callers that read the IR without the Pipeline.
+        const metadata = {};
+        if (doc.stages)
+            metadata.stages = doc.stages;
+        if (doc.include)
+            metadata.include = doc.include;
+        if (doc.variables)
+            metadata.variables = doc.variables;
+        return {
+            resources,
+            parameters: [], // GitLab CI doesn't have parameters like CFN
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,26 @@
+// Serializer
+export { gitlabSerializer } from "./serializer.js";
+export { gitlabGraphEdges } from "./graph-edges.js";
+// Plugin
+export { gitlabPlugin } from "./plugin.js";
+// Typed Op step-builder wrapper (chant #1288 Stage 2) — gitlabPipeline with
+// authoring-time types derived from this lexicon's own GitlabPipelineArgs
+// (see lexicons/k8s/src/op/builders.ts's module doc for why this lives here
+// rather than in core). Opt-in: `@intentius/chant/op`'s same-named export is
+// core's original untyped builder, unchanged, for cloud-agnostic authoring.
+export { gitlabPipeline } from "./op/builders.js";
+// Intrinsics
+export { reference, ReferenceIntrinsic } from "./intrinsics.js";
+// CI/CD Variables
+export { CI } from "./variables.js";
+// Generated entities — export everything from generated index
+// After running `chant generate`, this re-exports all CI entity classes
+export * from "./generated/index.js";
+// Composites
+export { DockerBuild, NodePipeline, BunPipeline, PnpmPipeline, PythonPipeline, ReviewApp, MrPlanReport } from "./composites/index.js";
+// Spec utilities (for tooling)
+export { fetchCISchema, fetchSchemas, GITLAB_SCHEMA_VERSION } from "./codegen/fetch.js";
+export { parseCISchema, gitlabShortName, gitlabServiceName } from "./codegen/parse.js";
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate.js";
+export { packageLexicon } from "./codegen/package.js";

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "63c7379cd49d05603a54529fa139575f02ceb7e3241a931bb15b9e35c8ffecb7",
+    "manifest.json": "be91342ce1ba95512e87deebcd929d0afcadc076160491773630b2e7b62097de",
     "meta.json": "db082fbf90c5941c498b2bee0f106103449c1a4c257716ca2220f0dd490450b2",
     "types/index.d.ts": "a048a66ebe20da0cb5fc889054cac69044d9bf882e2c56b5c5bf113d1f3ba57c",
     "rules/artifact-no-expiry.ts": "0ca5bb972d4a542126e8a0229d43b55658394cb7dd9b9923b2c590bec1c2ad7d",
@@ -11,7 +11,7 @@
     "rules/missing-stage.ts": "1270d4e00e270e60f948880ade373a91b02e33a26b9c9552a874b772998e3640",
     "rules/wgl010.ts": "e9a14d5f9e4c49b1524ba5ee3746be739603125ec3c2dc4eb4b7c0bfc32581b0",
     "rules/wgl011.ts": "2fbb164669204ac8c3662b9c1ae156b59589913e59dd596fb38f289a0f218aaf",
-    "rules/wgl012.ts": "ec4bd3fe93d30824c74223bb4e5929e493a06561a7bd3265b68dc1ba5d734da4",
+    "rules/wgl012.ts": "789d1c6932e532ee5eb9eddd4191c49cc9d4094425339f93a36c960e82e90273",
     "rules/wgl013.ts": "afde3fb528dc9d8a245ec35f0da2ffb8460224956eb986412bef7e9e3891e378",
     "rules/wgl014.ts": "acbbeec029ec7f23e74cebcd4965dae12ea991a5a29e754040edd4a0c3fd8f0c",
     "rules/wgl015.ts": "040da46b2fe8126ba18c8d44957b402a710537eca0dc05d885498022ccec006a",
@@ -55,5 +55,5 @@
     "skills/chant-gitlab-migrate.md": "4853d04980560b379e5b0f7267dcb0a1e5d5879cb9e9931681ce76b2a5fe69d8",
     "skills/chant-gitlab-patterns.md": "6d9a44e9e8de4c3820be9d65381b0d2ede4cb3626aaaf0011e21838a9fbf556e"
   },
-  "composite": "fa8097c773e5d6b8d94a7ab984b8e02f66fd29ec7bc817974632acf927b7103f"
+  "composite": "b0fefd5cf9a9c881b5a84df608913c43c5995c4b319d2ee76a89555a635de276"
 }

package/dist/intrinsics.js

@@ -0,0 +1,33 @@
+/**
+ * GitLab CI/CD intrinsic functions.
+ *
+ * GitLab CI has a single intrinsic: the !reference tag.
+ * CI/CD variables ($CI_*) are just strings, not intrinsic functions.
+ */
+import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
+/**
+ * !reference tag intrinsic.
+ * References another job's properties: !reference [job_name, key]
+ */
+export class ReferenceIntrinsic {
+    constructor(...path) {
+        this[INTRINSIC_MARKER] = true;
+        this.path = path;
+    }
+    toJSON() {
+        return this.path;
+    }
+    /**
+     * YAML representation uses the !reference tag.
+     */
+    toYAML() {
+        return { tag: "!reference", value: this.path };
+    }
+}
+/**
+ * Create a !reference intrinsic.
+ * Usage: reference("job_name", "script") → !reference [job_name, script]
+ */
+export function reference(...path) {
+    return new ReferenceIntrinsic(...path);
+}