@intentius/chant-lexicon-gitlab 0.124.30 → 0.124.32

package/dist/codegen/docs-cli.js

@@ -0,0 +1,2 @@
+import { generateDocs } from "./docs.js";
+await generateDocs({ verbose: true });

package/dist/codegen/docs.js

@@ -0,0 +1,157 @@
+/**
+ * Documentation generation for GitLab CI lexicon.
+ *
+ * Generates Starlight MDX pages for CI entities using the core docs pipeline.
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+/**
+ * Extract service name from GitLab CI type: "GitLab::CI::Job" → "CI"
+ */
+function serviceFromType(resourceType) {
+    const parts = resourceType.split("::");
+    return parts.length >= 2 ? parts[1] : "CI";
+}
+const overview = `The **GitLab CI/CD** lexicon provides typed constructors for GitLab CI pipeline
+configuration. It covers jobs, workflow settings, artifacts, caching, images,
+rules, environments, triggers, and more.
+
+Install it with:
+
+\`\`\`bash
+npm install --save-dev @intentius/chant-lexicon-gitlab
+\`\`\`
+
+## Quick Start
+
+{{file:docs-snippets/src/quickstart.ts}}
+
+The lexicon provides **4 resources** (Job, Workflow, Default, Pipeline), **16 property types** (Image, Cache, Artifacts, Rule, Environment, Trigger, Need, Service, and more), the \`CI\` pseudo-parameter object for predefined variables, and the \`reference()\` intrinsic for YAML \`!reference\` tags. It also ships **4 lint rules** + **39 post-synth checks** (including a CI/CD supply-chain security pass, WGL029–048) and a [\`chant migrate\`](./migration) source for translating GitHub Actions workflows.
+`;
+const outputFormat = `The GitLab lexicon serializes resources into **\`.gitlab-ci.yml\` YAML**. Keys are
+converted to \`snake_case\` and jobs use kebab-case names. Stages are collected
+from the job definitions, after any a \`Pipeline\` lists.
+
+## Building
+
+Run \`chant build\` to produce a \`.gitlab-ci.yml\` from your declarations:
+
+\`\`\`bash
+chant build
+# Writes dist/.gitlab-ci.yml
+\`\`\`
+
+The generated file includes:
+
+- a header comment, \`include:\` and \`variables:\`, if a \`Pipeline\` resource is exported
+- \`stages:\` list: a \`Pipeline\`'s \`stages\` in its order, then every other stage a job's \`stage\` names, in first use
+- \`default:\` section — if a \`Default\` resource is exported
+- \`workflow:\` section — if a \`Workflow\` resource is exported
+- Job definitions with \`snake_case\` keys and \`kebab-case\` job names
+
+## Key conversions
+
+| Chant (TypeScript) | YAML output | Rule |
+|--------------------|-------------|------|
+| \`export const buildApp = new Job({...})\` | \`build-app:\` | Export name → kebab-case job key |
+| \`expire_in: "1 week"\` | \`expire_in: 1 week\` | Property names use spec-native snake_case |
+| \`new Image({ name: "node:20" })\` | \`image: node:20\` | Single-property objects are collapsed |
+
+## Top-level keys and comments
+
+A \`Pipeline\` resource holds the top-level keys that are not a job, \`default\` or \`workflow\`: \`include\`, \`stages\` and \`variables\`. Its \`stages\` can name a stage no declared job uses, such as one an included file's jobs run in, and set the order; a stage a job names that the list leaves out is still added after it, so the file stays valid. \`variables\` holds pipeline-wide variables, which \`Default\` cannot, since GitLab's \`default:\` has none.
+
+\`Pipeline\` and \`Job\` also take a \`comment\`, written as \`#\` lines: the pipeline's at the top of the file, a job's above its key.
+
+\`\`\`typescript
+export const pipeline = new Pipeline({
+  comment: "Protect the writer's variables and scope them to their environment.",
+  include: [{ local: ".gitlab/watch.yml" }],
+  stages: ["review", "apply", "ops"],
+  variables: { GIT_DEPTH: "0" },
+});
+
+export const lint = new Job({ comment: "Blocks the merge.", stage: "review", image: "node:22", script: ["npm run lint"] });
+\`\`\`
+
+\`\`\`yaml
+# Protect the writer's variables and scope them to their environment.
+
+include:
+  - local: .gitlab/watch.yml
+
+stages:
+  - review
+  - apply
+  - ops
+
+variables:
+  GIT_DEPTH: '0'
+
+# Blocks the merge.
+lint:
+  stage: review
+  image: node:22
+  script:
+    - npm run lint
+\`\`\`
+
+## Validating locally
+
+The output is standard GitLab CI YAML. Validate with the GitLab CI Lint API or locally:
+
+\`\`\`bash
+# Using the GitLab API
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+  --data-urlencode "content=$(cat dist/.gitlab-ci.yml)" \\
+  "https://gitlab.com/api/v4/ci/lint"
+
+# Using the glab CLI
+glab ci lint dist/.gitlab-ci.yml
+\`\`\`
+
+## Compatibility
+
+The output is compatible with:
+- GitLab CI/CD (any recent GitLab version)
+- GitLab CI Lint API
+- \`glab\` CLI tool
+- Any tool that processes \`.gitlab-ci.yml\` files`;
+/**
+ * Generate documentation for the GitLab CI lexicon.
+ */
+export async function generateDocs(opts) {
+    const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    const config = {
+        name: "gitlab",
+        displayName: "GitLab CI/CD",
+        description: "Typed constructors for GitLab CI/CD pipeline configuration",
+        distDir: join(pkgDir, "dist"),
+        outDir: join(pkgDir, "docs"),
+        overview,
+        outputFormat,
+        serviceFromType,
+        // "intrinsics" is no longer suppressed (chant #1067) — the reference
+        // table at that slug is now generated from the plugin's own
+        // `intrinsics()` registration (docsPipeline's generateIntrinsics, same
+        // mechanism azure/helm already use), so its "Folds?" column can never
+        // drift from the registration the way #1062's foldability matrix
+        // depends on. The hand-written `reference()` usage guide lives in a
+        // separate "intrinsics-guide" page under docs/pages/ — content unchanged,
+        // just no longer sharing a slug with generated data.
+        examplesDir: join(pkgDir, "examples"),
+        extraSections: [
+            {
+                title: "Migrating from GitHub Actions",
+                content: `\`chant migrate\` translates GitHub Actions workflows into GitLab CI/CD pipelines or typed chant source. See [Migration](./migration) for the full CLI surface, supported translations, and limitations.`,
+            },
+        ],
+        basePath: "/chant/lexicons/gitlab/",
+    };
+    const result = await docsPipeline(config);
+    writeDocsSite(config, result);
+    if (opts?.verbose) {
+        console.error(`Generated docs: ${result.stats.resources} resources, ${result.stats.properties} properties, ${result.stats.services} services, ${result.stats.rules} rules`);
+    }
+}

package/dist/codegen/fetch.js

@@ -0,0 +1,93 @@
+/**
+ * GitLab CI schema fetching — downloads the CI JSON Schema
+ * and caches it locally.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { readFileSync, writeFileSync } from "fs";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { fetchWithCache, clearCacheFile } from "@intentius/chant/codegen/fetch";
+/**
+ * Pinned schema version — a GitLab release tag that produces a known-good
+ * schema. Override at runtime with `--schema-version <tag>` in generate-cli
+ * or by setting `schemaVersion` in the generate options.
+ *
+ * Using a tag (e.g. "v17.8.1-ee") rather than `master` ensures reproducible
+ * codegen across environments and CI runs.
+ */
+export const GITLAB_SCHEMA_VERSION = "v17.8.1-ee";
+/**
+ * Build the schema URL for a given version ref.
+ */
+function schemaUrl(version) {
+    return `https://gitlab.com/gitlab-org/gitlab/-/raw/${version}/app/assets/javascripts/editor/schema/ci.json`;
+}
+/**
+ * Get the cache file path for the CI schema.
+ */
+export function getCachePath() {
+    return join(homedir(), ".chant", "gitlab-ci-schema.json");
+}
+/**
+ * Path to the vendored CI schema committed in this lexicon. Reading it offline
+ * is the default so `generate` never depends on gitlab.com — which aggressively
+ * 429-rate-limits the raw endpoint and chronically flaked CI (#574). The
+ * `GITLAB_SCHEMA_VERSION` pin already makes the fetch deterministic, so a
+ * committed copy is equivalent and network-free.
+ */
+export function getVendoredSchemaPath() {
+    return join(moduleSourceDir(import.meta.url), "vendored", "gitlab-ci-schema.json");
+}
+/**
+ * Fetch the GitLab CI JSON Schema, returning the raw JSON buffer.
+ *
+ * Default (pinned version, no force): read the vendored, committed schema —
+ * offline, deterministic, no gitlab.com 429s (#574). Pass `force` or a custom
+ * `version` to fetch live — used to verify against upstream or to refresh the
+ * vendored copy when bumping the pin (see {@link refreshVendoredSchema}).
+ *
+ * @param force  Bypass the vendored copy and download fresh.
+ * @param version  GitLab ref (tag, branch, or SHA) to fetch from.
+ *                 Defaults to {@link GITLAB_SCHEMA_VERSION}.
+ */
+export async function fetchCISchema(force, version) {
+    const ref = version ?? GITLAB_SCHEMA_VERSION;
+    if (!force && ref === GITLAB_SCHEMA_VERSION) {
+        return readFileSync(getVendoredSchemaPath());
+    }
+    return fetchWithCache({
+        url: schemaUrl(ref),
+        cacheFile: getCachePath(),
+    }, force);
+}
+/**
+ * Refresh the vendored schema from upstream. Call this when bumping
+ * `GITLAB_SCHEMA_VERSION` so the committed copy tracks the new pin — the
+ * lexicon-upgrade pipeline (#523) runs it as part of a gitlab pin bump.
+ * Fetches the given version live and overwrites the vendored file.
+ */
+export async function refreshVendoredSchema(version) {
+    const ref = version ?? GITLAB_SCHEMA_VERSION;
+    const data = await fetchWithCache({ url: schemaUrl(ref), cacheFile: getCachePath() }, true);
+    writeFileSync(getVendoredSchemaPath(), data);
+}
+/**
+ * Fetch the CI schema and return it as a Map<typeName, Buffer>
+ * compatible with the generatePipeline fetchSchemas callback.
+ *
+ * The CI schema is a single document, so we return a single entry
+ * keyed by "GitLab::CI::Pipeline" — the parse step will split it
+ * into multiple entities.
+ */
+export async function fetchSchemas(force, version) {
+    const data = await fetchCISchema(force, version);
+    const schemas = new Map();
+    schemas.set("GitLab::CI::Pipeline", data);
+    return schemas;
+}
+/**
+ * Clear the cached schema file.
+ */
+export function clearCache() {
+    clearCacheFile(getCachePath());
+}

package/dist/codegen/generate-cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for GitLab CI lexicon generation.
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate.js";
+import { GITLAB_SCHEMA_VERSION } from "./fetch.js";
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+async function main() {
+    const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+    const force = process.argv.includes("--force") || process.argv.includes("-f");
+    // Parse --schema-version <ref>
+    const versionIdx = process.argv.indexOf("--schema-version");
+    const schemaVersion = versionIdx !== -1 ? process.argv[versionIdx + 1] : undefined;
+    console.error(`Generating GitLab CI lexicon (schema: ${schemaVersion ?? GITLAB_SCHEMA_VERSION})...`);
+    const result = await generate({ verbose, force, schemaVersion });
+    writeGeneratedFiles(result, pkgDir);
+    console.error(`Generated ${result.resources} entities, ${result.properties} property types, ${result.enums} enums`);
+    if (result.warnings.length > 0) {
+        console.error(`${result.warnings.length} warnings:`);
+        for (const w of result.warnings) {
+            console.error(`  ${w.file}: ${w.error}`);
+        }
+    }
+}
+main().catch((err) => {
+    console.error("Generation failed:", err);
+    process.exit(1);
+});

package/dist/codegen/generate-lexicon.js

@@ -0,0 +1,36 @@
+/**
+ * Lexicon JSON generator — produces lexicon-gitlab.json with metadata
+ * for all GitLab CI entities.
+ */
+import { gitlabShortName } from "./parse.js";
+import { buildRegistry, serializeRegistry, } from "@intentius/chant/codegen/generate-registry";
+/**
+ * Generate the lexicon-gitlab.json content.
+ */
+export function generateLexiconJSON(results, naming) {
+    const registryResources = results.map((r) => ({
+        typeName: r.resource.typeName,
+        attributes: r.resource.attributes,
+        properties: r.resource.properties,
+        propertyTypes: r.propertyTypes.map((pt) => ({ name: pt.name, specType: pt.defType })),
+    }));
+    const entries = buildRegistry(registryResources, naming, {
+        shortName: gitlabShortName,
+        buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+            const r = results.find((res) => res.resource.typeName === resource.typeName);
+            return {
+                resourceType: resource.typeName,
+                kind: (r?.isProperty ? "property" : "resource"),
+                lexicon: "gitlab",
+                ...(r?.resource.deprecatedProperties?.length && { deprecatedProperties: r.resource.deprecatedProperties }),
+                ...(propConstraints && Object.keys(propConstraints).length > 0 && { constraints: propConstraints }),
+            };
+        },
+        buildPropertyEntry: (resourceType, propertyType) => ({
+            resourceType: `${resourceType}.${propertyType}`,
+            kind: "property",
+            lexicon: "gitlab",
+        }),
+    });
+    return serializeRegistry(entries);
+}

package/dist/codegen/generate-typescript.js

@@ -0,0 +1,105 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with all
+ * GitLab CI entity classes.
+ */
+import { gitlabShortName } from "./parse.js";
+import { propertyTypeName, extractDefName } from "./naming.js";
+import { writeResourceClass, writeEnumType, } from "@intentius/chant/codegen/generate-typescript";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(results, naming) {
+    const lines = [];
+    lines.push("// Code generated by chant gitlab generate. DO NOT EDIT.");
+    const resources = [];
+    const enums = [];
+    for (const r of results) {
+        const typeName = r.resource.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        const shortName = gitlabShortName(typeName);
+        const remap = new Map();
+        for (const pt of r.propertyTypes) {
+            const defName = extractDefName(pt.name, shortName);
+            remap.set(pt.name, propertyTypeName(tsName, defName));
+        }
+        for (const e of r.enums) {
+            const defName = extractDefName(e.name, shortName);
+            remap.set(e.name, propertyTypeName(tsName, defName));
+        }
+        const dtsProps = r.resource.properties.map((p) => ({
+            name: p.name,
+            type: p.tsType,
+            required: p.required,
+            description: p.description,
+        }));
+        const dtsAttrs = r.resource.attributes.map((a) => ({
+            name: a.name,
+            type: a.tsType,
+        }));
+        resources.push({ tsName, properties: dtsProps, attributes: dtsAttrs, remap });
+        for (const alias of naming.aliases(typeName)) {
+            resources.push({ tsName: alias, properties: dtsProps, attributes: dtsAttrs, remap });
+        }
+        for (const e of r.enums) {
+            const defName = extractDefName(e.name, shortName);
+            const eName = propertyTypeName(tsName, defName);
+            enums.push({ tsName: eName, values: e.values });
+        }
+    }
+    // Sort alphabetically
+    resources.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    enums.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    // Resource classes (all CI entities use writeResourceClass since they're
+    // all top-level — the "property" distinction is only in the registry)
+    lines.push("");
+    lines.push("// --- CI Entity classes ---");
+    for (const re of resources) {
+        writeResourceClass(lines, re.tsName, re.properties, re.attributes, re.remap);
+    }
+    // Enum types
+    if (enums.length > 0) {
+        lines.push("");
+        lines.push("// --- Enum types ---");
+        for (const ee of enums) {
+            writeEnumType(lines, ee.tsName, ee.values);
+        }
+    }
+    // Static content
+    lines.push("");
+    lines.push(staticTypeScript());
+    lines.push("");
+    return lines.join("\n");
+}
+function staticTypeScript() {
+    const lines = [];
+    lines.push("// --- CI/CD Variables ---");
+    lines.push("");
+    lines.push("export declare const CI: {");
+    const ciVars = [
+        "CommitBranch",
+        "CommitRef",
+        "CommitSha",
+        "CommitTag",
+        "DefaultBranch",
+        "Environment",
+        "JobId",
+        "JobName",
+        "JobStage",
+        "MergeRequestIid",
+        "PipelineId",
+        "PipelineSource",
+        "ProjectDir",
+        "ProjectId",
+        "ProjectName",
+        "ProjectPath",
+        "Registry",
+        "RegistryImage",
+    ];
+    for (const v of ciVars) {
+        lines.push(`  readonly ${v}: string;`);
+    }
+    lines.push("};");
+    return lines.join("\n");
+}

package/dist/codegen/generate.js

@@ -0,0 +1,125 @@
+/**
+ * GitLab CI generation pipeline — uses core generatePipeline
+ * with GitLab-specific fetch, parse, naming, and generation callbacks.
+ */
+import { generatePipeline, writeGeneratedArtifacts, } from "@intentius/chant/codegen/generate";
+import { fetchSchemas } from "./fetch.js";
+import { parseCISchema } from "./parse.js";
+import { NamingStrategy, propertyTypeName, extractDefName } from "./naming.js";
+import { gitlabShortName } from "./parse.js";
+import { generateLexiconJSON } from "./generate-lexicon.js";
+import { generateTypeScriptDeclarations } from "./generate-typescript.js";
+import { generateRuntimeIndex as coreGenerateRuntimeIndex, } from "@intentius/chant/codegen/generate-runtime-index";
+/**
+ * Run the full GitLab generation pipeline.
+ */
+export async function generate(opts = {}) {
+    // Pipeline state captured in closure — no module-level mutation
+    let pendingResults = [];
+    const config = {
+        fetchSchemas: async (fetchOpts) => {
+            return fetchSchemas(fetchOpts.force, opts.schemaVersion);
+        },
+        parseSchema: (_typeName, data) => {
+            // The CI schema is a single document — parseCISchema returns multiple results.
+            // The pipeline calls this once per schema entry. We return the first result
+            // and use augmentResults to inject the rest.
+            const results = parseCISchema(data);
+            if (results.length === 0)
+                return null;
+            // Return the first result; stash the rest for augmentResults
+            pendingResults = results.slice(1);
+            return results[0];
+        },
+        createNaming: (results) => new NamingStrategy(results),
+        augmentResults: (results, _opts, log) => {
+            // Add the remaining results from the single-schema parse
+            if (pendingResults.length > 0) {
+                results.push(...pendingResults);
+                log(`Added ${pendingResults.length} additional CI entities from single schema`);
+                pendingResults = [];
+            }
+            log(`Total: ${results.length} CI entity schemas`);
+            return { results };
+        },
+        generateRegistry: (results, naming) => {
+            return generateLexiconJSON(results, naming);
+        },
+        generateTypes: (results, naming) => {
+            return generateTypeScriptDeclarations(results, naming);
+        },
+        generateRuntimeIndex: (results, naming) => {
+            return generateRuntimeIndex(results, naming);
+        },
+    };
+    return generatePipeline(config, opts);
+}
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result, baseDir) {
+    writeGeneratedArtifacts({
+        baseDir,
+        files: {
+            "lexicon-gitlab.json": result.lexiconJSON,
+            "index.d.ts": result.typesDTS,
+            "index.ts": result.indexTS,
+            "runtime.ts": `/**\n * Runtime factory constructors — re-exported from core.\n */\nexport { createResource, createProperty } from "@intentius/chant/runtime";\n`,
+        },
+    });
+}
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(results, naming) {
+    const resourceEntries = [];
+    const propertyEntries = [];
+    for (const r of results) {
+        const typeName = r.resource.typeName;
+        const tsName = naming.resolve(typeName);
+        if (!tsName)
+            continue;
+        // CI entities have no read-only attributes
+        const attrs = {};
+        if (r.isProperty) {
+            // Property-kind entities (Artifacts, Cache, Image, etc.)
+            propertyEntries.push({ tsName, resourceType: typeName });
+            for (const alias of naming.aliases(typeName)) {
+                propertyEntries.push({ tsName: alias, resourceType: typeName });
+            }
+        }
+        else {
+            // Resource-kind entities (Job, Default, Workflow)
+            resourceEntries.push({ tsName, resourceType: typeName, attrs });
+            for (const alias of naming.aliases(typeName)) {
+                resourceEntries.push({ tsName: alias, resourceType: typeName, attrs });
+            }
+        }
+        // Property types
+        const shortName = gitlabShortName(typeName);
+        const ptAliases = naming.propertyTypeAliases(typeName);
+        for (const pt of r.propertyTypes) {
+            const defName = extractDefName(pt.name, shortName);
+            const ptName = propertyTypeName(tsName, defName);
+            const ptType = `${typeName}.${pt.defType}`;
+            propertyEntries.push({ tsName: ptName, resourceType: ptType });
+            if (ptAliases) {
+                const aliasName = ptAliases.get(defName);
+                if (aliasName) {
+                    propertyEntries.push({ tsName: aliasName, resourceType: ptType });
+                }
+            }
+        }
+    }
+    return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+        lexiconName: "gitlab",
+        intrinsicReExports: {
+            names: ["reference"],
+            from: "../intrinsics",
+        },
+        pseudoReExports: {
+            names: ["CI"],
+            from: "../variables",
+        },
+    });
+}

package/dist/codegen/naming.js

@@ -0,0 +1,48 @@
+/**
+ * GitLab CI naming strategy — simpler than AWS since CI entities
+ * use a flat GitLab::CI:: namespace with few collisions.
+ */
+import { NamingStrategy as CoreNamingStrategy, } from "@intentius/chant/codegen/naming";
+import { gitlabShortName, gitlabServiceName } from "./parse.js";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+const gitlabNamingConfig = {
+    priorityNames: {
+        "GitLab::CI::Job": "Job",
+        "GitLab::CI::Default": "Default",
+        "GitLab::CI::Workflow": "Workflow",
+        "GitLab::CI::Pipeline": "Pipeline",
+        "GitLab::CI::Artifacts": "Artifacts",
+        "GitLab::CI::Cache": "Cache",
+        "GitLab::CI::Image": "Image",
+        "GitLab::CI::Rule": "Rule",
+        "GitLab::CI::Retry": "Retry",
+        "GitLab::CI::AllowFailure": "AllowFailure",
+        "GitLab::CI::Parallel": "Parallel",
+        "GitLab::CI::Include": "Include",
+        "GitLab::CI::Release": "Release",
+        "GitLab::CI::Environment": "Environment",
+        "GitLab::CI::Trigger": "Trigger",
+        "GitLab::CI::AutoCancel": "AutoCancel",
+        "GitLab::CI::WorkflowRule": "WorkflowRule",
+        "GitLab::CI::Need": "Need",
+        "GitLab::CI::Inherit": "Inherit",
+    },
+    priorityAliases: {},
+    priorityPropertyAliases: {},
+    serviceAbbreviations: {},
+    shortName: gitlabShortName,
+    serviceName: gitlabServiceName,
+};
+/**
+ * GitLab-specific naming strategy.
+ * Extends core NamingStrategy with GitLab naming config.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+    constructor(results) {
+        const inputs = results.map((r) => ({
+            typeName: r.resource.typeName,
+            propertyTypes: r.propertyTypes,
+        }));
+        super(inputs, gitlabNamingConfig);
+    }
+}

package/dist/codegen/package.js

@@ -0,0 +1,41 @@
+/**
+ * GitLab lexicon packaging — delegates to core packagePipeline
+ * with GitLab-specific manifest building and skill collection.
+ */
+import { readFileSync } from "fs";
+import { gitlabPlugin } from "../plugin.js";
+import { join, dirname } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { packagePipeline, collectSkills, } from "@intentius/chant/codegen/package";
+import { generate } from "./generate.js";
+const pkgDir = dirname(moduleSourceDir(import.meta.url));
+/**
+ * Package the GitLab lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts = {}) {
+    const pkgJson = JSON.parse(readFileSync(join(pkgDir, "..", "package.json"), "utf-8"));
+    return packagePipeline({
+        generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+        buildManifest: (_genResult) => {
+            // Derived from the plugin's own registration (chant #1067) — this
+            // used to be a hand-maintained array independent of ../plugin.ts
+            // (despite the comment claiming otherwise), free to drift from the
+            // real registration without anything noticing.
+            const intrinsics = gitlabPlugin.intrinsics?.() ?? [];
+            return {
+                name: "gitlab",
+                version: pkgJson.version ?? "0.0.0",
+                chantVersion: ">=0.1.0",
+                namespace: "GitLab",
+                intrinsics,
+                pseudoParameters: {},
+            };
+        },
+        srcDir: pkgDir,
+        collectSkills: () => {
+            const skillDefs = gitlabPlugin.skills?.() ?? [];
+            return collectSkills(skillDefs);
+        },
+        version: pkgJson.version ?? "0.0.0",
+    }, opts);
+}