@tahminator/pipeline 1.0.78 → 1.0.79-beta.cf2df8b7

package/README.md

@@ -185,7 +185,7 @@ await client.promoteDockerImage({
 
 ### `ProtobufCompilerClient`
 
-Generate protobuf clients with the [Buf CLI](https://buf.build/docs/installation/) and its remote plugins. Java and Rust targets can be published to Artifact Keeper with Maven, Gradle, or Cargo. The client installs Buf globally with npm when necessary.
+Generate protobuf messages and gRPC client/server stubs with the [Buf CLI](https://buf.build/docs/installation/) and local protoc plugins. Java, Rust, and Go targets can be published to Artifact Keeper with Maven/Gradle, Cargo, or Go module uploads. The client checks for required local tools and throws when one is missing.
 
 ```ts
 const protobuf = new ProtobufCompilerClient();
@@ -210,6 +210,54 @@ await protobuf.compile({
 });
 ```
 
+Configure generated-code packages in each `.proto` file, not in `targetLanguages`. The client does not enable Buf managed mode; Buf's generators read these file options directly:
+
+```proto
+option go_package = "example.com/proto/helloworld/v1;helloworldv1";
+option java_package = "org.myorg.helloworld.v1";
+option java_multiple_files = true;
+```
+
+`go_package` is required for Go generation with this client. Java package options are recommended; `java_outer_classname` is optional. Rust generation needs no language-specific file options. CI target options such as Java `groupId`/`artifactId` and Rust `crateName` are publishing metadata, not generated-code package names. Go's former unused `modulePath` option has been removed.
+
+In CI, enable the setup action's protobuf dependency installer so generation uses local tools and does not send source code to BSR remote plugins:
+
+```yaml
+- uses: tahminator/pipeline/actions/setup@<version>
+  with:
+    INSTALL_PROTO_DEPENDENCIES: "true"
+```
+
+Every target enables both message and service generation by default:
+
+| Target                  | Generated service API                                                | Published runtime dependencies                      |
+| ----------------------- | -------------------------------------------------------------------- | --------------------------------------------------- |
+| Java (Maven and Gradle) | `<Service>Grpc.<Service>ImplBase` and client stubs                   | `protobuf-java`, `grpc-protobuf`, `grpc-stub`       |
+| Go                      | `<Service>Server`, `Unimplemented<Service>Server`, `<Service>Client` | Resolved by `go mod tidy` into the generated module |
+| Rust                    | Tonic `<service>_server` traits and `<service>_client` clients       | `prost`, `prost-types`, `tonic`, `tonic-prost`      |
+
+Applications implement the generated service interfaces and supply server startup, endpoints, authentication, and transport configuration. Java applications must add a transport implementation such as `io.grpc:grpc-netty-shaded:1.75.0`; the generated SDK does not choose one. Gradle publishes public runtime types as `api` dependencies so they are visible on consumers' compile classpaths.
+
+Imported schemas are generated alongside the selected input, except standard well-known types, which use the runtime libraries. This produces self-contained schema output rather than relying on separately published schema packages. Go publishing still requires those package paths to share a valid module root.
+
+Rust generation uses local Prost and Tonic protoc plugins, paired with the `0.14` runtime series. `prostVersion` overrides must remain within `0.14`. The published crate preserves proto package hierarchy (for example, `example.v1` becomes `example::v1`) and includes Tonic stubs in the same module as their messages. This replaces the previous flattened Rust module names.
+
+For Go publishing, only the release version is needed:
+
+```ts
+targetLanguages: {
+  [ProtobufTargetLanguage.GO]: {
+    version: "1.0.0",
+  },
+},
+```
+
+The publisher generates `go.mod` using the deepest shared directory of the generated Go packages as the module root. For a single package, that package's import path becomes the module path. It never adds, strips, or rewrites version suffixes. Proto authors own package layout; invalid Go module/version combinations fail. In particular, Go does not allow a module path ending in `/v1`. Adding packages outside the existing shared directory changes the inferred module root, so keep the package layout stable across releases.
+
+Go publishing requires `go` and `zip` on PATH. It stages generated packages without changing the original output, runs `go mod init` and `go mod tidy` to generate dependency metadata, and uploads `.mod` and `.zip` artifacts to the hosted `go` repository at `<backend.url>/go/go`. It does not lint, build, or test generated code. Dependency resolution may require network access. Versions may include a leading `v`; v2+ modules require the corresponding major-version module path suffix.
+
+Java generation is pinned to the compiler release matching `protobufJavaVersion` (default runtime `4.32.1`, Buf Java plugin `v32.1`). The same runtime version is used in both Maven and Gradle metadata. Overrides must be exact stable versions, not ranges, and the corresponding plugin must exist in the Buf registry.
+
 ### `NPMClient`
 
 Interface with NPM registry in order to publish packages to `npmjs.com`

package/dist/protobuf/backend/artifact-keeper.d.ts

@@ -1,22 +1,15 @@
 import type { IProtobufCompilerBackendStrategy, ProtobufCompilerBackendPublishArgs } from "./types";
 import { type ProtobufArtifactKeeperBackend } from "../types";
+/**
+ * Select the publisher for one target language.
+ *
+ * ```text
+ * The language publishers contain the package-manager rules.
+ * This class only routes the publish request.
+ * ```
+ */
 export declare class ArtifactKeeperProtobufCompilerBackend implements IProtobufCompilerBackendStrategy {
     private readonly config;
     constructor(config: ProtobufArtifactKeeperBackend);
     publish({ generatedDirectory, targetLanguage, options, }: ProtobufCompilerBackendPublishArgs): Promise<void>;
-    private publishJava;
-    private publishMaven;
-    private publishGradle;
-    private publishRust;
-    private moveJavaSources;
-    private findRustFiles;
-    private createMavenPom;
-    private createMavenSettings;
-    private createGradleBuild;
-    private createCargoToml;
-    private createRustLibrary;
-    private escapeXml;
-    private get artifactKeeperUrl();
-    private get mavenRepositoryUrl();
-    private get cargoIndexUrl();
 }

package/dist/protobuf/backend/artifact-keeper.js

@@ -1,10 +1,15 @@
-import { $ } from "bun";
-import { mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
 import { ProtobufTargetLanguage, } from "../types";
-const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
-const DEFAULT_PROST_VERSION = "0.14";
+import { ArtifactKeeperGoPublisher } from "./publisher/go";
+import { ArtifactKeeperJavaPublisher } from "./publisher/java";
+import { ArtifactKeeperRustPublisher } from "./publisher/rust/index";
+/**
+ * Select the publisher for one target language.
+ *
+ * ```text
+ * The language publishers contain the package-manager rules.
+ * This class only routes the publish request.
+ * ```
+ */
 export class ArtifactKeeperProtobufCompilerBackend {
     config;
     constructor(config) {
@@ -13,221 +18,23 @@ export class ArtifactKeeperProtobufCompilerBackend {
     async publish({ generatedDirectory, targetLanguage, options, }) {
         switch (targetLanguage) {
             case ProtobufTargetLanguage.JAVA:
-                await this.publishJava({
+                await new ArtifactKeeperJavaPublisher(this.config).publish({
                     generatedDirectory,
                     options: options,
                 });
                 return;
             case ProtobufTargetLanguage.RUST:
-                await this.publishRust({
+                await new ArtifactKeeperRustPublisher(this.config).publish({
                     generatedDirectory,
                     options: options,
                 });
                 return;
             case ProtobufTargetLanguage.GO:
-                throw new Error("Artifact Keeper Go module publishing requires its upload workflow; only Go module consumption has been configured.");
-        }
-    }
-    async publishJava({ generatedDirectory, options, }) {
-        await this.moveJavaSources(generatedDirectory);
-        if (options.buildTool === "gradle") {
-            await this.publishGradle({ generatedDirectory, options });
-            return;
-        }
-        await this.publishMaven({ generatedDirectory, options });
-    }
-    async publishMaven({ generatedDirectory, options, }) {
-        await writeFile(path.join(generatedDirectory, "pom.xml"), this.createMavenPom(options));
-        const settingsDirectory = await mkdtemp(path.join(tmpdir(), "artifact-keeper-maven-"));
-        const settingsPath = path.join(settingsDirectory, "settings.xml");
-        await writeFile(settingsPath, this.createMavenSettings());
-        try {
-            await $ `mvn --settings ${settingsPath} deploy`.cwd(generatedDirectory);
-        }
-        finally {
-            await rm(settingsDirectory, { force: true, recursive: true });
-        }
-    }
-    async publishGradle({ generatedDirectory, options, }) {
-        await Promise.all([
-            writeFile(path.join(generatedDirectory, "build.gradle"), this.createGradleBuild(options)),
-            writeFile(path.join(generatedDirectory, "settings.gradle"), `rootProject.name = "${options.artifactId}"\n`),
-        ]);
-        await $ `gradle -PmavenUsername=${this.config.username} -PmavenPassword=${this.config.token} publish`.cwd(generatedDirectory);
-    }
-    async publishRust({ generatedDirectory, options, }) {
-        const generatedFiles = await this.findRustFiles(generatedDirectory);
-        await mkdir(path.join(generatedDirectory, "src"), { recursive: true });
-        await Promise.all([
-            writeFile(path.join(generatedDirectory, "Cargo.toml"), this.createCargoToml(options)),
-            writeFile(path.join(generatedDirectory, "src", "lib.rs"), this.createRustLibrary(generatedFiles)),
-        ]);
-        await $ `cargo publish --registry cargo --token ${this.config.token} --config ${`registries.cargo.index=${this.cargoIndexUrl}`}`.cwd(generatedDirectory);
-    }
-    async moveJavaSources(generatedDirectory) {
-        const sourceDirectory = path.join(generatedDirectory, "src", "main", "java");
-        await mkdir(sourceDirectory, { recursive: true });
-        for (const entry of await readdir(generatedDirectory, {
-            withFileTypes: true,
-        })) {
-            if (entry.name === "src" ||
-                entry.name === "pom.xml" ||
-                entry.name === "build.gradle" ||
-                entry.name === "settings.gradle") {
-                continue;
-            }
-            await rename(path.join(generatedDirectory, entry.name), path.join(sourceDirectory, entry.name));
-        }
-    }
-    async findRustFiles(directory, baseDirectory = directory) {
-        const files = [];
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            const filePath = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === "src")
-                    continue;
-                files.push(...(await this.findRustFiles(filePath, baseDirectory)));
-                continue;
-            }
-            if (entry.isFile() && entry.name.endsWith(".rs")) {
-                files.push(path.relative(baseDirectory, filePath).split(path.sep).join("/"));
-            }
-        }
-        return files;
-    }
-    createMavenPom(options) {
-        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
-        return `<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>${this.escapeXml(options.groupId)}</groupId>
-  <artifactId>${this.escapeXml(options.artifactId)}</artifactId>
-  <version>${this.escapeXml(options.version)}</version>
-  <properties>
-    <maven.compiler.release>17</maven.compiler.release>
-  </properties>
-  <dependencies>
-    <dependency>
-      <groupId>com.google.protobuf</groupId>
-      <artifactId>protobuf-java</artifactId>
-      <version>${this.escapeXml(protobufVersion)}</version>
-    </dependency>
-  </dependencies>
-  <distributionManagement>
-    <repository>
-      <id>maven</id>
-      <url>${this.escapeXml(this.mavenRepositoryUrl)}</url>
-    </repository>
-  </distributionManagement>
-</project>
-`;
-    }
-    createMavenSettings() {
-        return `<settings>
-  <servers>
-    <server>
-      <id>maven</id>
-      <username>${this.escapeXml(this.config.username)}</username>
-      <password>${this.escapeXml(this.config.token)}</password>
-    </server>
-  </servers>
-</settings>
-`;
-    }
-    createGradleBuild(options) {
-        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
-        return `plugins {
-    id "java"
-    id "maven-publish"
-}
-
-group = "${options.groupId}"
-version = "${options.version}"
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
-}
-
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
-    }
-}
-
-publishing {
-    publications {
-        mavenJava(MavenPublication) {
-            from components.java
-            artifactId = "${options.artifactId}"
-        }
-    }
-    repositories {
-        maven {
-            url = uri("${this.mavenRepositoryUrl}")
-            credentials {
-                username = project.findProperty("mavenUsername")
-                password = project.findProperty("mavenPassword")
-            }
+                await new ArtifactKeeperGoPublisher(this.config).publish({
+                    generatedDirectory,
+                    options: options,
+                });
+                return;
         }
     }
 }
-`;
-    }
-    createCargoToml(options) {
-        const prostVersion = options.prostVersion ?? DEFAULT_PROST_VERSION;
-        return `[package]
-name = "${options.crateName}"
-version = "${options.version}"
-edition = "2021"
-
-[dependencies]
-prost = "${prostVersion}"
-`;
-    }
-    createRustLibrary(generatedFiles) {
-        return generatedFiles
-            .map((relativePath) => {
-            const moduleName = relativePath
-                .replace(/\.rs$/, "")
-                .replace(/[^a-zA-Z0-9_]/g, "_");
-            return `pub mod ${moduleName} {
-    include!(concat!(env!("CARGO_MANIFEST_DIR"), "/${relativePath}"));
-}
-`;
-        })
-            .join("\n");
-    }
-    escapeXml(value) {
-        return value.replace(/[<>&'"]/g, (character) => {
-            switch (character) {
-                case "<":
-                    return "&lt;";
-                case ">":
-                    return "&gt;";
-                case "&":
-                    return "&amp;";
-                case "'":
-                    return "&apos;";
-                case '"':
-                    return "&quot;";
-                default:
-                    return character;
-            }
-        });
-    }
-    get artifactKeeperUrl() {
-        return this.config.url.replace(/\/$/, "");
-    }
-    get mavenRepositoryUrl() {
-        return `${this.artifactKeeperUrl}/maven/maven/`;
-    }
-    get cargoIndexUrl() {
-        return `${this.artifactKeeperUrl}/cargo/cargo/index`;
-    }
-}

package/dist/protobuf/backend/publisher/go.d.ts

@@ -0,0 +1,33 @@
+import type { ProtobufArtifactKeeperBackend, ProtobufGoTargetLanguageOptions } from "../../types";
+/**
+ * Publish generated Go code as a hosted Go proxy module.
+ *
+ * ```text
+ * Buf writes files under the go_package import path.
+ * Artifact Keeper expects Go proxy files:
+ *   <module>/@v/<version>.mod
+ *   <module>/@v/<version>.zip
+ *
+ * This publisher creates those files and uploads them.
+ * ```
+ */
+export declare class ArtifactKeeperGoPublisher {
+    private readonly config;
+    constructor(config: ProtobufArtifactKeeperBackend);
+    publish({ generatedDirectory, options, }: {
+        generatedDirectory: string;
+        options: ProtobufGoTargetLanguageOptions;
+    }): Promise<void>;
+    private normalizeVersion;
+    private requireToolchains;
+    private inferModulePath;
+    private findPackageDirectories;
+    private validateModuleVersion;
+    private stageModule;
+    private packageModule;
+    private uploadArtifact;
+    private archiveRoot;
+    private escapeProxyPath;
+    private get repositoryUrl();
+    private get shell();
+}

package/dist/protobuf/backend/publisher/go.js

@@ -0,0 +1,186 @@
+import { $ } from "bun";
+import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import semver from "semver";
+import { isCmdAvailable } from "../../../utils/cmd";
+/**
+ * Publish generated Go code as a hosted Go proxy module.
+ *
+ * ```text
+ * Buf writes files under the go_package import path.
+ * Artifact Keeper expects Go proxy files:
+ *   <module>/@v/<version>.mod
+ *   <module>/@v/<version>.zip
+ *
+ * This publisher creates those files and uploads them.
+ * ```
+ */
+export class ArtifactKeeperGoPublisher {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async publish({ generatedDirectory, options, }) {
+        /*
+         * Go module publishing is not the same as Maven or Cargo.
+         * We must infer the module path and upload proxy artifacts.
+         */
+        const version = this.normalizeVersion(options.version);
+        await this.requireToolchains();
+        const modulePath = await this.inferModulePath(generatedDirectory);
+        this.validateModuleVersion(modulePath, version);
+        const module = { modulePath, version };
+        const stagingDirectory = await mkdtemp(path.join(tmpdir(), "protobuf-go-"));
+        try {
+            const moduleDirectory = await this.stageModule(module, generatedDirectory, stagingDirectory);
+            const artifacts = await this.packageModule(module, moduleDirectory, stagingDirectory);
+            for (const artifact of artifacts) {
+                await this.uploadArtifact(module, artifact);
+            }
+        }
+        finally {
+            await rm(stagingDirectory, { force: true, recursive: true });
+        }
+    }
+    normalizeVersion(value) {
+        /*
+         * Go proxy versions must start with v.
+         * Build metadata is not safe for this upload path.
+         */
+        const version = `v${value.replace(/^v/, "")}`;
+        if (!semver.valid(version) || version.includes("+")) {
+            throw new Error("Go publishing requires a semantic version without build metadata.");
+        }
+        return version;
+    }
+    async requireToolchains() {
+        for (const command of ["go", "zip"]) {
+            if (!(await isCmdAvailable(command))) {
+                throw new Error(`Go publishing requires ${command} on PATH.`);
+            }
+        }
+    }
+    async inferModulePath(generatedDirectory) {
+        /*
+         * Buf uses paths=import by default.
+         * Thus the directory tree contains the full go_package path.
+         * The shared prefix of all Go packages is the module path.
+         */
+        const packages = await this.findPackageDirectories(generatedDirectory);
+        const prefix = packages[0]?.split("/") ?? [];
+        for (const directory of packages.slice(1)) {
+            const segments = directory.split("/");
+            while (prefix.some((segment, index) => segment !== segments[index])) {
+                prefix.pop();
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (prefix.length < 2 || !prefix[0].includes(".")) {
+            throw new Error("Generated go_package paths must share a module prefix containing a domain and path.");
+        }
+        return prefix.join("/");
+    }
+    async findPackageDirectories(directory, relativeDirectory = "") {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const packages = [];
+        if (entries.some((entry) => entry.isFile() && entry.name.endsWith(".go"))) {
+            packages.push(relativeDirectory);
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                packages.push(...(await this.findPackageDirectories(path.join(directory, entry.name), relativeDirectory ?
+                    `${relativeDirectory}/${entry.name}`
+                    : entry.name)));
+            }
+        }
+        return packages;
+    }
+    validateModuleVersion(modulePath, version) {
+        /*
+         * Go requires the major version to match the module path.
+         * v2 and later must use a /vN suffix, unless it is gopkg.in.
+         */
+        const major = semver.major(version);
+        const pathMajor = modulePath.match(/\/v([0-9]+)$/)?.[1] ??
+            (modulePath.startsWith("gopkg.in/") ?
+                modulePath.match(/\.v([0-9]+)$/)?.[1]
+                : undefined);
+        if ((pathMajor &&
+            !modulePath.startsWith("gopkg.in/") &&
+            Number(pathMajor) < 2) ||
+            (pathMajor && Number(pathMajor) !== major) ||
+            (!pathMajor && major >= 2)) {
+            throw new Error(`Go module path ${modulePath} does not match version ${version}.`);
+        }
+    }
+    async stageModule(module, generatedDirectory, stagingDirectory) {
+        /*
+         * Buf's default paths=import layout includes the full go_package path.
+         * Strip only the module prefix.
+         * Do not modify the original generated output.
+         */
+        const sourceDirectory = path.join(generatedDirectory, module.modulePath);
+        const moduleDirectory = path.join(stagingDirectory, this.archiveRoot(module));
+        await mkdir(path.dirname(moduleDirectory), { recursive: true });
+        await cp(sourceDirectory, moduleDirectory, { recursive: true });
+        await this.shell `go mod init ${module.modulePath}`.cwd(moduleDirectory);
+        return moduleDirectory;
+    }
+    async packageModule(module, moduleDirectory, stagingDirectory) {
+        /*
+         * Resolve dependency metadata.
+         * Do not lint or test generated code here.
+         */
+        await this.shell `go mod tidy`.cwd(moduleDirectory);
+        const archivePath = path.join(stagingDirectory, "module.zip");
+        const archiveRoot = this.archiveRoot(module);
+        await this
+            .shell `zip -q -r ${archivePath} ${archiveRoot} -i ${`${archiveRoot}/*`}`.cwd(stagingDirectory);
+        return [
+            {
+                extension: "mod",
+                filePath: path.join(moduleDirectory, "go.mod"),
+                contentType: "text/plain",
+            },
+            {
+                extension: "zip",
+                filePath: archivePath,
+                contentType: "application/zip",
+            },
+        ];
+    }
+    async uploadArtifact(module, artifact) {
+        const url = `${this.repositoryUrl}/${this.escapeProxyPath(module.modulePath)}/@v/${this.escapeProxyPath(module.version)}.${artifact.extension}`;
+        const credentials = Buffer.from(`${this.config.username}:${this.config.token}`).toString("base64");
+        const response = await fetch(url, {
+            method: "PUT",
+            headers: {
+                Authorization: `Basic ${credentials}`,
+                "Content-Type": artifact.contentType,
+            },
+            body: Bun.file(artifact.filePath),
+            redirect: "error",
+        });
+        await response.body?.cancel();
+        if (!response.ok) {
+            throw new Error(`Go ${artifact.extension} upload failed: HTTP ${response.status}`);
+        }
+    }
+    archiveRoot(module) {
+        return `${module.modulePath}@${module.version}`;
+    }
+    escapeProxyPath(value) {
+        /*
+         * Go proxy URLs escape uppercase letters.
+         * Zip archive entries do not use this escape.
+         */
+        return value.replace(/[A-Z]/g, (letter) => `!${letter.toLowerCase()}`);
+    }
+    get repositoryUrl() {
+        return `${this.config.url.replace(/\/$/, "")}/go/go`;
+    }
+    get shell() {
+        return $.env({ ...process.env, GOWORK: "off" });
+    }
+}

package/dist/protobuf/backend/publisher/java.d.ts

@@ -0,0 +1,27 @@
+import type { ProtobufArtifactKeeperBackend, ProtobufJavaTargetLanguageOptions } from "../../types";
+/**
+ * Publish generated Java code to the Maven repository in Artifact Keeper.
+ *
+ * ```text
+ * Buf only generates Java source files.
+ * Maven and Gradle need a project layout and build files.
+ * This publisher creates that project wrapper and then deploys it.
+ * ```
+ */
+export declare class ArtifactKeeperJavaPublisher {
+    private readonly config;
+    static JAVA_LANGUAGE_VERSION: string;
+    constructor(config: ProtobufArtifactKeeperBackend);
+    publish({ generatedDirectory, options, }: {
+        generatedDirectory: string;
+        options: ProtobufJavaTargetLanguageOptions;
+    }): Promise<void>;
+    private publishMaven;
+    private publishGradle;
+    private moveSources;
+    createMavenPom(options: ProtobufJavaTargetLanguageOptions): string;
+    private createMavenSettings;
+    createGradleBuild(options: ProtobufJavaTargetLanguageOptions): string;
+    private escapeXml;
+    private get repositoryUrl();
+}

package/dist/protobuf/backend/publisher/java.js

@@ -0,0 +1,216 @@
+import { $ } from "bun";
+import { mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { DEFAULT_PROTOBUF_JAVA_VERSION, GRPC_JAVA_VERSION, } from "../../versions";
+/**
+ * Publish generated Java code to the Maven repository in Artifact Keeper.
+ *
+ * ```text
+ * Buf only generates Java source files.
+ * Maven and Gradle need a project layout and build files.
+ * This publisher creates that project wrapper and then deploys it.
+ * ```
+ */
+export class ArtifactKeeperJavaPublisher {
+    config;
+    static JAVA_LANGUAGE_VERSION = "17";
+    constructor(config) {
+        this.config = config;
+    }
+    async publish({ generatedDirectory, options, }) {
+        /*
+         * Buf writes packages at the output root.
+         * Java build tools expect sources in src/main/java.
+         */
+        await this.moveSources(generatedDirectory);
+        switch (options.buildTool) {
+            case "gradle":
+                return await this.publishGradle({ generatedDirectory, options });
+            case "maven":
+                return await this.publishMaven({ generatedDirectory, options });
+        }
+    }
+    async publishMaven({ generatedDirectory, options, }) {
+        await writeFile(path.join(generatedDirectory, "pom.xml"), this.createMavenPom(options));
+        /*
+         * Write credentials to a temporary Maven settings file.
+         * Do not put secrets into the generated project directory.
+         */
+        const settingsDirectory = await mkdtemp(path.join(tmpdir(), "artifact-keeper-maven-"));
+        const settingsPath = path.join(settingsDirectory, "settings.xml");
+        await writeFile(settingsPath, this.createMavenSettings());
+        try {
+            await $ `mvn --settings ${settingsPath} deploy`.cwd(generatedDirectory);
+        }
+        finally {
+            await rm(settingsDirectory, { force: true, recursive: true });
+        }
+    }
+    async publishGradle({ generatedDirectory, options, }) {
+        /*
+         * Gradle needs a build file and a settings file.
+         * Credentials are passed as project properties at publish time.
+         */
+        await Promise.all([
+            writeFile(path.join(generatedDirectory, "build.gradle"), this.createGradleBuild(options)),
+            writeFile(path.join(generatedDirectory, "settings.gradle"), `rootProject.name = "${options.artifactId}"\n`),
+        ]);
+        await $ `gradle -PmavenUsername=${this.config.username} -PmavenPassword=${this.config.token} publish`.cwd(generatedDirectory);
+    }
+    async moveSources(generatedDirectory) {
+        /*
+         * Move only generated package directories.
+         * Leave build files and an existing src directory in place.
+         */
+        const sourceDirectory = path.join(generatedDirectory, "src", "main", "java");
+        await mkdir(sourceDirectory, { recursive: true });
+        for (const entry of await readdir(generatedDirectory, {
+            withFileTypes: true,
+        })) {
+            if (entry.name === "src" ||
+                entry.name === "pom.xml" ||
+                entry.name === "build.gradle" ||
+                entry.name === "settings.gradle") {
+                continue;
+            }
+            await rename(path.join(generatedDirectory, entry.name), path.join(sourceDirectory, entry.name));
+        }
+    }
+    /*
+     * Keep this public for tests.
+     * It is generated here because Buf does not write Maven project files.
+     */
+    createMavenPom(options) {
+        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${this.escapeXml(options.groupId)}</groupId>
+  <artifactId>${this.escapeXml(options.artifactId)}</artifactId>
+  <version>${this.escapeXml(options.version)}</version>
+  <properties>
+    <maven.compiler.release>17</maven.compiler.release>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>com.google.protobuf</groupId>
+      <artifactId>protobuf-java</artifactId>
+      <version>${this.escapeXml(protobufVersion)}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+      <version>${GRPC_JAVA_VERSION}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+      <version>${GRPC_JAVA_VERSION}</version>
+    </dependency>
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
+  <distributionManagement>
+    <repository>
+      <id>maven</id>
+      <url>${this.escapeXml(this.repositoryUrl)}</url>
+    </repository>
+  </distributionManagement>
+</project>
+`;
+    }
+    createMavenSettings() {
+        return `<settings>
+  <servers>
+    <server>
+      <id>maven</id>
+      <username>${this.escapeXml(this.config.username)}</username>
+      <password>${this.escapeXml(this.config.token)}</password>
+    </server>
+  </servers>
+</settings>
+`;
+    }
+    /*
+     * Keep this public for tests.
+     * It is generated here because Buf does not write Gradle project files.
+     */
+    createGradleBuild(options) {
+        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
+        return `plugins {
+    id "java-library"
+    id "maven-publish"
+}
+
+group = "${options.groupId}"
+version = "${options.version}"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api "com.google.protobuf:protobuf-java:${protobufVersion}"
+    api "io.grpc:grpc-protobuf:${GRPC_JAVA_VERSION}"
+    api "io.grpc:grpc-stub:${GRPC_JAVA_VERSION}"
+    compileOnly "javax.annotation:javax.annotation-api:1.3.2"
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(${ArtifactKeeperJavaPublisher.JAVA_LANGUAGE_VERSION})
+    }
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+            artifactId = "${options.artifactId}"
+        }
+    }
+    repositories {
+        maven {
+            url = uri("${this.repositoryUrl}")
+            credentials {
+                username = project.findProperty("mavenUsername")
+                password = project.findProperty("mavenPassword")
+            }
+        }
+    }
+}
+`;
+    }
+    escapeXml(value) {
+        /*
+         * User-provided package data goes into XML.
+         * Escape it before Maven reads the file.
+         */
+        return value.replace(/[<>&'"]/g, (character) => {
+            switch (character) {
+                case "<":
+                    return "&lt;";
+                case ">":
+                    return "&gt;";
+                case "&":
+                    return "&amp;";
+                case "'":
+                    return "&apos;";
+                case '"':
+                    return "&quot;";
+                default:
+                    return character;
+            }
+        });
+    }
+    get repositoryUrl() {
+        return `${this.config.url.replace(/\/$/, "")}/maven/maven/`;
+    }
+}

package/dist/protobuf/backend/publisher/rust/index.d.ts

@@ -0,0 +1,21 @@
+import type { ProtobufArtifactKeeperBackend, ProtobufRustTargetLanguageOptions } from "../../../types";
+/**
+ * Publish generated Rust code as a Cargo crate.
+ *
+ * ```text
+ * Buf only generates .rs files.
+ * Cargo needs Cargo.toml and src/lib.rs.
+ * This publisher adds those files before cargo publish runs.
+ * ```
+ */
+export declare class ArtifactKeeperRustPublisher {
+    private readonly config;
+    constructor(config: ProtobufArtifactKeeperBackend);
+    publish({ generatedDirectory, options, }: {
+        generatedDirectory: string;
+        options: ProtobufRustTargetLanguageOptions;
+    }): Promise<void>;
+    private findRustFiles;
+    createCargoToml(options: ProtobufRustTargetLanguageOptions): string;
+    private get indexUrl();
+}

package/dist/protobuf/backend/publisher/rust/index.js

@@ -0,0 +1,84 @@
+import { $ } from "bun";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_PROST_VERSION, TONIC_VERSION } from "../../../versions";
+import { createRustLibrary } from "./library";
+/**
+ * Publish generated Rust code as a Cargo crate.
+ *
+ * ```text
+ * Buf only generates .rs files.
+ * Cargo needs Cargo.toml and src/lib.rs.
+ * This publisher adds those files before cargo publish runs.
+ * ```
+ */
+export class ArtifactKeeperRustPublisher {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async publish({ generatedDirectory, options, }) {
+        const generatedFiles = await this.findRustFiles(generatedDirectory);
+        /*
+         * Add the two files that make the generated code a crate.
+         * Cargo.toml gives package data and dependencies.
+         * src/lib.rs exposes the generated modules to users.
+         */
+        await mkdir(path.join(generatedDirectory, "src"), { recursive: true });
+        await Promise.all([
+            writeFile(path.join(generatedDirectory, "Cargo.toml"), this.createCargoToml(options)),
+            writeFile(path.join(generatedDirectory, "src", "lib.rs"), createRustLibrary(generatedFiles)),
+        ]);
+        /*
+         * Artifact Keeper exposes Cargo as a sparse registry.
+         * Cargo reads these CARGO_REGISTRIES_* variables for this publish.
+         */
+        await $.env({
+            ...process.env,
+            CARGO_REGISTRIES_CARGO_INDEX: this.indexUrl,
+            CARGO_REGISTRIES_CARGO_TOKEN: this.config.token,
+            CARGO_REGISTRIES_CARGO_CREDENTIAL_PROVIDER: "cargo:token",
+        }) `cargo publish --registry cargo`.cwd(generatedDirectory);
+    }
+    /*
+     * Find generated Rust files before we add src/lib.rs.
+     * Do not scan src, or lib.rs can include itself on a re-run.
+     */
+    async findRustFiles(directory, baseDirectory = directory) {
+        const files = [];
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const filePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "src")
+                    continue;
+                files.push(...(await this.findRustFiles(filePath, baseDirectory)));
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith(".rs")) {
+                files.push(path.relative(baseDirectory, filePath).split(path.sep).join("/"));
+            }
+        }
+        return files;
+    }
+    /*
+     * Keep this public for tests.
+     * It is generated here because Buf does not write Cargo manifests.
+     */
+    createCargoToml(options) {
+        const prostVersion = options.prostVersion ?? DEFAULT_PROST_VERSION;
+        return `[package]
+name = "${options.crateName}"
+version = "${options.version}"
+edition = "2021"
+
+[dependencies]
+prost = "${prostVersion}"
+prost-types = "${prostVersion}"
+tonic = "${TONIC_VERSION}"
+tonic-prost = "${TONIC_VERSION}"
+`;
+    }
+    get indexUrl() {
+        return `sparse+${this.config.url.replace(/\/$/, "")}/cargo/cargo/`;
+    }
+}

package/dist/protobuf/backend/publisher/rust/library.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Create the Cargo library entry file for generated Rust code.
+ *
+ * ```text
+ * Buf writes one Rust file for each proto package.
+ * Example:
+ *   example.v1.rs
+ *   example.v1.tonic.rs
+ *
+ * Cargo does not load these files by itself.
+ * A crate must have src/lib.rs.
+ * This function writes the content for that file.
+ *
+ * The module path must match the proto package.
+ * example.v1 becomes example::v1.
+ * The Prost messages and Tonic services go in the same module.
+ * ```
+ */
+export declare function createRustLibrary(generatedFiles: string[]): string;

package/dist/protobuf/backend/publisher/rust/library.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+/**
+ * Create the Cargo library entry file for generated Rust code.
+ *
+ * ```text
+ * Buf writes one Rust file for each proto package.
+ * Example:
+ *   example.v1.rs
+ *   example.v1.tonic.rs
+ *
+ * Cargo does not load these files by itself.
+ * A crate must have src/lib.rs.
+ * This function writes the content for that file.
+ *
+ * The module path must match the proto package.
+ * example.v1 becomes example::v1.
+ * The Prost messages and Tonic services go in the same module.
+ * ```
+ */
+export function createRustLibrary(generatedFiles) {
+    const root = { files: [], children: new Map() };
+    for (const file of [...generatedFiles].sort()) {
+        const packageName = path.posix
+            .basename(file)
+            .replace(/(?:\.tonic)?\.rs$/, "");
+        let node = root;
+        for (const segment of packageName === "_" ? [] : packageName.split(".")) {
+            /*
+             * Rust module names must be valid identifiers.
+             * We fail here instead of publishing a crate that cannot compile.
+             */
+            if (!/^(?:r#)?[a-zA-Z_][a-zA-Z0-9_]*$/.test(segment) ||
+                ["self", "Self", "super", "crate"].includes(segment)) {
+                throw new Error(`Cannot represent Rust package module ${segment} from ${file}.`);
+            }
+            /*
+             * Use a raw identifier for each module name.
+             * This makes names such as type or match safe in Rust.
+             */
+            const name = segment.startsWith("r#") ? segment : `r#${segment}`;
+            let child = node.children.get(name);
+            if (!child) {
+                child = { files: [], children: new Map() };
+                node.children.set(name, child);
+            }
+            node = child;
+        }
+        node.files.push(file);
+    }
+    function render(node, indent = "") {
+        /*
+         * Include files from the crate root.
+         * The generated files stay outside src.
+         * CARGO_MANIFEST_DIR gives Cargo the crate root path.
+         */
+        const includes = node.files
+            .map((file) => `${indent}include!(concat!(env!("CARGO_MANIFEST_DIR"), ${JSON.stringify(`/${file}`)}));\n`)
+            .join("");
+        const children = [...node.children]
+            .map(([name, child]) => `${indent}pub mod ${name} {\n${render(child, `${indent}    `)}${indent}}\n`)
+            .join("");
+        return includes + children;
+    }
+    return render(root);
+}

package/dist/protobuf/client.d.ts

@@ -1,10 +1,18 @@
-import { type ProtobufCompilerCompileArgs, type ProtobufCompilerCompileResult } from "./types";
+import { type IProtobufTargetLanguageStrategy } from "./strategy";
+import { type ProtobufCompilerCompileArgs, type ProtobufCompilerCompileResult, type ProtobufTargetLanguageOptions, ProtobufTargetLanguage } from "./types";
+type CompilationTarget = {
+    language: ProtobufTargetLanguage;
+    options: ProtobufTargetLanguageOptions;
+    strategy: IProtobufTargetLanguageStrategy;
+};
 export declare class ProtobufCompilerClient {
     compile({ backend, bufToken, targetLanguages, protoFilesLocation, outputDirectory, }: ProtobufCompilerCompileArgs): Promise<ProtobufCompilerCompileResult>;
-    installToolchains(): Promise<void>;
+    installToolchains(targets?: CompilationTarget[]): Promise<void>;
+    private requireToolchains;
     private generateWithBuf;
     private getCompilationTargets;
     private getConfiguredTargetLanguages;
     private getBufGenerateInput;
     private findBufModuleDirectory;
 }
+export {};

package/dist/protobuf/client.js

@@ -8,16 +8,16 @@ import { createProtobufCompilerBackendStrategy } from "./backend";
 import { GoProtobufTargetLanguageStrategy, JavaProtobufTargetLanguageStrategy, RustProtobufTargetLanguageStrategy, } from "./strategy";
 import { ProtobufTargetLanguage, } from "./types";
 const TARGET_LANGUAGE_STRATEGY_FACTORIES = {
-    [ProtobufTargetLanguage.JAVA]: () => new JavaProtobufTargetLanguageStrategy(),
+    [ProtobufTargetLanguage.JAVA]: (targets) => new JavaProtobufTargetLanguageStrategy(targets[ProtobufTargetLanguage.JAVA]?.protobufJavaVersion),
     [ProtobufTargetLanguage.GO]: () => new GoProtobufTargetLanguageStrategy(),
-    [ProtobufTargetLanguage.RUST]: () => new RustProtobufTargetLanguageStrategy(),
+    [ProtobufTargetLanguage.RUST]: (targets) => new RustProtobufTargetLanguageStrategy(targets[ProtobufTargetLanguage.RUST]?.prostVersion),
 };
 export class ProtobufCompilerClient {
     async compile({ backend, bufToken, targetLanguages, protoFilesLocation, outputDirectory, }) {
-        await this.installToolchains();
+        const targets = this.getCompilationTargets(targetLanguages);
+        await this.requireToolchains(targets);
         const outputDirectoryPath = path.resolve(outputDirectory ??
             (await mkdtemp(path.join(tmpdir(), "protobuf-compiler-"))));
-        const targets = this.getCompilationTargets(targetLanguages);
         const compilerBackend = backend ? createProtobufCompilerBackendStrategy(backend) : undefined;
         await mkdir(outputDirectoryPath, { recursive: true });
         await this.generateWithBuf({
@@ -45,10 +45,24 @@ export class ProtobufCompilerClient {
         }
         return { generatedDirectories, outputDirectory: outputDirectoryPath };
     }
-    async installToolchains() {
-        if (!(await isCmdAvailable("buf"))) {
-            console.log("Buf is missing, installing globally via NPM...");
-            await $ `npm i -g @bufbuild/buf`;
+    async installToolchains(targets = []) {
+        await this.requireToolchains(targets);
+    }
+    async requireToolchains(targets) {
+        /*
+         * Use local protoc plugins, not Buf remote plugins.
+         * This keeps proto source code off BSR servers.
+         * The setup action installs these tools in CI.
+         */
+        const requiredCommands = [
+            "buf",
+            ...new Set(targets.flatMap(({ strategy }) => strategy.requiredCommands ?? [])),
+        ];
+        for (const command of requiredCommands) {
+            if (await isCmdAvailable(command))
+                continue;
+            throw new Error(`${command} is required for local protobuf generation. ` +
+                "Enable INSTALL_PROTO_DEPENDENCIES in the setup action, or install the tool on PATH.");
         }
     }
     async generateWithBuf({ bufToken, protoFilesLocation, outputDirectory, targetStrategies, }) {
@@ -56,12 +70,17 @@ export class ProtobufCompilerClient {
         const templatePath = path.join(templateDirectory, "buf.gen.yaml");
         const { input, pathFilter } = await this.getBufGenerateInput(protoFilesLocation);
         const pathFlag = pathFilter ? ["--path", pathFilter] : [];
+        /*
+         * Write a temporary Buf template.
+         * This lets callers choose languages without a checked-in buf.gen.yaml.
+         */
         await writeFile(templatePath, yaml.stringify({
             version: "v2",
-            plugins: targetStrategies.map((strategy) => ({
+            plugins: targetStrategies.flatMap((strategy) => strategy.plugins.map((plugin) => ({
+                ...plugin,
                 out: strategy.outputDirectoryName,
-                remote: strategy.remotePlugin,
-            })),
+                include_imports: true,
+            }))),
         }));
         try {
             const command = bufToken ?
@@ -80,13 +99,18 @@ export class ProtobufCompilerClient {
         return this.getConfiguredTargetLanguages(targetLanguages).map(([language, options]) => ({
             language,
             options,
-            strategy: TARGET_LANGUAGE_STRATEGY_FACTORIES[language](),
+            strategy: TARGET_LANGUAGE_STRATEGY_FACTORIES[language](targetLanguages),
         }));
     }
     getConfiguredTargetLanguages(targetLanguages) {
         return Object.entries(targetLanguages).flatMap(([language, options]) => options ? [[Number(language), options]] : []);
     }
     async getBufGenerateInput(protoFilesLocation) {
+        /*
+         * If the input is inside a Buf module, run Buf at the module root.
+         * Then add --path for the selected file.
+         * This lets imports resolve correctly.
+         */
         const resolvedLocation = path.resolve(protoFilesLocation);
         const stats = await Bun.file(resolvedLocation).stat();
         if (stats.isFile() && !resolvedLocation.endsWith(".proto")) {

package/dist/protobuf/strategy/go.d.ts

@@ -1,5 +1,8 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class GoProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "go";
-    readonly remotePlugin = "buf.build/protocolbuffers/go";
+    readonly requiredCommands: string[];
+    readonly plugins: {
+        local: string;
+    }[];
 }

package/dist/protobuf/strategy/go.js

@@ -1,4 +1,8 @@
 export class GoProtobufTargetLanguageStrategy {
     outputDirectoryName = "go";
-    remotePlugin = "buf.build/protocolbuffers/go";
+    requiredCommands = ["protoc-gen-go", "protoc-gen-go-grpc"];
+    plugins = [
+        { local: "protoc-gen-go" },
+        { local: "protoc-gen-go-grpc" },
+    ];
 }

package/dist/protobuf/strategy/java.d.ts

@@ -1,5 +1,13 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class JavaProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "java";
-    readonly remotePlugin = "buf.build/protocolbuffers/java";
+    readonly requiredCommands: string[];
+    readonly plugins: ({
+        protoc_builtin: string;
+        local?: undefined;
+    } | {
+        local: string;
+        protoc_builtin?: undefined;
+    })[];
+    constructor(runtimeVersion?: string);
 }

package/dist/protobuf/strategy/java.js

@@ -1,4 +1,19 @@
+import semver from "semver";
+import { DEFAULT_PROTOBUF_JAVA_VERSION } from "../versions";
 export class JavaProtobufTargetLanguageStrategy {
     outputDirectoryName = "java";
-    remotePlugin = "buf.build/protocolbuffers/java";
+    requiredCommands = ["protoc-gen-grpc-java"];
+    plugins = [
+        { protoc_builtin: "java" },
+        { local: "protoc-gen-grpc-java" },
+    ];
+    constructor(runtimeVersion = DEFAULT_PROTOBUF_JAVA_VERSION) {
+        const version = semver.parse(runtimeVersion);
+        if (!version ||
+            ![3, 4].includes(version.major) ||
+            version.prerelease.length > 0 ||
+            version.build.length > 0) {
+            throw new Error("protobufJavaVersion must be an exact stable version.");
+        }
+    }
 }

package/dist/protobuf/strategy/rust.d.ts

@@ -1,5 +1,13 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class RustProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "rust";
-    readonly remotePlugin = "buf.build/community/neoeinstein-prost";
+    readonly requiredCommands: string[];
+    readonly plugins: ({
+        local: string;
+        opt?: undefined;
+    } | {
+        local: string;
+        opt: string[];
+    })[];
+    constructor(prostVersion?: string);
 }

package/dist/protobuf/strategy/rust.js

@@ -1,4 +1,23 @@
+import semver from "semver";
+import { DEFAULT_PROST_VERSION } from "../versions";
 export class RustProtobufTargetLanguageStrategy {
     outputDirectoryName = "rust";
-    remotePlugin = "buf.build/community/neoeinstein-prost";
+    requiredCommands = ["protoc-gen-prost", "protoc-gen-tonic"];
+    plugins = [
+        { local: "protoc-gen-prost" },
+        {
+            local: "protoc-gen-tonic",
+            /*
+             * Do not let Tonic include Prost files.
+             * src/lib.rs includes messages and services in one module.
+             */
+            opt: ["no_include=true"],
+        },
+    ];
+    constructor(prostVersion = DEFAULT_PROST_VERSION) {
+        if (!semver.validRange(prostVersion) ||
+            !semver.subset(prostVersion, ">=0.14.0 <0.15.0")) {
+            throw new Error("The pinned Rust gRPC generators require prostVersion in the 0.14 release series.");
+        }
+    }
 }

package/dist/protobuf/strategy/types.d.ts

@@ -1,4 +1,15 @@
+export type ProtobufGeneratorPlugin = {
+    readonly remote: string;
+    readonly opt?: string[];
+} | {
+    readonly local: string;
+    readonly opt?: string[];
+} | {
+    readonly protoc_builtin: string;
+    readonly opt?: string[];
+};
 export interface IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName: string;
-    readonly remotePlugin: string;
+    readonly plugins: ProtobufGeneratorPlugin[];
+    readonly requiredCommands?: readonly string[];
 }

package/dist/protobuf/types.d.ts

@@ -17,19 +17,22 @@ export interface ProtobufArtifactKeeperBackend {
 }
 export type ProtobufCompilerBackendConfig = ProtobufArtifactKeeperBackend;
 export interface ProtobufJavaTargetLanguageOptions {
+    /** Maven/Gradle publishing group; Java packages are configured in .proto files. */
     groupId: string;
     artifactId: string;
     version: string;
     buildTool?: "maven" | "gradle";
+    /** Exact stable Java runtime version; also pins the matching Buf generator. Defaults to 4.32.1. */
     protobufJavaVersion?: string;
 }
 export interface ProtobufRustTargetLanguageOptions {
     crateName: string;
     version: string;
+    /** Prost runtime constraint within 0.14; matched to the pinned Prost/Tonic generators. */
     prostVersion?: string;
 }
+/** Go import paths are configured with go_package in .proto files. */
 export interface ProtobufGoTargetLanguageOptions {
-    modulePath: string;
     version: string;
 }
 export type ProtobufTargetLanguageOptions = ProtobufGoTargetLanguageOptions | ProtobufJavaTargetLanguageOptions | ProtobufRustTargetLanguageOptions;
@@ -42,7 +45,7 @@ export interface ProtobufCompilerCompileArgs {
     /** All targets are published through this one backend. */
     backend?: ProtobufCompilerBackendConfig;
     sourceLanguage: ProtobufSourceLanguage;
-    /** Optional BSR API token used for Buf remote plugins. */
+    /** Optional Buf token for private module inputs. Code generation uses local plugins. */
     bufToken?: string;
     targetLanguages: ProtobufTargetLanguages;
     /** Directory containing proto files, or one specific `.proto` file. */

package/dist/protobuf/versions.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export declare const GRPC_JAVA_VERSION = "1.75.0";
+export declare const DEFAULT_PROST_VERSION = "0.14.1";
+export declare const TONIC_VERSION = "0.14.1";

package/dist/protobuf/versions.js

@@ -0,0 +1,4 @@
+export const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export const GRPC_JAVA_VERSION = "1.75.0";
+export const DEFAULT_PROST_VERSION = "0.14.1";
+export const TONIC_VERSION = "0.14.1";

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "author": "Tahmid Ahmed",
   "description": "A collection of Bun shell scripts that can be re-used in various CICD pipelines.",
-  "version": "1.0.78",
+  "version": "1.0.79-beta.cf2df8b7",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },