@tahminator/pipeline 1.0.77 → 1.0.78-beta.1fe28066

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 its remote plugins. Java, Rust, and Go targets can be published to Artifact Keeper with Maven/Gradle, Cargo, or Go module uploads. The client installs Buf globally with npm when necessary.
 
 ```ts
 const protobuf = new ProtobufCompilerClient();
@@ -210,6 +210,46 @@ 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.
+
+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's Prost and Tonic plugins are pinned to `v0.5.0`, 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

@@ -14,7 +14,6 @@ export declare class ArtifactKeeperProtobufCompilerBackend implements IProtobufC
     private createMavenSettings;
     private createGradleBuild;
     private createCargoToml;
-    private createRustLibrary;
     private escapeXml;
     private get artifactKeeperUrl();
     private get mavenRepositoryUrl();

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

@@ -3,8 +3,9 @@ import { mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promise
 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 { DEFAULT_PROTOBUF_JAVA_VERSION, DEFAULT_PROST_VERSION, GRPC_JAVA_VERSION, TONIC_VERSION, } from "../versions";
+import { ArtifactKeeperGoPublisher } from "./go";
+import { createRustLibrary } from "./rust-library";
 export class ArtifactKeeperProtobufCompilerBackend {
     config;
     constructor(config) {
@@ -25,7 +26,11 @@ export class ArtifactKeeperProtobufCompilerBackend {
                 });
                 return;
             case ProtobufTargetLanguage.GO:
-                throw new Error("Artifact Keeper Go module publishing requires its upload workflow; only Go module consumption has been configured.");
+                await new ArtifactKeeperGoPublisher(this.config).publish({
+                    generatedDirectory,
+                    options: options,
+                });
+                return;
         }
     }
     async publishJava({ generatedDirectory, options, }) {
@@ -60,9 +65,14 @@ export class ArtifactKeeperProtobufCompilerBackend {
         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)),
+            writeFile(path.join(generatedDirectory, "src", "lib.rs"), createRustLibrary(generatedFiles)),
         ]);
-        await $ `cargo publish --registry cargo --token ${this.config.token} --config ${`registries.cargo.index=${this.cargoIndexUrl}`}`.cwd(generatedDirectory);
+        await $.env({
+            ...process.env,
+            CARGO_REGISTRIES_CARGO_INDEX: this.cargoIndexUrl,
+            CARGO_REGISTRIES_CARGO_TOKEN: this.config.token,
+            CARGO_REGISTRIES_CARGO_CREDENTIAL_PROVIDER: "cargo:token",
+        }) `cargo publish --registry cargo`.cwd(generatedDirectory);
     }
     async moveJavaSources(generatedDirectory) {
         const sourceDirectory = path.join(generatedDirectory, "src", "main", "java");
@@ -114,6 +124,22 @@ export class ArtifactKeeperProtobufCompilerBackend {
       <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>
@@ -139,7 +165,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
     createGradleBuild(options) {
         const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
         return `plugins {
-    id "java"
+    id "java-library"
     id "maven-publish"
 }
 
