@mindburn/helm-ai-kernel 0.5.1 → 0.5.9

package/README.md

@@ -10,7 +10,7 @@ npm ci
 npm run build
 ```
 
-Package metadata declares version `0.5.1` in `package.json`; this README does
+Package metadata declares version `0.5.9` in `package.json`; this README does
 not claim that a registry package has been published.
 
 ## Local Development
@@ -86,4 +86,4 @@ and sandbox grants attached to HELM-native receipts and EvidencePacks.
 
 ## Release Notes
 
-`0.5.1` is the release-hardening patch with the retained OpenAPI client surface and protobuf message bindings.
+`0.5.9` is the release-hardening patch with the retained OpenAPI client surface and protobuf message bindings.

package/dist/adapters/agent-frameworks.coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/agent-frameworks.coverage.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from "vitest";
+import { createAgentFrameworkAdapter, fromLangGraphToolCall, fromLlamaIndexToolCall, fromN8NNodeExecution, fromOpenAIAgentsToolCall, fromSemanticKernelFunctionCall, fromZapierWebhookCall, fromRawMCPToolCall, toOpenAIFunctionTool, } from "./agent-frameworks.js";
+describe("agent framework adapter coverage branches", () => {
+    it("normalizes fallback argument shapes", () => {
+        expect(fromOpenAIAgentsToolCall({ name: "tool", arguments: "not json" }).arguments).toEqual({ value: "not json" });
+        expect(fromOpenAIAgentsToolCall({ name: "tool", arguments: "" }).arguments).toEqual({});
+        expect(fromOpenAIAgentsToolCall({ name: "tool", arguments: [1, 2] }).arguments).toEqual({ items: [1, 2] });
+        expect(fromOpenAIAgentsToolCall({ name: "tool", arguments: 7 }).arguments).toEqual({ value: 7 });
+        expect(fromSemanticKernelFunctionCall({ pluginName: "files", functionName: "read", arguments: {} }).toolName).toBe("files.read");
+        expect(fromSemanticKernelFunctionCall({ functionName: "read", arguments: {} }).toolName).toBe("read");
+        expect(fromLlamaIndexToolCall({ tool_name: "search", input: null }).arguments).toEqual({});
+        expect(fromN8NNodeExecution({ name: "http", input: { url: "https://example.test" } }).toolName).toBe("http");
+        expect(fromZapierWebhookCall({ tool: "zap", payload: { id: 1 } }).toolName).toBe("zap");
+    });
+    it("throws on missing and unnormalizable tool names", () => {
+        expect(() => fromLangGraphToolCall({ args: {} })).toThrow("requires a tool name");
+        expect(() => toOpenAIFunctionTool({
+            framework: "raw-mcp",
+            toolName: "   ",
+            arguments: {},
+        })).toThrow("normalizes to an empty");
+    });
+    it("builds and submits with default option merging", async () => {
+        const response = { response: { id: "chatcmpl", choices: [] }, governance: { receiptId: "r1" } };
+        const client = {
+            chatCompletionsWithReceipt: vi.fn(async () => response),
+        };
+        const adapter = createAgentFrameworkAdapter(client, {
+            model: "gpt-default",
+            policyPrompt: "default policy",
+            temperature: 0.1,
+            maxTokens: 128,
+            metadata: { defaulted: true },
+        });
+        const action = fromRawMCPToolCall({
+            serverId: "srv",
+            name: "file.read",
+            args: { path: "/tmp/a" },
+            scopes: ["fs:read"],
+            metadata: { call: "one" },
+        });
+        const request = adapter.buildRequest(action);
+        expect(request.model).toBe("gpt-default");
+        expect(request.messages[1].content).toContain("file.read");
+        const result = await adapter.submit(action, { model: "gpt-override", temperature: 0.2 });
+        expect(result.request.model).toBe("gpt-override");
+        expect(result.action.metadata).toMatchObject({ defaulted: true, call: "one" });
+        expect(client.chatCompletionsWithReceipt).toHaveBeenCalledOnce();
+    });
+});

package/dist/client-coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client-coverage.test.js

@@ -0,0 +1,152 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { HelmApiError, HelmClient } from "./client.js";
+function jsonResponse(body, status = 200, headers = {}) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json", ...headers },
+    });
+}
+function helmError(status = 500) {
+    return jsonResponse({ error: { message: "denied", type: "policy", code: "DENY", reason_code: "DENY_POLICY_VIOLATION" } }, status);
+}
+describe("HelmClient coverage matrix", () => {
+    let fetchSpy;
+    let client;
+    beforeEach(() => {
+        fetchSpy = vi.fn(async () => jsonResponse({ ok: true }));
+        vi.stubGlobal("fetch", fetchSpy);
+        client = new HelmClient({
+            baseUrl: "http://helm.test/",
+            apiKey: "token",
+            tenantId: "tenant-a",
+            timeout: 5_000,
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("constructs fallback API errors for non-HELM bodies", () => {
+        expect(new HelmApiError(418, {}).message).toBe("HELM API request failed with HTTP 418");
+        expect(new HelmApiError(409, { error: null }).reasonCode).toBe("ERROR_INTERNAL");
+        expect(new HelmApiError(400, { error: { message: "bad" } }).message).toBe("HELM API request failed with HTTP 400");
+        expect(new HelmApiError(401, { error: { reason_code: "DENY" } }).reasonCode).toBe("ERROR_INTERNAL");
+    });
+    it("exercises every JSON endpoint wrapper", async () => {
+        const calls = [
+            ["evaluateDecision", [{ effect: "read" }]],
+            ["runPublicDemo", ["read_ticket", { id: 1 }]],
+            ["verifyPublicDemoReceipt", [{ receipt_id: "r1" }, "hash"]],
+            ["approveIntent", [{ intent_hash: "h", signature_b64: "sig", public_key_b64: "pk" }]],
+            ["listSessions", []],
+            ["listSessions", [7, 3]],
+            ["getReceipts", ["session/one"]],
+            ["getReceipt", ["receipt#one"]],
+            ["createEvidenceEnvelopeManifest", [{ manifest_id: "m1", envelope: "dsse", native_evidence_hash: "h" }]],
+            ["listEvidenceEnvelopeManifests", []],
+            ["getEvidenceEnvelopeManifest", ["manifest/a b"]],
+            ["verifyEvidenceEnvelopeManifest", ["manifest/a b"]],
+            ["getEvidenceEnvelopePayload", ["manifest/a b"]],
+            ["getBoundaryStatus", []],
+            ["listBoundaryCapabilities", []],
+            ["listBoundaryRecords", []],
+            ["listBoundaryRecords", [{ limit: 10, offset: 0, empty: "", omitted: undefined }]],
+            ["getBoundaryRecord", ["record/a b"]],
+            ["verifyBoundaryRecord", ["record/a b"]],
+            ["listBoundaryCheckpoints", []],
+            ["createBoundaryCheckpoint", []],
+            ["verifyBoundaryCheckpoint", ["checkpoint/a b"]],
+            ["conformanceRun", [{ level: "basic" }]],
+            ["getConformanceReport", ["report-1"]],
+            ["listConformanceReports", []],
+            ["listConformanceVectors", []],
+            ["listNegativeConformanceVectors", []],
+            ["listMcpRegistry", []],
+            ["discoverMcpServer", [{ server_id: "srv" }]],
+            ["approveMcpServer", [{ server_id: "srv", approver_id: "me", approval_receipt_id: "r" }]],
+            ["getMcpRegistryRecord", ["srv/a b"]],
+            ["approveMcpRegistryRecord", ["srv/a b", { reason: "ok" }]],
+            ["revokeMcpRegistryRecord", ["srv/a b"]],
+            ["revokeMcpRegistryRecord", ["srv/a b", "stale"]],
+            ["scanMcpServer", [{ server_id: "srv" }]],
+            ["listMcpAuthProfiles", []],
+            ["putMcpAuthProfile", ["profile/a b", { scopes: ["tools"] }]],
+            ["authorizeMcpCall", [{ tool: "read" }]],
+            ["inspectSandboxGrants", []],
+            ["inspectSandboxGrants", ["runtime", "profile", "epoch"]],
+            ["listSandboxProfiles", []],
+            ["listSandboxGrants", []],
+            ["createSandboxGrant", [{ runtime: "wasi" }]],
+            ["getSandboxGrant", ["grant/a b"]],
+            ["verifySandboxGrant", ["grant/a b"]],
+            ["preflightSandboxGrant", [{ runtime: "wasi" }]],
+            ["listAgentIdentities", []],
+            ["getAuthzHealth", []],
+            ["checkAuthz", [{ subject: "agent" }]],
+            ["listAuthzSnapshots", []],
+            ["getAuthzSnapshot", ["snapshot/a b"]],
+            ["listApprovalCeremonies", []],
+            ["createApprovalCeremony", [{ approval_id: "a1" }]],
+            ["transitionApprovalCeremony", ["approval/a b", "approve"]],
+            ["transitionApprovalCeremony", ["approval/a b", "deny", { reason: "bad" }]],
+            ["createApprovalWebAuthnChallenge", ["approval/a b"]],
+            ["createApprovalWebAuthnChallenge", ["approval/a b", { user: "me" }]],
+            ["assertApprovalWebAuthnChallenge", ["approval/a b", { credential: "c" }]],
+            ["listBudgetCeilings", []],
+            ["putBudgetCeiling", ["budget/a b", { limit: 1 }]],
+            ["getCoexistenceCapabilities", []],
+            ["getTelemetryOTelConfig", []],
+            ["exportTelemetry", [{ span: "all" }]],
+            ["health", []],
+            ["version", []],
+        ];
+        for (const [method, args] of calls) {
+            await client[method](...args);
+        }
+        expect(fetchSpy).toHaveBeenCalledTimes(calls.length);
+        expect(fetchSpy.mock.calls.some(([url]) => String(url).includes("limit=10&offset=0"))).toBe(true);
+        expect(fetchSpy.mock.calls.some(([url]) => String(url).includes("runtime=runtime&profile=profile&policy_epoch=epoch"))).toBe(true);
+        expect(fetchSpy.mock.calls.every(([, init]) => init.headers.Authorization === "Bearer token")).toBe(true);
+        expect(fetchSpy.mock.calls.every(([, init]) => init.headers["X-Helm-Tenant-ID"] === "tenant-a")).toBe(true);
+    });
+    it("extracts governance headers and default values", async () => {
+        fetchSpy.mockResolvedValueOnce(jsonResponse({ id: "chatcmpl", choices: [] }, 200, {
+            "X-Helm-Receipt-ID": "r1",
+            "X-Helm-Status": "ALLOW",
+            "X-Helm-Output-Hash": "oh",
+            "X-Helm-Lamport-Clock": "9",
+            "X-Helm-Reason-Code": "ALLOW",
+            "X-Helm-Decision-ID": "d1",
+            "X-Helm-ProofGraph-Node": "pg",
+            "X-Helm-Signature": "sig",
+            "X-Helm-Tool-Calls": "2",
+        }));
+        await expect(client.chatCompletionsWithReceipt({ model: "gpt", messages: [] })).resolves.toMatchObject({
+            governance: { receiptId: "r1", lamportClock: 9, toolCalls: 2 },
+        });
+        fetchSpy.mockResolvedValueOnce(jsonResponse({ id: "chatcmpl", choices: [] }));
+        await expect(client.chatCompletionsWithReceipt({ model: "gpt", messages: [] })).resolves.toMatchObject({
+            governance: { receiptId: "", lamportClock: 0, toolCalls: 0 },
+        });
+    });
+    it("covers binary and form endpoints including error branches", async () => {
+        const blob = new Blob(["bundle"]);
+        fetchSpy.mockResolvedValueOnce(new Response("tgz", { status: 200 }));
+        await expect(client.exportEvidence("session-1")).resolves.toBeInstanceOf(Blob);
+        fetchSpy.mockResolvedValueOnce(helmError(400));
+        await expect(client.exportEvidence()).rejects.toThrow(HelmApiError);
+        fetchSpy.mockResolvedValueOnce(jsonResponse({ verdict: "PASS" }));
+        await expect(client.verifyEvidence(blob)).resolves.toMatchObject({ verdict: "PASS" });
+        fetchSpy.mockResolvedValueOnce(helmError(422));
+        await expect(client.verifyEvidence(blob)).rejects.toThrow(HelmApiError);
+        fetchSpy.mockResolvedValueOnce(jsonResponse({ verdict: "PASS" }));
+        await expect(client.replayVerify(blob)).resolves.toMatchObject({ verdict: "PASS" });
+        fetchSpy.mockResolvedValueOnce(helmError(422));
+        await expect(client.replayVerify(blob)).rejects.toThrow(HelmApiError);
+    });
+    it("throws for JSON request and receipt failures", async () => {
+        fetchSpy.mockResolvedValueOnce(helmError(403));
+        await expect(client.health()).rejects.toThrow(HelmApiError);
+        fetchSpy.mockResolvedValueOnce(helmError(403));
+        await expect(client.chatCompletionsWithReceipt({ model: "gpt", messages: [] })).rejects.toThrow(HelmApiError);
+    });
+});

package/dist/generated-coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generated-coverage.test.js

@@ -0,0 +1,284 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import * as openapiTypes from "./types.gen.js";
+import * as durationProto from "./generated/google/protobuf/duration.js";
+import * as timestampProto from "./generated/google/protobuf/timestamp.js";
+import * as authorityProto from "./generated/helm/authority/v1/authority.js";
+import * as effectsProto from "./generated/helm/effects/v1/effects.js";
+import * as interventionProto from "./generated/helm/intervention/v1/intervention.js";
+import * as kernelProto from "./generated/helm/kernel/v1/helm.js";
+import * as truthProto from "./generated/helm/truth/v1/truth.js";
+const typeSource = readFileSync(new URL("types.gen.ts", import.meta.url), "utf8");
+function requiredFieldsFor(modelName) {
+    const match = typeSource.match(instanceOfPattern(modelName));
+    if (!match)
+        return [];
+    return [...match[0].matchAll(/if \(!\('([^']+)' in value\)\) return false;/g)].map((field) => field[1]);
+}
+function instanceOfPattern(modelName) {
+    return new RegExp(`export function instanceOf${modelName}[^]*?\\n}\\n\\nexport function ${modelName}FromJSON`);
+}
+function converterBodyFor(modelName) {
+    const match = typeSource.match(new RegExp(`export function ${modelName}FromJSONTyped[^]*?\\n}\\n\\nexport function ${modelName}ToJSON`));
+    return match?.[0] ?? "";
+}
+function normalizeJson(value) {
+    if (value == null)
+        return value;
+    if (Array.isArray(value))
+        return value.map(normalizeJson);
+    if (typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalizeJson(item)]));
+}
+function sourceValueFor(modelName, field, expression, stack) {
+    const arrayMatch = expression.match(/json\['[^']+'\] as Array<any>\)\.map\(([^)]+)FromJSON\)/);
+    if (arrayMatch) {
+        return [sourceSampleForModel(arrayMatch[1], false, stack)];
+    }
+    const nestedMatch = expression.match(/([A-Za-z0-9_]+)FromJSON\(json\['[^']+'\]\)/);
+    if (nestedMatch) {
+        return sourceSampleForModel(nestedMatch[1], false, stack);
+    }
+    if (expression.includes("new Date"))
+        return "2026-01-01T00:00:00.000Z";
+    if (expression.includes("bytesFromBase64"))
+        return "aGVsbQ==";
+    if (/count|number|lamport|clock|port|limit|size|ttl|bytes|cpu|memory|score|confidence|version/i.test(field))
+        return 1;
+    if (/enabled|allow|deny|active|valid|ok|success|required|experimental|hosted|launchable|verified/i.test(field))
+        return true;
+    return "sample";
+}
+function sourceSampleForModel(modelName, requiredOnly = false, stack = []) {
+    if (stack.includes(modelName))
+        return {};
+    if (modelName === "MCPJSONRPCRequestId" || modelName === "MCPJSONRPCResponseId")
+        return 1;
+    if (modelName === "MCPToolCallResponseResult")
+        return { content: "sample" };
+    if (modelName === "SandboxGrantInspection")
+        return [];
+    const body = converterBodyFor(modelName);
+    const required = new Set(requiredFieldsFor(modelName));
+    const sample = {};
+    for (const match of body.matchAll(/'([^']+)': ([^\n]+),/g)) {
+        const [, field, expression] = match;
+        if (requiredOnly && required.size > 0 && !required.has(field))
+            continue;
+        sample[field] = sourceValueFor(modelName, field, expression, [...stack, modelName]);
+    }
+    return sample;
+}
+function sampleForModel(modelName, requiredOnly = false) {
+    if (modelName === "MCPJSONRPCRequestId" || modelName === "MCPJSONRPCResponseId") {
+        return 1;
+    }
+    if (modelName === "MCPToolCallResponseResult") {
+        return { content: "sample" };
+    }
+    if (modelName === "SandboxGrantInspection") {
+        return [];
+    }
+    return sourceSampleForModel(modelName, requiredOnly);
+}
+function modelNames() {
+    return [...typeSource.matchAll(/^export function ([A-Za-z0-9_]+)FromJSON\(/gm)]
+        .map((match) => match[1])
+        .filter((name) => typeof openapiTypes[`${name}FromJSON`] === "function")
+        .sort();
+}
+function expectNoThrow(fn) {
+    try {
+        fn();
+    }
+    catch (error) {
+        expect(error).toBeUndefined();
+    }
+}
+describe("generated OpenAPI TypeScript helpers", () => {
+    it("exercises every generated JSON converter and interface guard", () => {
+        const exercised = [];
+        for (const name of modelNames()) {
+            const fromJSON = openapiTypes[`${name}FromJSON`];
+            const fromJSONTyped = openapiTypes[`${name}FromJSONTyped`];
+            const toJSON = openapiTypes[`${name}ToJSON`];
+            const instanceOf = openapiTypes[`instanceOf${name}`];
+            expect(fromJSON(null)).toBeNull();
+            expectNoThrow(() => fromJSONTyped(null, true));
+            if (toJSON) {
+                expect(toJSON(null)).toBeNull();
+                expect(toJSON(undefined)).toBeUndefined();
+            }
+            for (const requiredOnly of [false, true]) {
+                const sample = sampleForModel(name, requiredOnly);
+                const converted = fromJSON(sample);
+                expectNoThrow(() => fromJSONTyped(sample, requiredOnly));
+                if (toJSON) {
+                    expectNoThrow(() => toJSON(converted));
+                }
+            }
+            if (name === "SandboxGrantInspection") {
+                const grant = sampleForModel("SandboxGrant");
+                const converted = fromJSON(grant);
+                expectNoThrow(() => fromJSONTyped(grant, true));
+                expectNoThrow(() => toJSON(converted));
+            }
+            if (instanceOf) {
+                const required = requiredFieldsFor(name);
+                const full = { ...sampleForModel(name), ...Object.fromEntries(required.map((field) => [field, "sample"])) };
+                expect(instanceOf(full)).toBe(true);
+                for (const field of required) {
+                    const missing = { ...full };
+                    delete missing[field];
+                    expect(instanceOf(missing)).toBe(false);
+                }
+            }
+            exercised.push(name);
+        }
+        expect(exercised.length).toBeGreaterThan(150);
+    });
+});
+const protoModules = [
+    { exports: durationProto, source: readFileSync(new URL("generated/google/protobuf/duration.ts", import.meta.url), "utf8") },
+    { exports: timestampProto, source: readFileSync(new URL("generated/google/protobuf/timestamp.ts", import.meta.url), "utf8") },
+    { exports: authorityProto, source: readFileSync(new URL("generated/helm/authority/v1/authority.ts", import.meta.url), "utf8") },
+    { exports: effectsProto, source: readFileSync(new URL("generated/helm/effects/v1/effects.ts", import.meta.url), "utf8") },
+    { exports: interventionProto, source: readFileSync(new URL("generated/helm/intervention/v1/intervention.ts", import.meta.url), "utf8") },
+    { exports: kernelProto, source: readFileSync(new URL("generated/helm/kernel/v1/helm.ts", import.meta.url), "utf8") },
+    { exports: truthProto, source: readFileSync(new URL("generated/helm/truth/v1/truth.ts", import.meta.url), "utf8") },
+];
+function isMessageFns(value) {
+    return typeof value === "object"
+        && value !== null
+        && ["encode", "decode", "fromJSON", "toJSON", "create", "fromPartial"].every((key) => typeof value[key] === "function");
+}
+function messageBlock(source, messageName) {
+    const match = source.match(new RegExp(`export const ${messageName}: MessageFns<${messageName}> = \\{[^]*?\\n\\};`));
+    return match?.[0] ?? "";
+}
+function nestedRepeatedFields(source, messageName) {
+    return [...messageBlock(source, messageName).matchAll(/message\.(\w+) = object\.\1\?\.map\(\(e\) => ([A-Za-z0-9_]+)\.fromPartial\(e\)\) \|\| \[\];/g)]
+        .map((match) => [match[1], match[2]]);
+}
+function primitiveRepeatedFields(source, messageName) {
+    return [...messageBlock(source, messageName).matchAll(/message\.(\w+) = object\.\1\?\.map\(\(e\) => e\) \|\| \[\];/g)]
+        .map((match) => match[1]);
+}
+function nestedOptionalFields(source, messageName) {
+    return [...messageBlock(source, messageName).matchAll(/message\.(\w+) = \(object\.\1 !== undefined && object\.\1 !== null\)\s+\? ([A-Za-z0-9_]+)\.fromPartial/g)]
+        .map((match) => [match[1], match[2]]);
+}
+function nonDefaultValueFor(key, value) {
+    if (typeof value === "string")
+        return `${key}-sample`;
+    if (typeof value === "number")
+        return 1;
+    if (typeof value === "boolean")
+        return true;
+    if (value instanceof Uint8Array)
+        return new Uint8Array([1, 2, 3]);
+    if (Array.isArray(value))
+        return ["sample"];
+    if (value === undefined && /(time|date|deadline|expires|issued|created|updated|completed|timestamp)/i.test(key)) {
+        return new Date("2026-01-01T00:00:00.000Z");
+    }
+    if (value && typeof value === "object")
+        return { key: "value" };
+    return value;
+}
+function populatedMessage(name, fns, moduleExports, source, stack = []) {
+    const base = fns.create();
+    const populated = Object.fromEntries(Object.entries(base).map(([key, value]) => [key, nonDefaultValueFor(key, value)]));
+    for (const [field, nestedName] of nestedOptionalFields(source, name)) {
+        const nested = moduleExports[nestedName];
+        if (isMessageFns(nested) && !stack.includes(nestedName)) {
+            populated[field] = populatedMessage(nestedName, nested, moduleExports, source, [...stack, name]);
+        }
+    }
+    for (const [field, nestedName] of nestedRepeatedFields(source, name)) {
+        const nested = moduleExports[nestedName];
+        if (isMessageFns(nested) && !stack.includes(nestedName)) {
+            populated[field] = [populatedMessage(nestedName, nested, moduleExports, source, [...stack, name])];
+        }
+    }
+    for (const field of primitiveRepeatedFields(source, name)) {
+        populated[field] = ["sample"];
+    }
+    return populated;
+}
+function snakeCaseKeys(value) {
+    if (value == null || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array)
+        return value;
+    if (Array.isArray(value))
+        return value.map(snakeCaseKeys);
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`),
+        snakeCaseKeys(item),
+    ]));
+}
+function serviceMessageName(fn) {
+    return String(fn).match(/([A-Za-z0-9_]+)\.encode/)?.[1];
+}
+describe("generated protobuf TypeScript helpers", () => {
+    it("exercises message function tables and enum JSON helpers", () => {
+        let messageCount = 0;
+        let enumHelperCount = 0;
+        for (const { exports: moduleExports, source } of protoModules) {
+            for (const [name, value] of Object.entries(moduleExports)) {
+                if (isMessageFns(value)) {
+                    const empty = value.create();
+                    const populated = populatedMessage(name, value, moduleExports, source);
+                    const emptyBytes = value.encode(empty).finish();
+                    const fullBytes = value.encode(populated).finish();
+                    expectNoThrow(() => value.decode(emptyBytes));
+                    expectNoThrow(() => value.decode(fullBytes));
+                    expectNoThrow(() => value.decode(fullBytes, fullBytes.length));
+                    expectNoThrow(() => value.fromJSON({}));
+                    expectNoThrow(() => value.fromJSON(value.toJSON(populated)));
+                    expectNoThrow(() => value.fromJSON(snakeCaseKeys(value.toJSON(populated))));
+                    expectNoThrow(() => value.toJSON(empty));
+                    expectNoThrow(() => value.toJSON(populated));
+                    expectNoThrow(() => value.fromPartial({}));
+                    expectNoThrow(() => value.fromPartial(populated));
+                    messageCount += 1;
+                    continue;
+                }
+                if (name.endsWith("FromJSON") && typeof value === "function") {
+                    const enumName = name.slice(0, -"FromJSON".length);
+                    const toJSON = moduleExports[`${enumName}ToJSON`];
+                    for (const candidate of [0, 1, -1, "UNRECOGNIZED", "not-a-real-value"]) {
+                        const converted = value(candidate);
+                        if (toJSON) {
+                            expect(typeof toJSON(converted)).toBe("string");
+                        }
+                    }
+                    enumHelperCount += 1;
+                }
+                if (typeof value === "object" && value !== null && !isMessageFns(value)) {
+                    for (const descriptor of Object.values(value)) {
+                        if (descriptor
+                            && typeof descriptor.requestSerialize === "function"
+                            && typeof descriptor.requestDeserialize === "function"
+                            && typeof descriptor.responseSerialize === "function"
+                            && typeof descriptor.responseDeserialize === "function") {
+                            const requestName = serviceMessageName(descriptor.requestSerialize);
+                            const responseName = serviceMessageName(descriptor.responseSerialize);
+                            const exportsByName = moduleExports;
+                            const requestFns = requestName ? exportsByName[requestName] : undefined;
+                            const responseFns = responseName ? exportsByName[responseName] : undefined;
+                            if (isMessageFns(requestFns) && isMessageFns(responseFns)) {
+                                const requestBytes = descriptor.requestSerialize(populatedMessage(requestName, requestFns, moduleExports, source));
+                                const responseBytes = descriptor.responseSerialize(populatedMessage(responseName, responseFns, moduleExports, source));
+                                expectNoThrow(() => descriptor.requestDeserialize(requestBytes));
+                                expectNoThrow(() => descriptor.responseDeserialize(responseBytes));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        expect(messageCount).toBeGreaterThan(30);
+        expect(enumHelperCount).toBeGreaterThan(5);
+    });
+});