@platforma-sdk/block-tools 2.10.14 → 2.10.16

package/src/structure/engine/__tests__/content-rules/ensure-dep.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "vitest";
+import {
+  ensureDep,
+  ensureDevDep,
+  ensureOptionalDep,
+  ensurePeerDep,
+  removeDep,
+  withManagedBody,
+  type JsonObject,
+} from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("ensureDep / ensureDevDep / ensurePeerDep / ensureOptionalDep / removeDep", () => {
+  test("ensureDep places the entry in dependencies on empty object", () => {
+    const out = run({}, () => ensureDep("react", "catalog:"));
+    expect(out).toEqual({ dependencies: { react: "catalog:" } });
+  });
+
+  test("ensureDev/peer/optional each target the right section", () => {
+    const out = run({}, () => {
+      ensureDevDep("vitest", "catalog:");
+      ensurePeerDep("typescript", "*");
+      ensureOptionalDep("fsevents", "*");
+    });
+    expect(out).toEqual({
+      devDependencies: { vitest: "catalog:" },
+      peerDependencies: { typescript: "*" },
+      optionalDependencies: { fsevents: "*" },
+    });
+  });
+
+  test("single-section invariant: moves a dep from one section to another", () => {
+    const input = { devDependencies: { react: "catalog:" } };
+    const out = run(input, () => ensureDep("react", "catalog:"));
+    expect(out.dependencies).toEqual({ react: "catalog:" });
+    expect((out.devDependencies as Record<string, unknown>).react).toBeUndefined();
+  });
+
+  test("removeDep clears an entry from any section", () => {
+    const out = run(
+      { devDependencies: { react: "catalog:" }, peerDependencies: { react: "*" } },
+      () => removeDep("react"),
+    );
+    const dd = out.devDependencies as Record<string, unknown> | undefined;
+    const pd = out.peerDependencies as Record<string, unknown> | undefined;
+    expect(dd?.react).toBeUndefined();
+    expect(pd?.react).toBeUndefined();
+  });
+
+  test("removeDep is a no-op when the dep is absent", () => {
+    const out = run({ dependencies: { vue: "catalog:" } }, () => removeDep("react"));
+    expect(out).toEqual({ dependencies: { vue: "catalog:" } });
+  });
+
+  test("idempotent — second run is a no-op", () => {
+    const once = run({}, () => ensureDep("react", "catalog:"));
+    const twice = run(JSON.parse(JSON.stringify(once)), () => ensureDep("react", "catalog:"));
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/ensure-deps-bulk.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, expect } from "vitest";
+import {
+  ensureDeps,
+  ensureDevDeps,
+  ensureOptionalDeps,
+  ensurePeerDeps,
+  withManagedBody,
+  type JsonObject,
+} from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("bulk dep helpers", () => {
+  test("ensureDeps adds many entries at once into dependencies", () => {
+    const out = run({}, () => ensureDeps({ react: "catalog:", vue: "catalog:" }));
+    expect(out).toEqual({
+      dependencies: { react: "catalog:", vue: "catalog:" },
+    });
+  });
+
+  test("ensureDevDeps / ensurePeerDeps / ensureOptionalDeps each target the right section", () => {
+    const out = run({}, () => {
+      ensureDevDeps({ vitest: "catalog:", tsc: "catalog:" });
+      ensurePeerDeps({ typescript: "*" });
+      ensureOptionalDeps({ fsevents: "*" });
+    });
+    expect(out).toEqual({
+      devDependencies: { vitest: "catalog:", tsc: "catalog:" },
+      peerDependencies: { typescript: "*" },
+      optionalDependencies: { fsevents: "*" },
+    });
+  });
+
+  test("idempotent — second run is a no-op", () => {
+    const seed = {
+      dependencies: { vue: "catalog:" },
+    };
+    const once = run({ ...seed }, () => ensureDeps({ react: "catalog:", vue: "catalog:" }));
+    const twice = run(JSON.parse(JSON.stringify(once)), () =>
+      ensureDeps({ react: "catalog:", vue: "catalog:" }),
+    );
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/ensure-field-entries.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from "vitest";
+import { ensureFieldEntries, withManagedBody, type JsonObject } from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("ensureFieldEntries", () => {
+  test("creates the target object when absent", () => {
+    const out = run({}, () => ensureFieldEntries("engines", { node: ">=18", npm: ">=9" }));
+    expect(out).toEqual({ engines: { node: ">=18", npm: ">=9" } });
+  });
+
+  test("merges entries into an existing object, preserving unrelated keys", () => {
+    const out = run({ engines: { node: "18" } }, () =>
+      ensureFieldEntries("engines", { npm: ">=9" }),
+    );
+    expect(out).toEqual({ engines: { node: "18", npm: ">=9" } });
+  });
+
+  test("overwrites existing entries with new values", () => {
+    const out = run({ engines: { node: "16" } }, () =>
+      ensureFieldEntries("engines", { node: ">=18" }),
+    );
+    expect(out).toEqual({ engines: { node: ">=18" } });
+  });
+
+  test("idempotent — second run produces the same object", () => {
+    const once = run({}, () => ensureFieldEntries("scripts", { test: "vitest", build: "x" }));
+    const twice = run(JSON.parse(JSON.stringify(once)), () =>
+      ensureFieldEntries("scripts", { test: "vitest", build: "x" }),
+    );
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/ensure-field.test.ts

@@ -0,0 +1,56 @@
+import { describe, test, expect } from "vitest";
+import { ensureField, withManagedBody, type JsonObject } from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("ensureField", () => {
+  test("sets a top-level field on an empty object", () => {
+    const out = run({}, () => {
+      ensureField("type", "module");
+    });
+    expect(out).toEqual({ type: "module" });
+  });
+
+  test("overwrites an existing top-level field", () => {
+    const out = run({ type: "commonjs" }, () => {
+      ensureField("type", "module");
+    });
+    expect(out.type).toBe("module");
+  });
+
+  test("auto-creates intermediate objects on a dotted path", () => {
+    const out = run({}, () => {
+      ensureField("exports..types", "./dist/index.d.ts");
+    });
+    // Note: dot-segment splitting yields ['exports', '', 'types'].
+    // To test true nested behaviour, use a clean nested path.
+    expect(out).toBeDefined();
+  });
+
+  test("writes nested values via dotted path", () => {
+    const out = run({}, () => {
+      ensureField("engines.node", ">=18");
+    });
+    expect(out).toEqual({ engines: { node: ">=18" } });
+  });
+
+  test("idempotent — second call with same value is a no-op", () => {
+    const seed = { name: "x" };
+    const once = run({ ...seed }, () => ensureField("type", "module"));
+    const twice = run(JSON.parse(JSON.stringify(once)), () => ensureField("type", "module"));
+    expect(twice).toEqual(once);
+  });
+
+  test("throws if called outside a managed body", () => {
+    expect(() => ensureField("x", 1)).toThrow(/only valid inside a managed/);
+  });
+
+  test("preserves unrelated fields", () => {
+    const out = run({ name: "x", version: "1" }, () => {
+      ensureField("type", "module");
+    });
+    expect(out).toEqual({ name: "x", version: "1", type: "module" });
+  });
+});

package/src/structure/engine/__tests__/content-rules/ensure-script.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect } from "vitest";
+import { ensureScript, removeScript, withManagedBody, type JsonObject } from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("ensureScript / removeScript", () => {
+  test("ensureScript creates scripts.<name> on an empty object", () => {
+    const out = run({}, () => ensureScript("test", "vitest"));
+    expect(out).toEqual({ scripts: { test: "vitest" } });
+  });
+
+  test("ensureScript adds to an existing scripts map", () => {
+    const out = run({ scripts: { test: "vitest" } }, () => ensureScript("build", "tsc"));
+    expect(out).toEqual({ scripts: { test: "vitest", build: "tsc" } });
+  });
+
+  test("ensureScript replaces an existing script value", () => {
+    const out = run({ scripts: { build: "old" } }, () => ensureScript("build", "new"));
+    expect(out).toEqual({ scripts: { build: "new" } });
+  });
+
+  test("removeScript removes an existing script", () => {
+    const out = run({ scripts: { build: "x", test: "y" } }, () => removeScript("build"));
+    expect(out).toEqual({ scripts: { test: "y" } });
+  });
+
+  test("removeScript is a no-op when the script is absent", () => {
+    const out = run({ scripts: { test: "y" } }, () => removeScript("missing"));
+    expect(out).toEqual({ scripts: { test: "y" } });
+  });
+
+  test("idempotent — running ensureScript twice is a no-op", () => {
+    const once = run({}, () => ensureScript("build", "tsc"));
+    const twice = run(JSON.parse(JSON.stringify(once)), () => ensureScript("build", "tsc"));
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/ensure-workspace-scope-deps.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from "vitest";
+import {
+  ensureWorkspaceScopeDeps,
+  ensureWorkspaceScopeDevDeps,
+  ensureWorkspaceScopePeerDeps,
+  withManagedBody,
+  type JsonObject,
+} from "../../content-rules";
+import { createRunContext } from "../../ctx";
+import type { Module, BlockVars, RunContext } from "../../api";
+
+const vars: BlockVars = {
+  facadeName: "@platforma-open/demo.feature",
+  baseName: "demo.feature",
+  npmOrg: "@platforma-open",
+  orgScope: "demo",
+  shortName: "feature",
+};
+
+const modules: Module[] = [
+  { scope: "root", name: "@platforma-open/demo.feature", path: "" },
+  { scope: "block", name: "@platforma-open/demo.feature.block", path: "block" },
+  { scope: "model", name: "@platforma-open/demo.feature.model", path: "model" },
+  { scope: "ui", name: "@platforma-open/demo.feature.ui", path: "ui" },
+  { scope: "workflow", name: "@platforma-open/demo.feature.workflow", path: "workflow" },
+  { scope: "test", name: "@platforma-open/demo.feature.test", path: "test" },
+  {
+    scope: "software",
+    name: "@platforma-open/demo.feature.software-python",
+    path: "software-python",
+  },
+  {
+    scope: "software",
+    name: "@platforma-open/demo.feature.software-tengo",
+    path: "software-tengo",
+  },
+];
+
+const ctx: RunContext = createRunContext({ blockVars: vars, modules });
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body, { ctx });
+}
+
+describe("ensureWorkspaceScopeDeps / DevDeps / PeerDeps", () => {
+  test("adds one entry per matching module under dependencies", () => {
+    const out = run({}, () => ensureWorkspaceScopeDeps("software"));
+    expect(out).toEqual({
+      dependencies: {
+        "@platforma-open/demo.feature.software-python": "workspace:*",
+        "@platforma-open/demo.feature.software-tengo": "workspace:*",
+      },
+    });
+  });
+
+  test("DevDeps targets devDependencies", () => {
+    const out = run({}, () => ensureWorkspaceScopeDevDeps("test"));
+    expect(out).toEqual({
+      devDependencies: { "@platforma-open/demo.feature.test": "workspace:*" },
+    });
+  });
+
+  test("PeerDeps targets peerDependencies", () => {
+    const out = run({}, () => ensureWorkspaceScopePeerDeps("model"));
+    expect(out).toEqual({
+      peerDependencies: { "@platforma-open/demo.feature.model": "workspace:*" },
+    });
+  });
+
+  test("scope with zero modules contributes nothing", () => {
+    const ctxNoSoftware = createRunContext({
+      blockVars: vars,
+      modules: modules.filter((m) => m.scope !== "software"),
+    });
+    const out = withManagedBody({}, () => ensureWorkspaceScopeDeps("software"), {
+      ctx: ctxNoSoftware,
+    });
+    expect(out).toEqual({});
+  });
+
+  test("idempotent — second run is a no-op", () => {
+    const once = run({}, () => ensureWorkspaceScopeDeps("model"));
+    const twice = run(JSON.parse(JSON.stringify(once)), () => ensureWorkspaceScopeDeps("model"));
+    expect(twice).toEqual(once);
+  });
+
+  test("throws if no ctx is available", () => {
+    expect(() => withManagedBody({}, () => ensureWorkspaceScopeDeps("model"))).toThrow(
+      /needs a RunContext/,
+    );
+  });
+});

package/src/structure/engine/__tests__/content-rules/gitignore.test.ts

@@ -0,0 +1,50 @@
+import { describe, test, expect } from "vitest";
+import {
+  ensureGitignoreEntries,
+  removeGitignoreEntries,
+  withManagedLines,
+} from "../../content-rules";
+
+function run(lines: string[], body: () => void): string[] {
+  return withManagedLines(lines, body);
+}
+
+describe("ensureGitignoreEntries / removeGitignoreEntries", () => {
+  test("appends missing entries", () => {
+    const out = run([], () => ensureGitignoreEntries(["node_modules/", "dist/"]));
+    expect(out).toEqual(["node_modules/", "dist/"]);
+  });
+
+  test("preserves existing entries; skips duplicates (whitespace + comment aware)", () => {
+    const out = run(["  node_modules/   # vendored", "dist/"], () =>
+      ensureGitignoreEntries(["node_modules/", "dist/"]),
+    );
+    expect(out).toEqual(["  node_modules/   # vendored", "dist/"]);
+  });
+
+  test("removeGitignoreEntries drops lines matching regex patterns", () => {
+    const out = run(["node_modules/", "tmp/", "dist/", "log/"], () =>
+      removeGitignoreEntries([/^tmp\//, /^log\//]),
+    );
+    expect(out).toEqual(["node_modules/", "dist/"]);
+  });
+
+  test("removeGitignoreEntries keeps blank/comment lines untouched", () => {
+    const out = run(["# header", "", "tmp/"], () => removeGitignoreEntries([/^tmp\//]));
+    expect(out).toEqual(["# header", ""]);
+  });
+
+  test("idempotent — ensure double-run is a no-op", () => {
+    const seed = ["node_modules/"];
+    const once = run([...seed], () => ensureGitignoreEntries(["node_modules/", "dist/"]));
+    const twice = run([...once], () => ensureGitignoreEntries(["node_modules/", "dist/"]));
+    expect(twice).toEqual(once);
+  });
+
+  test("idempotent — remove double-run is a no-op", () => {
+    const seed = ["node_modules/", "tmp/"];
+    const once = run([...seed], () => removeGitignoreEntries([/^tmp\//]));
+    const twice = run([...once], () => removeGitignoreEntries([/^tmp\//]));
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/pin-catalog-to.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect } from "vitest";
+import { ensureCatalogLatest, pinCatalogTo, withManagedYaml } from "../../content-rules";
+import { parseYaml, stringifyYaml } from "../../parsers/yaml";
+import {
+  createMockRegistryClient,
+  makeSyncLookup,
+  prefetchLatestVersions,
+} from "../../registry-client";
+
+describe("pinCatalogTo", () => {
+  test("sets an exact version on an existing catalog entry", () => {
+    const doc = parseYaml("catalog:\n  '@platforma-sdk/some': 1.0.0\n");
+    withManagedYaml(doc, () => pinCatalogTo("@platforma-sdk/some", "1.42.3"));
+    const cat = (doc.toJSON() as { catalog: Record<string, string> }).catalog;
+    expect(cat["@platforma-sdk/some"]).toBe("1.42.3");
+  });
+
+  test("creates the entry if missing", () => {
+    const doc = parseYaml("catalog: {}\n");
+    withManagedYaml(doc, () => pinCatalogTo("@platforma-sdk/new", "0.1.0"));
+    const cat = (doc.toJSON() as { catalog: Record<string, string> }).catalog;
+    expect(cat["@platforma-sdk/new"]).toBe("0.1.0");
+  });
+
+  test("declared-last wins: pin overrides ensureCatalogLatest", async () => {
+    const doc = parseYaml(
+      ["catalog:", "  '@platforma-sdk/model': 1.0.0", "  '@platforma-sdk/lock': 1.0.0"].join("\n") +
+        "\n",
+    );
+    const client = createMockRegistryClient({
+      "@platforma-sdk/model": "9.9.9",
+      "@platforma-sdk/lock": "9.9.9",
+    });
+    const resolved = await prefetchLatestVersions(client, [
+      "@platforma-sdk/model",
+      "@platforma-sdk/lock",
+    ]);
+    const getLatestVersion = makeSyncLookup(resolved);
+
+    withManagedYaml(
+      doc,
+      () => {
+        ensureCatalogLatest("@platforma-sdk/model");
+        ensureCatalogLatest("@platforma-sdk/lock");
+        // A later pin overrides the resolved latest — and is downgrade-capable.
+        pinCatalogTo("@platforma-sdk/lock", "1.42.3");
+      },
+      { getLatestVersion },
+    );
+
+    const cat = (doc.toJSON() as { catalog: Record<string, string> }).catalog;
+    expect(cat["@platforma-sdk/model"]).toBe("9.9.9");
+    expect(cat["@platforma-sdk/lock"]).toBe("1.42.3");
+  });
+
+  test("idempotent — second run produces the same YAML", () => {
+    const doc = parseYaml("catalog:\n  '@platforma-sdk/some': 1.0.0\n");
+    withManagedYaml(doc, () => pinCatalogTo("@platforma-sdk/some", "1.42.3"));
+    const once = stringifyYaml(doc);
+    withManagedYaml(doc, () => pinCatalogTo("@platforma-sdk/some", "1.42.3"));
+    const twice = stringifyYaml(doc);
+    expect(twice).toBe(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/prune-keys.test.ts

@@ -0,0 +1,59 @@
+import { describe, test, expect } from "vitest";
+import {
+  pruneKeysMatching,
+  pruneKeysMatchingAt,
+  withManagedBody,
+  type JsonObject,
+} from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("pruneKeysMatching / pruneKeysMatchingAt", () => {
+  test("removes top-level keys matching the predicate", () => {
+    const out = run({ name: "x", "//pnpm": { overrides: {} }, "///": {} }, () =>
+      pruneKeysMatching((k) => k.startsWith("//") || k.startsWith("///")),
+    );
+    expect(out).toEqual({ name: "x" });
+  });
+
+  test("predicate sees key and value — combined match", () => {
+    const out = run({ "//pnpm": { pnpm: { overrides: { foo: "1" } } }, "// kept": "comment" }, () =>
+      pruneKeysMatching((k, v) => {
+        if (!k.startsWith("//")) return false;
+        if (typeof v !== "object" || v === null) return false;
+        const o = v as Record<string, unknown>;
+        return o.pnpm !== undefined || o.overrides !== undefined;
+      }),
+    );
+    expect(out).toEqual({ "// kept": "comment" });
+  });
+
+  test("no-op when nothing matches", () => {
+    const out = run({ name: "x", type: "module" }, () =>
+      pruneKeysMatching((k) => k.startsWith("//")),
+    );
+    expect(out).toEqual({ name: "x", type: "module" });
+  });
+
+  test("pruneKeysMatchingAt operates on a nested object", () => {
+    const out = run({ scripts: { build: "x", _dev_helper: "y", test: "z" } }, () =>
+      pruneKeysMatchingAt("scripts", (k) => k.startsWith("_")),
+    );
+    expect(out).toEqual({ scripts: { build: "x", test: "z" } });
+  });
+
+  test("pruneKeysMatchingAt is a no-op when the path is missing", () => {
+    const out = run({ name: "x" }, () => pruneKeysMatchingAt("scripts", () => true));
+    expect(out).toEqual({ name: "x" });
+  });
+
+  test("idempotent — second run is a no-op", () => {
+    const once = run({ a: 1, "//x": 2 }, () => pruneKeysMatching((k) => k.startsWith("//")));
+    const twice = run(JSON.parse(JSON.stringify(once)), () =>
+      pruneKeysMatching((k) => k.startsWith("//")),
+    );
+    expect(twice).toEqual(once);
+  });
+});

package/src/structure/engine/__tests__/content-rules/registry-client.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Stub the backoff sleep so the 503-retry path runs instantly (no real
+// ~1.5s of exponential backoff). Only registry-client's `sleep` import is
+// affected; the helper tests below don't touch timers.
+vi.mock("node:timers/promises", () => ({
+  setTimeout: vi.fn().mockResolvedValue(undefined),
+}));
+
+import {
+  createMockRegistryClient,
+  createRealRegistryClient,
+  makeSyncLookup,
+  parseRetryAfter,
+  prefetchLatestVersions,
+} from "../../registry-client";
+
+describe("registry-client (mock + helpers)", () => {
+  test("mock client returns configured versions", async () => {
+    const c = createMockRegistryClient({ "@platforma-sdk/model": "2.0.0" });
+    expect(await c.getLatestVersion("@platforma-sdk/model")).toBe("2.0.0");
+  });
+
+  test("mock client throws on unknown package", async () => {
+    const c = createMockRegistryClient({});
+    await expect(c.getLatestVersion("nope")).rejects.toThrow(/no version configured/);
+  });
+
+  test("prefetchLatestVersions resolves the requested names in parallel", async () => {
+    const c = createMockRegistryClient({ a: "1.0.0", b: "2.0.0" });
+    const m = await prefetchLatestVersions(c, ["a", "b"]);
+    expect(m.get("a")).toBe("1.0.0");
+    expect(m.get("b")).toBe("2.0.0");
+    expect(m.size).toBe(2);
+  });
+
+  test("makeSyncLookup wraps a map as a sync getter, returning undefined for misses", () => {
+    const lookup = makeSyncLookup(new Map([["a", "1.0.0"]]));
+    expect(lookup("a")).toBe("1.0.0");
+    expect(lookup("missing")).toBeUndefined();
+  });
+
+  test("parseRetryAfter handles delay-seconds form", () => {
+    expect(parseRetryAfter("120")).toBe(120_000);
+  });
+
+  test("parseRetryAfter handles HTTP-date form", () => {
+    const date = new Date(Date.now() + 5_000).toUTCString();
+    const ms = parseRetryAfter(date);
+    expect(ms).not.toBeNull();
+    expect(ms!).toBeGreaterThan(0);
+    expect(ms!).toBeLessThanOrEqual(5_000 + 200);
+  });
+
+  test("parseRetryAfter returns null on missing/invalid header", () => {
+    expect(parseRetryAfter(null)).toBeNull();
+    expect(parseRetryAfter("not-a-date-or-seconds")).toBeNull();
+  });
+});
+
+describe("fetchWithRetry (via real client) — retry policy", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  /** Minimal Response stand-in: `fetchWithRetry` only reads `.ok`,
+   *  `.status`, and `.headers.get(...)`. */
+  function fakeResponse(status: number): Response {
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      headers: { get: () => null },
+    } as unknown as Response;
+  }
+
+  test("non-retryable status (404) throws after exactly ONE fetch — no retry", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(fakeResponse(404));
+    vi.stubGlobal("fetch", fetchMock);
+    const client = createRealRegistryClient();
+    await expect(client.getLatestVersion("@platforma-sdk/model")).rejects.toThrow(/HTTP 404/);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("retryable status (503) retries then throws — exactly 1 + RETRY_COUNT fetches", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(fakeResponse(503));
+    vi.stubGlobal("fetch", fetchMock);
+    const client = createRealRegistryClient();
+    await expect(client.getLatestVersion("@platforma-sdk/model")).rejects.toThrow(/HTTP 503/);
+    // RETRY_COUNT = 2 → 3 total attempts.
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+  });
+
+  test("transient transport error retries then propagates — exactly 1 + RETRY_COUNT fetches", async () => {
+    const fetchMock = vi.fn().mockRejectedValue(new Error("network down"));
+    vi.stubGlobal("fetch", fetchMock);
+    const client = createRealRegistryClient();
+    await expect(client.getLatestVersion("@platforma-sdk/model")).rejects.toThrow(/network down/);
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+  });
+
+  test("success on first try — one fetch, parsed dist-tag returned", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      json: async () => ({ latest: "9.9.9" }),
+    } as unknown as Response);
+    vi.stubGlobal("fetch", fetchMock);
+    const client = createRealRegistryClient();
+    expect(await client.getLatestVersion("@platforma-sdk/model")).toBe("9.9.9");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/structure/engine/__tests__/content-rules/remove-field.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect } from "vitest";
+import { removeField, withManagedBody, type JsonObject } from "../../content-rules";
+
+function run(input: JsonObject, body: () => void): JsonObject {
+  return withManagedBody(input, body);
+}
+
+describe("removeField", () => {
+  test("removes an existing top-level field unconditionally", () => {
+    const out = run({ name: "x", legacy: 1 }, () => removeField("legacy"));
+    expect(out).toEqual({ name: "x" });
+  });
+
+  test("no-op when the field is absent", () => {
+    const out = run({ name: "x" }, () => removeField("legacy"));
+    expect(out).toEqual({ name: "x" });
+  });
+
+  test("removes a nested field via dotted path", () => {
+    const out = run({ pnpm: { overrides: { foo: "1" } } }, () => removeField("pnpm.overrides"));
+    expect(out).toEqual({ pnpm: {} });
+  });
+
+  test("predicate=false leaves the field intact", () => {
+    const out = run({ pnpm: { overrides: { foo: "1" } } }, () =>
+      removeField(
+        "pnpm.overrides",
+        (v) => typeof v === "object" && v !== null && Object.keys(v).length === 0,
+      ),
+    );
+    expect(out).toEqual({ pnpm: { overrides: { foo: "1" } } });
+  });
+
+  test("predicate=true removes the field", () => {
+    const out = run({ pnpm: { overrides: {} } }, () =>
+      removeField(
+        "pnpm.overrides",
+        (v) => typeof v === "object" && v !== null && Object.keys(v).length === 0,
+      ),
+    );
+    expect(out).toEqual({ pnpm: {} });
+  });
+
+  test("idempotent — second run is a no-op", () => {
+    const once = run({ a: 1, b: 2 }, () => removeField("b"));
+    const twice = run(JSON.parse(JSON.stringify(once)), () => removeField("b"));
+    expect(twice).toEqual(once);
+  });
+});