@@ -151,7 +177,10 @@ repositories {
 }
 
 dependencies {
-    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
+    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 {
@@ -188,21 +217,11 @@ edition = "2021"
 
 [dependencies]
 prost = "${prostVersion}"
+prost-types = "${prostVersion}"
+tonic = "${TONIC_VERSION}"
+tonic-prost = "${TONIC_VERSION}"
 `;
     }
-    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) {
@@ -228,6 +247,6 @@ prost = "${prostVersion}"
         return `${this.artifactKeeperUrl}/maven/maven/`;
     }
     get cargoIndexUrl() {
-        return `${this.artifactKeeperUrl}/cargo/cargo/index`;
+        return `sparse+${this.artifactKeeperUrl}/cargo/cargo/`;
     }
 }

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

@@ -0,0 +1,22 @@
+import type { ProtobufArtifactKeeperBackend, ProtobufGoTargetLanguageOptions } from "../types";
+/** Publishes Buf's import-path output as a hosted Go proxy module. */
+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/go.js

@@ -0,0 +1,149 @@
+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";
+/** Publishes Buf's import-path output as a hosted Go proxy module. */
+export class ArtifactKeeperGoPublisher {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async publish({ generatedDirectory, options, }) {
+        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) {
+        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) {
+        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) {
+        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 import path.
+        // Strip only the module prefix, without modifying the original 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; generated code is not linted or tested.
+        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; archive entries do not.
+        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/rust-library.d.ts

@@ -0,0 +1,2 @@
+/** Prost filenames encode proto packages; Tonic belongs in the same module. */
+export declare function createRustLibrary(generatedFiles: string[]): string;

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

@@ -0,0 +1,35 @@
+import path from "node:path";
+/** Prost filenames encode proto packages; Tonic belongs 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(".")) {
+            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}.`);
+            }
+            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 = "") {
+        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.js

@@ -8,9 +8,9 @@ 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, }) {
@@ -58,10 +58,11 @@ export class ProtobufCompilerClient {
         const pathFlag = pathFilter ? ["--path", pathFilter] : [];
         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,7 +81,7 @@ 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) {

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

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

package/dist/protobuf/strategy/go.js

@@ -1,4 +1,7 @@
 export class GoProtobufTargetLanguageStrategy {
     outputDirectoryName = "go";
-    remotePlugin = "buf.build/protocolbuffers/go";
+    plugins = [
+        { remote: "buf.build/protocolbuffers/go:v1.36.11" },
+        { remote: "buf.build/grpc/go:v1.5.1" },
+    ];
 }

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

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

package/dist/protobuf/strategy/java.js

@@ -1,4 +1,13 @@
+import { DEFAULT_PROTOBUF_JAVA_VERSION, GRPC_JAVA_VERSION, javaGeneratorVersion, } from "../versions";
 export class JavaProtobufTargetLanguageStrategy {
     outputDirectoryName = "java";
-    remotePlugin = "buf.build/protocolbuffers/java";
+    plugins;
+    constructor(runtimeVersion = DEFAULT_PROTOBUF_JAVA_VERSION) {
+        this.plugins = [
+            {
+                remote: `buf.build/protocolbuffers/java:v${javaGeneratorVersion(runtimeVersion)}`,
+            },
+            { remote: `buf.build/grpc/java:v${GRPC_JAVA_VERSION}` },
+        ];
+    }
 }

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

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

package/dist/protobuf/strategy/rust.js

@@ -1,4 +1,21 @@
+import semver from "semver";
+import { DEFAULT_PROST_VERSION, PROST_PLUGIN_VERSION } from "../versions";
 export class RustProtobufTargetLanguageStrategy {
     outputDirectoryName = "rust";
-    remotePlugin = "buf.build/community/neoeinstein-prost";
+    plugins = [
+        {
+            remote: `buf.build/community/neoeinstein-prost:v${PROST_PLUGIN_VERSION}`,
+        },
+        {
+            remote: `buf.build/community/neoeinstein-tonic:v${PROST_PLUGIN_VERSION}`,
+            // lib.rs includes messages and service stubs into the same package 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,8 @@
+export interface ProtobufGeneratorPlugin {
+    readonly remote: string;
+    readonly opt?: string[];
+}
 export interface IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName: string;
-    readonly remotePlugin: string;
+    readonly plugins: ProtobufGeneratorPlugin[];
 }

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;

package/dist/protobuf/versions.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export declare const GRPC_JAVA_VERSION = "1.75.0";
+export declare const PROST_PLUGIN_VERSION = "0.5.0";
+export declare const DEFAULT_PROST_VERSION = "0.14.1";
+export declare const TONIC_VERSION = "0.14.1";
+/** Java runtime releases include a language major absent from modern protoc tags. */
+export declare function javaGeneratorVersion(runtimeVersion: string): string;

package/dist/protobuf/versions.js

@@ -0,0 +1,17 @@
+export const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export const GRPC_JAVA_VERSION = "1.75.0";
+export const PROST_PLUGIN_VERSION = "0.5.0";
+export const DEFAULT_PROST_VERSION = "0.14.1";
+export const TONIC_VERSION = "0.14.1";
+/** Java runtime releases include a language major absent from modern protoc tags. */
+export function javaGeneratorVersion(runtimeVersion) {
+    const match = /^(3|4)\.(\d+)\.(\d+)$/.exec(runtimeVersion);
+    if (!match) {
+        throw new Error("protobufJavaVersion must be an exact stable 3.x or 4.x version.");
+    }
+    const [, major, minor, patch] = match;
+    // Before protoc 21, compiler and Java runtime used the same 3.x version.
+    return major === "3" && Number(minor) < 21 ?
+        runtimeVersion
+        : `${minor}.${patch}`;
+}

package/dist/versioning/client.js

@@ -83,7 +83,8 @@ export class VersioningClient {
     async nextBeta(sha, ...opts) {
         const latestTag = await this.githubClient.getLatestTag(...opts);
         if (!latestTag) {
-            throw new Error("You must upload a tag atleast once before generating a beta tag.");
+            console.warn("No latest tag yet. You should upload a tag atleast once before generating a beta tag. Defaulting to `1.0.0-beta.${sha}`");
+            return `1.0.0-beta.${sha}`;
         }
         const latest = this.parseOrThrow("latest tag from github", latestTag);
         return `${latest.toString()}-beta.${sha}`;

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.77",
+  "version": "1.0.78-beta.1fe28066",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },