@wildo-ai/wildo-module-client 1.1.1

package/src/__tests__/registry-lockfile.service.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Phase 0.5 sanity tests for `RegistryLockfileService`.
+ *
+ * These pin the cross-section preservation invariants Phase 1 must
+ * inherit when it graduates the locking + atomic-write primitives
+ * into `platform-config-lib`. The test runs against a per-test
+ * tmpdir; the real `wildo-saas.lock.json` is never touched.
+ */
+
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { RegistryLockfileService } from '../services/registry-lockfile.service';
+// L6 (third-pass review): the symbol is no longer re-exported from
+// `wildo-module-client`; import it directly from `platform-config-lib`.
+import { WILDO_SAAS_LOCK_RELATIVE_PATH } from '@wildo-ai/platform-config-lib';
+
+let saasRoot: string;
+
+beforeEach(async () => {
+  saasRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'wildo-module-client-spec-'));
+});
+
+afterEach(async () => {
+  await fs.rm(saasRoot, { recursive: true, force: true });
+});
+
+describe('RegistryLockfileService', () => {
+  it('returns an empty modules section when the lockfile does not exist', async () => {
+    const section = await RegistryLockfileService.read(saasRoot);
+    expect(section.installed).toEqual({});
+  });
+
+  it('writes a fresh envelope with only sections.modules populated', async () => {
+    await RegistryLockfileService.upsertEntry(saasRoot, {
+      moduleId: 'acme/billing',
+      registryId: 'wildo',
+      registryUrl: 'https://registry.wildo.ai',
+      domain: 'acme',
+      version: '1.2.3',
+      artifactDigest: 'sha256:' + 'a'.repeat(64),
+      installedAt: '2026-05-05T12:00:00.000Z',
+      files: ['shared-lib/src/modules/acme-billing/index.ts'],
+      source: 'install',
+    });
+    const raw = await fs.readFile(path.join(saasRoot, WILDO_SAAS_LOCK_RELATIVE_PATH), 'utf8');
+    const env = JSON.parse(raw) as { schemaVersion: number; sections: Record<string, unknown> };
+    expect(env.schemaVersion).toBe(2);
+    expect((env.sections.modules as { installed: Record<string, unknown> }).installed['acme/billing'])
+      .toMatchObject({ moduleId: 'acme/billing', version: '1.2.3' });
+    expect(env.sections.providers).toBeUndefined();
+  });
+
+  it('preserves sections.providers and unknown sections across module-section mutation', async () => {
+    const lockPath = path.join(saasRoot, WILDO_SAAS_LOCK_RELATIVE_PATH);
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
+    const original = {
+      schemaVersion: 2 as const,
+      generatedAt: '2026-05-05T11:00:00.000Z',
+      sections: {
+        providers: {
+          runtimeScopes: {
+            backend: {
+              resend: {
+                ref: 'resend',
+                digest: 'sha256:fixture',
+                engineCapabilities: ['EMAIL_TRANSACTIONAL'],
+                providerCapabilities: ['EMAIL_TRANSACTIONAL'],
+                protocols: ['EMAIL_PROVIDER'],
+                secretsContractDigest: 'sha256:contract',
+              },
+            },
+          },
+        },
+        i18n: {
+          sectionVersion: 1,
+          units: { welcome: { inputSha: 'abc' } },
+        },
+        future: { whatever: ['preserved'] },
+      },
+    };
+    await fs.writeFile(lockPath, JSON.stringify(original, null, 2), 'utf8');
+
+    await RegistryLockfileService.mutate(saasRoot, (current) => ({
+      ...current,
+      installed: {
+        ...current.installed,
+        'acme/billing': {
+          moduleId: 'acme/billing',
+          registryId: 'wildo',
+          registryUrl: 'https://registry.wildo.ai',
+          domain: 'acme',
+          version: '2.0.0',
+          artifactDigest: 'sha256:' + 'b'.repeat(64),
+          installedAt: '2026-05-05T12:00:00.000Z',
+          files: [],
+          source: 'install',
+        },
+      },
+    }));
+
+    const after = JSON.parse(await fs.readFile(lockPath, 'utf8'));
+    expect(after.sections.providers).toEqual(original.sections.providers);
+    expect(after.sections.i18n).toEqual(original.sections.i18n);
+    expect(after.sections.future).toEqual(original.sections.future);
+    expect(after.sections.modules.installed['acme/billing'].version).toBe('2.0.0');
+    // generatedAt MUST be refreshed.
+    expect(after.generatedAt).not.toBe(original.generatedAt);
+  });
+
+  it('rejects an invalid module entry with a Zod parse error and never writes the section', async () => {
+    const lockPath = path.join(saasRoot, WILDO_SAAS_LOCK_RELATIVE_PATH);
+    await expect(
+      RegistryLockfileService.mutate(saasRoot, () => ({
+        installed: {
+          'acme/billing': {
+            // missing required fields on purpose
+            moduleId: 'acme/billing',
+          } as never,
+        },
+      })),
+    ).rejects.toThrow();
+    // The shared library pre-creates an empty envelope before locking
+    // (proper-lockfile requires the file to exist), so the FILE may
+    // exist — but `sections.modules` MUST NOT contain the invalid
+    // entry, and the original section (if any) is unchanged.
+    const raw = await fs.readFile(lockPath, 'utf8').catch(() => null);
+    if (raw !== null) {
+      const env = JSON.parse(raw) as { sections: { modules?: { installed?: Record<string, unknown> } } };
+      expect(env.sections.modules?.installed?.['acme/billing']).toBeUndefined();
+    }
+  });
+});

package/src/__tests__/registry-server-client.test.ts

@@ -0,0 +1,312 @@
+/**
+ * Phase 2 tests for `RegistryServerClient` real methods.
+ *
+ * We use Node's `node:http` to stand up a tiny in-process server
+ * so each route's wire shape, error classification, and digest
+ * verification can be exercised without depending on Phase 3's
+ * `platform-module-registry`.
+ */
+
+import { createServer, type Server } from 'node:http';
+import { createHash } from 'node:crypto';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  RegistryArtifactIntegrityMismatchError,
+  RegistryAuthForbiddenError,
+  RegistryAuthRequiredError,
+  RegistryMalformedPayloadError,
+  RegistryModuleNotFoundError,
+  RegistryVersionNotFoundError,
+} from '@wildo-ai/platform-config-lib';
+import { RegistryServerClient } from '../services/registry-server-client';
+
+interface TestServer {
+  baseUrl: string;
+  close: () => Promise<void>;
+  server: Server;
+}
+
+async function startServer(
+  handler: (
+    req: import('node:http').IncomingMessage,
+    res: import('node:http').ServerResponse,
+  ) => void | Promise<void>,
+): Promise<TestServer> {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      Promise.resolve(handler(req, res)).catch((err) => {
+        res.writeHead(500);
+        res.end(String(err));
+      });
+    });
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address();
+      if (!addr || typeof addr === 'string') throw new Error('no addr');
+      resolve({
+        baseUrl: `http://127.0.0.1:${addr.port}`,
+        close: () => new Promise((r) => server.close(() => r())),
+        server,
+      });
+    });
+  });
+}
+
+let svc: TestServer | null = null;
+
+afterEach(async () => {
+  if (svc) {
+    await svc.close();
+    svc = null;
+  }
+});
+
+describe('RegistryServerClient.ping', () => {
+  it('hits /health (no /v1 prefix — framework auto-mounts the engine HealthController) and returns true on 200', async () => {
+    let observedPath: string | undefined;
+    svc = await startServer((req, res) => {
+      observedPath = req.url;
+      if (req.url === '/health') {
+        res.writeHead(200);
+        res.end('ok');
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    expect(await RegistryServerClient.ping({ baseUrl: svc.baseUrl })).toBe(true);
+    // Wire-shape pin: a future re-prefixing of `ping()` should fail
+    // CI explicitly rather than silently re-introducing the /v1
+    // mismatch the second-pass review surfaced as a RED test.
+    expect(observedPath).toBe('/health');
+  });
+
+  it('returns false on network failure', async () => {
+    expect(await RegistryServerClient.ping({ baseUrl: 'http://127.0.0.1:1' })).toBe(false);
+  });
+});
+
+describe('RegistryServerClient.resolve', () => {
+  it('returns version + digest on success', async () => {
+    const VALID = 'sha256:' + 'a'.repeat(64);
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ version: '1.2.3', artifactDigest: VALID }));
+    });
+    const result = await RegistryServerClient.resolve(
+      { baseUrl: svc.baseUrl },
+      { domain: 'acme', moduleId: 'acme/billing', range: '^1.0.0' },
+    );
+    expect(result.version).toBe('1.2.3');
+    expect(result.artifactDigest).toBe(VALID);
+  });
+
+  // M8 (third-pass review): pin the wire URL shape so a future
+  // "encode the slash differently" refactor fails CI explicitly. The
+  // server route is `/v1/registry/:domain/modules/:moduleId/resolve`
+  // and a `<scope>/<name>` moduleId (`acme/billing`) is passed
+  // through `encodeURIComponent` → `acme%2Fbilling` so it lands as
+  // ONE path segment. Express's path-to-regexp captures the encoded
+  // segment, and the controller `String(req.params.moduleId)` gets
+  // the decoded `'acme/billing'` back — verified end-to-end here.
+  it('encodes a `<scope>/<name>` moduleId as a single %2F-escaped path segment', async () => {
+    const VALID = 'sha256:' + 'a'.repeat(64);
+    let observedPath: string | undefined;
+    svc = await startServer((req, res) => {
+      observedPath = req.url;
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ version: '1.2.3', artifactDigest: VALID }));
+    });
+    await RegistryServerClient.resolve(
+      { baseUrl: svc.baseUrl },
+      { domain: 'wildo', moduleId: 'acme/billing', range: '^1.0.0' },
+    );
+    expect(observedPath).toBe(
+      '/v1/registry/wildo/modules/acme%2Fbilling/resolve?range=%5E1.0.0',
+    );
+  });
+
+  it('throws RegistryVersionNotFoundError on 404', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(404);
+      res.end();
+    });
+    await expect(
+      RegistryServerClient.resolve(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'missing', range: '^1.0.0' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryVersionNotFoundError);
+  });
+
+  it('throws RegistryAuthRequiredError on 401', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(401);
+      res.end();
+    });
+    await expect(
+      RegistryServerClient.resolve(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'acme/billing', range: '^1.0.0' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryAuthRequiredError);
+  });
+
+  it('throws RegistryAuthForbiddenError on 403', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(403);
+      res.end();
+    });
+    await expect(
+      RegistryServerClient.resolve(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'acme/billing', range: '^1.0.0' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryAuthForbiddenError);
+  });
+});
+
+describe('RegistryServerClient.info', () => {
+  it('returns the JSON body on 200', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          moduleId: 'acme/billing',
+          manifest: { id: 'acme/billing', version: '1.2.3' },
+          versions: [],
+          tags: { latest: '1.2.3' },
+        }),
+      );
+    });
+    const result = await RegistryServerClient.info(
+      { baseUrl: svc.baseUrl },
+      { domain: 'acme', moduleId: 'acme/billing' },
+    );
+    expect(result.moduleId).toBe('acme/billing');
+    expect(result.tags.latest).toBe('1.2.3');
+  });
+
+  it('throws RegistryModuleNotFoundError on 404', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(404);
+      res.end();
+    });
+    await expect(
+      RegistryServerClient.info(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'missing' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryModuleNotFoundError);
+  });
+});
+
+describe('RegistryServerClient.download', () => {
+  it('verifies the integrity digest and returns bytes', async () => {
+    const payload = Buffer.from('artifact-bytes');
+    const expectedDigest = `sha256:${createHash('sha256').update(payload).digest('hex')}`;
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/zip' });
+      res.end(payload);
+    });
+    const result = await RegistryServerClient.download(
+      { baseUrl: svc.baseUrl },
+      {
+        domain: 'acme',
+        moduleId: 'acme/billing',
+        version: '1.2.3',
+        expectedDigest,
+      },
+    );
+    expect(Buffer.from(result.bytes).equals(payload)).toBe(true);
+    expect(result.integrity).toBe(expectedDigest);
+  });
+
+  it('throws RegistryArtifactIntegrityMismatchError on digest mismatch', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(200);
+      res.end('different-bytes');
+    });
+    await expect(
+      RegistryServerClient.download(
+        { baseUrl: svc.baseUrl },
+        {
+          domain: 'acme',
+          moduleId: 'acme/billing',
+          version: '1.2.3',
+          expectedDigest: 'sha256:' + 'a'.repeat(64),
+        },
+      ),
+    ).rejects.toBeInstanceOf(RegistryArtifactIntegrityMismatchError);
+  });
+});
+
+/**
+ * 7th-pass C-M3: regression tests for the 6th-pass `parseJsonOrThrow`
+ * helper. The "misconfigured proxy returns HTML at 2xx" scenario that
+ * motivated the helper had no regression pin until this pass. One
+ * test per affected method covers `resolve`, `info`, `search`.
+ */
+describe('RegistryServerClient — parseJsonOrThrow (malformed 2xx body)', () => {
+  it('resolve() throws RegistryMalformedPayloadError when the server returns HTML at 200', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end('<html>not json</html>');
+    });
+    await expect(
+      RegistryServerClient.resolve(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'acme/billing', range: '^1.0.0' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryMalformedPayloadError);
+  });
+
+  it('info() throws RegistryMalformedPayloadError when the server returns HTML at 200', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end('<html>not json</html>');
+    });
+    await expect(
+      RegistryServerClient.info(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', moduleId: 'acme/billing' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryMalformedPayloadError);
+  });
+
+  it('search() throws RegistryMalformedPayloadError when the server returns HTML at 200', async () => {
+    svc = await startServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end('<html>not json</html>');
+    });
+    await expect(
+      RegistryServerClient.search(
+        { baseUrl: svc.baseUrl },
+        { domain: 'acme', query: 'billing' },
+      ),
+    ).rejects.toBeInstanceOf(RegistryMalformedPayloadError);
+  });
+});
+
+/**
+ * 7th-pass C-M1: `download()` argument-shape violation. Caller passes
+ * a malformed `expectedDigest` — must throw `TypeError` (not Zod's
+ * raw error, not `RegistryError`). Mirrors the precedent in
+ * `module-packager.service.ts > getModuleStagingPaths`.
+ */
+describe('RegistryServerClient.download — malformed expectedDigest (C-M1)', () => {
+  it('throws TypeError when expectedDigest is not a sha256:<64-hex> string', async () => {
+    // No server needed — the digest validation runs BEFORE the
+    // network call.
+    await expect(
+      RegistryServerClient.download(
+        { baseUrl: 'http://localhost:1' },
+        {
+          domain: 'acme',
+          moduleId: 'acme/billing',
+          version: '1.2.3',
+          expectedDigest: 'not-a-valid-digest',
+        },
+      ),
+    ).rejects.toBeInstanceOf(TypeError);
+  });
+});

package/src/index.ts

@@ -0,0 +1,18 @@
+/**
+ * `@wildo-ai/wildo-module-client` — runtime services for the Wildo
+ * module-registry workstream (KD-3).
+ *
+ * Phase 0.5 surface:
+ *   - `RegistryServerClient` — HTTP client for the registry server.
+ *   - `RegistryCompanionClient` — HTTP client for the dev companion.
+ *   - `RegistryLockfileService` — section-scoped `sections.modules`
+ *     reader/writer.
+ *   - `runProviderMaterializationHook` — post-mutation no-op hook
+ *     that delegates to `wildo config sync --domain config`.
+ *
+ * Phase 1+ adds `ModulePackagerService`, `ModuleAdopterService`,
+ * `LockfileRepairService`, and the real (locked + atomic) lockfile
+ * mutation surface.
+ */
+
+export * from './services';

package/src/services/_http-client.ts

@@ -0,0 +1,91 @@
+/**
+ * Internal HTTP client utilities shared by `RegistryServerClient`
+ * and `RegistryCompanionClient`.
+ *
+ * Both clients want the same primitives:
+ *   - `joinUrl(base, path)` — single-source-of-truth path joiner
+ *     that tolerates leading/trailing slashes;
+ *   - `fetchWithTimeout(url, init, timeoutMs)` — abort-on-timeout
+ *     wrapper that converts `AbortError`/`TimeoutError` into a
+ *     uniform diagnostic message;
+ *   - `fetchJsonOk(...)` — convenience for liveness probes that
+ *     want a boolean answer.
+ *
+ * The leading underscore signals "package-internal" — these are
+ * intentionally NOT re-exported from `services/index.ts`. Phase 2
+ * services that need fancier HTTP (multipart upload, streaming
+ * download) extend this file rather than copy the primitives.
+ */
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+export function joinUrl(base: string, path: string): string {
+  const normalized = path.startsWith('/') ? path : `/${path}`;
+  return `${base.replace(/\/$/, '')}${normalized}`;
+}
+
+export interface FetchWithTimeoutInit extends RequestInit {
+  timeoutMs?: number;
+  /** Used in the diagnostic timeout message (e.g. "Registry", "Companion registry"). */
+  diagnosticLabel?: string;
+}
+
+export async function fetchWithTimeout(
+  url: string,
+  init: FetchWithTimeoutInit = {},
+): Promise<Response> {
+  const timeoutMs = init.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const label = init.diagnosticLabel ?? 'HTTP';
+  const signal = AbortSignal.timeout(timeoutMs);
+  // Strip the wrapper-only fields before forwarding to `fetch`. The
+  // `_` names are conventional unused-binding markers.
+  //
+  // 6th-pass M1 — tsconfig premise (corrected): the wider repo's
+  // `engine/tsconfig.common.json` currently sets both `noUnusedLocals`
+  // and `noUnusedParameters` to `false`, so any unused binding (with
+  // or without `_` prefix) compiles clean today. If either flag is
+  // ever flipped to `true`, TypeScript's underscore-prefix convention
+  // applies to parameters reliably and to destructured `let`/`const`
+  // bindings depending on TS version + setting — so the `_` prefix
+  // here is a defensive signal of "intentional discard" should that
+  // happen. Today it's purely cosmetic.
+  const { timeoutMs: _timeoutMs, diagnosticLabel: _diagnosticLabel, ...rest } = init;
+  try {
+    return await fetch(url, { ...rest, signal });
+  } catch (err) {
+    if (err instanceof Error && (err.name === 'AbortError' || err.name === 'TimeoutError')) {
+      throw new Error(`${label} request timed out after ${timeoutMs}ms (${url})`);
+    }
+    throw err;
+  }
+}
+
+/**
+ * Throws on non-2xx; returns the Response otherwise.
+ *
+ * C-L2 (4th-pass review) waiver: this helper deliberately throws
+ * bare `Error` and is NOT part of the typed `RegistryError`
+ * vocabulary. It exists for liveness probes (`ping()`) that wrap
+ * the call in their own try/catch and convert any thrown exception
+ * to `false`. Future callers MUST do the same — if a caller wants
+ * to surface a typed error to the user, they should not use
+ * `fetchJsonOk` and should call `fetchWithTimeout` directly +
+ * inspect `res.ok` themselves to throw the right
+ * `RegistryUnexpectedStatusError` / `RegistryAuthRequiredError` /
+ * etc. variant.
+ *
+ * @internal — internal lib helper, not re-exported from the
+ * package root.
+ */
+export async function fetchJsonOk(
+  url: string,
+  init: FetchWithTimeoutInit = {},
+): Promise<Response> {
+  const res = await fetchWithTimeout(url, init);
+  if (!res.ok) {
+    throw new Error(
+      `${init.diagnosticLabel ?? 'HTTP'} request rejected (${res.status} ${res.statusText}) at ${url}`,
+    );
+  }
+  return res;
+}

package/src/services/_zod-issue-formatting.ts

@@ -0,0 +1,50 @@
+import type { ZodError } from 'zod';
+
+/**
+ * Package-internal mirror of `summarizeZodIssues` from `@wildo-ai/saas-models`,
+ * which is the canonical authority every other Wildo surface delegates to.
+ *
+ * zod-issue-formatter-mirror: engine/saas-models/src/errors/zod-issue-formatting.shared.utils.ts
+ *
+ * Why a mirror rather than an import: this package declares exactly ONE
+ * workspace dependency (`@wildo-ai/platform-config-lib`) plus a `zod` peer.
+ * Importing `saas-models` would pull its decorator-bound schema tree into a
+ * lean registry client to save a handful of lines — a bad trade. The boundary
+ * is the reason for the duplication; keep the RENDERING identical, and mirror
+ * any change to the canonical helper's path / root-label / overflow semantics
+ * here.
+ *
+ * The marker above is not decoration — `pnpm check:zod-issue-formatter-mirror`
+ * discovers this file by it and fails if the constants below drift from the
+ * canonical source it names. If the dependency constraint that justifies this
+ * mirror ever stops holding, delete the file and import the canonical formatter
+ * rather than keeping a mirror nobody needs.
+ *
+ * Within this package this is the single source: `registry-server-client.ts`
+ * and `lockfile-repair.service.ts` both call it instead of re-inlining the
+ * `.slice(0, 5).map(...).join('; ')` chain.
+ */
+
+/** Label for an issue whose `path` is empty — the value itself failed. */
+const ROOT_ISSUE_PATH_LABEL = '<root>';
+
+/** Issue cap; a malformed payload can fail on hundreds of paths. */
+const ISSUE_RENDER_LIMIT = 5;
+
+/**
+ * Render a `ZodError` as one operator-readable line —
+ * `path: message; path: message; …` — bounded at {@link ISSUE_RENDER_LIMIT}
+ * with an explicit `(+N more)` so truncation is never silent.
+ *
+ * Used as the `detail` on `RegistryMalformedPayloadError` and on lockfile
+ * repair findings. The raw `error.message` in Zod 4 is the JSON-stringified
+ * issues array — verbose, multi-line, and unreadable in CLI / SIEM output.
+ */
+export function formatZodIssuesAsSingleLine(error: ZodError): string {
+  const rendered = error.issues
+    .slice(0, ISSUE_RENDER_LIMIT)
+    .map((issue) => `${issue.path.join('.') || ROOT_ISSUE_PATH_LABEL}: ${issue.message}`);
+  const omitted = error.issues.length - ISSUE_RENDER_LIMIT;
+  if (omitted > 0) rendered.push(`(+${omitted} more)`);
+  return rendered.join('; ');
+}

package/src/services/index.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './registry-server-client';
+export * from './registry-companion-client';
+export * from './registry-lockfile.service';
+export * from './provider-sync-runner';
+export * from './provider-materialization-hook';
+export * from './module-packager.service';
+export * from './module-adopter.service';
+export * from './lockfile-repair.service';