@platforma-sdk/block-tools 2.10.15 → 2.10.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.10.15",
+  "version": "2.10.17",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "license": "UNLICENSED",
   "bin": {
@@ -33,12 +33,12 @@
     "undici": "~7.16.0",
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
-    "@milaboratories/pl-http": "1.2.4",
     "@milaboratories/pl-model-common": "1.46.1",
     "@milaboratories/pl-model-backend": "1.4.7",
-    "@milaboratories/pl-model-middle-layer": "1.30.5",
-    "@milaboratories/ts-helpers": "1.8.3",
     "@milaboratories/resolve-helper": "1.1.3",
+    "@milaboratories/pl-model-middle-layer": "1.30.6",
+    "@milaboratories/ts-helpers": "1.8.3",
+    "@milaboratories/pl-http": "1.2.4",
     "@milaboratories/ts-helpers-oclif": "1.1.42",
     "@platforma-sdk/blocks-deps-updater": "2.2.0"
   },
@@ -56,10 +56,10 @@
     "vite": "^8.0.6",
     "vite-plugin-dts": "^4.5.3",
     "vitest": "^4.1.3",
+    "@milaboratories/build-configs": "2.0.0",
     "@milaboratories/oclif-index": "1.1.1",
     "@milaboratories/ts-configs": "1.2.3",
-    "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-builder": "1.5.0"
+    "@milaboratories/ts-builder": "1.5.1"
   },
   "oclif": {
     "bin": "block-tools",

package/src/structure/__tests__/tsconfig-idempotency.test.ts

@@ -0,0 +1,94 @@
+// Regression: a test-bearing model/ui scope migrating from a LEGACY tsconfig
+// must converge in a single pass.
+//
+// History: the tsconfig used to be a `managed` file whose body did
+// `removeField("compilerOptions")`, conditionally re-added
+// `compilerOptions.types: ["node"]`, then `ensureField("include", …)`. On a
+// legacy tsconfig with no `include`, pass 1 appended `include` AFTER the
+// re-added `compilerOptions` → `{extends, compilerOptions, include}`, while the
+// body's fixpoint was `{extends, include, compilerOptions}`. The two differed
+// only in key order, so the engine's post-run recheck saw a phantom diff and
+// `refresh` aborted with a non-idempotency RecheckError on EVERY test-bearing
+// block migrating off a legacy (vite-era) tsconfig.
+//
+// Now the tsconfig is a `fixed` file with two static end states selected by a
+// `when`/else on co-located-test presence (`tsconfig.node.json` vs
+// `tsconfig.json`). There is no imperative body and no insertion-order side
+// effect, so single-pass idempotency holds by construction. This test guards
+// that property.
+
+import { describe, test, expect } from "vitest";
+import { simulateInit, defaultTemplateProvider } from "../engine/testing";
+import { run as engineRun } from "../engine/runner";
+import { discoverRunContext } from "../engine/discovery-fs";
+import { STRUCTURE } from "../structure-definition";
+import { SDK_CATALOG_PACKAGES } from "../rules/root-pnpm-workspace";
+import type { BlockVars } from "../engine/api";
+
+const VARS: BlockVars = {
+  facadeName: "@platforma-open/test-org.demo",
+  baseName: "test-org.demo",
+  npmOrg: "@platforma-open",
+  orgScope: "test-org",
+  shortName: "demo",
+};
+
+const mockLookup = (name: string): string | undefined =>
+  SDK_CATALOG_PACKAGES.includes(name) ? "9.9.9" : undefined;
+
+// `refresh` runs the full engine INCLUDING the post-run recheck (via
+// `rediscover`); a non-idempotent rule set makes this throw.
+function refresh(fs: ReturnType<typeof simulateInit>["fs"]) {
+  const ctx = discoverRunContext({ fs, isSdkInternal: false });
+  engineRun(STRUCTURE, fs, ctx, {
+    templates: defaultTemplateProvider(),
+    rediscover: () => discoverRunContext({ fs, isSdkInternal: false, dryRun: true }),
+  });
+}
+
+const CANONICAL_ORDER = ["extends", "compilerOptions", "include"];
+
+describe("tsconfig first-pass idempotency on legacy (no-include) tsconfig", () => {
+  test("model + ui co-located tests, legacy tsconfig without `include` → refresh converges in one pass", () => {
+    const { fs } = simulateInit({ vars: VARS, registryLookup: mockLookup });
+
+    // Co-located unit tests in both scopes -> the conditional node-types re-add fires.
+    fs.write("model/src/m.test.ts", `import { test } from "vitest";\ntest("x", () => {});\n`);
+    fs.write("ui/src/u.test.ts", `import { test } from "vitest";\ntest("x", () => {});\n`);
+
+    // Legacy tsconfigs as a vite-era block carried them: a `compilerOptions`
+    // block and NO top-level `include`. This is what made pass 1 append
+    // `include` after the re-added `compilerOptions`.
+    fs.write(
+      "model/tsconfig.json",
+      JSON.stringify({
+        extends: "@milaboratories/ts-configs/block/model",
+        compilerOptions: { strict: true },
+      }),
+    );
+    fs.write(
+      "ui/tsconfig.json",
+      JSON.stringify({
+        extends: "@milaboratories/ts-configs/block/ui",
+        compilerOptions: { strict: true },
+      }),
+    );
+
+    // Without the fix this throws RecheckError (rule set not idempotent).
+    expect(() => refresh(fs)).not.toThrow();
+
+    for (const scope of ["model", "ui"]) {
+      const ts = JSON.parse(fs.read(`${scope}/tsconfig.json`)) as {
+        extends: string;
+        include: string[];
+        compilerOptions: { types: string[] };
+      };
+      // Canonical, deterministic key order.
+      expect(Object.keys(ts)).toEqual(CANONICAL_ORDER);
+      expect(ts.extends).toBe(`@milaboratories/ts-configs/block/${scope}`);
+      expect(ts.include).toEqual(["src/**/*"]);
+      // node types wired (co-located test present); legacy `strict` pruned.
+      expect(ts.compilerOptions).toEqual({ types: ["node"] });
+    }
+  });
+});

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

@@ -222,6 +222,36 @@ describe("when() — inner-mode dispatch inside managed bodies", () => {
     ).toThrow(/outside defineStructure.*outside any managed/);
   });
 
+  test("else branch: predicate=true runs body, skips else", () => {
+    const out = withManagedBody(
+      {} as JsonObject,
+      () => {
+        when(
+          ({ pathExists }) => pathExists("tests/"),
+          () => ensureField("branch", "if"),
+          () => ensureField("branch", "else"),
+        );
+      },
+      { triggerContext: makeTctx({ paths: new Set(["tests/"]) }) },
+    );
+    expect(out.branch).toBe("if");
+  });
+
+  test("else branch: predicate=false runs else, skips body", () => {
+    const out = withManagedBody(
+      {} as JsonObject,
+      () => {
+        when(
+          ({ pathExists }) => pathExists("tests/"),
+          () => ensureField("branch", "if"),
+          () => ensureField("branch", "else"),
+        );
+      },
+      { triggerContext: makeTctx({ paths: new Set() }) },
+    );
+    expect(out.branch).toBe("else");
+  });
+
   test("idempotent — double-run yields the same parsed state", () => {
     const body = () => {
       ensureField("type", "module");

package/src/structure/engine/builders.ts

@@ -193,34 +193,49 @@ export function registerInnerWhenHandler(h: InnerWhenHandler): void {
 }
 
 /**
- * Conditionally run `body`. Two dispatch modes by active state:
- *  - inside `defineStructure(...)` → push a `WhenFrame` into the tree;
- *    trigger fires later at runner time per `FlatItem`.
- *  - inside a `managed(...)` body → evaluate `trigger` immediately
- *    against the runner-supplied `TriggerContext`; run/skip `body`
- *    synchronously.
+ * Conditionally run `body`, with an optional `elseBody`. One `when` symbol for
+ * both layers — `dispatchWhen` picks the timing:
+ *  - inside `defineStructure(...)` → register a `WhenFrame`; its trigger fires
+ *    later, per module, at runner time.
+ *  - inside a `managed(...)` body → evaluate the trigger against the live block
+ *    now and run/skip synchronously.
  *
- * One `when` symbol for both layers — same user contract, dispatch
- * picks the matching execution timing.
+ * `else` is just the negated trigger dispatched the same way, so exactly one
+ * branch applies (in either layer).
  */
-export function when(trigger: TriggerFn, body: () => void): void {
+export function when(trigger: TriggerFn, body: () => void, elseBody?: () => void): void {
+  dispatchWhen(trigger, body);
+  if (elseBody) dispatchWhen((tctx) => !trigger(tctx), elseBody);
+}
+
+/** Single-branch dispatch shared by both `when` branches. In a managed body the
+ *  handler runs `body` iff its trigger holds and returns whether a managed-body
+ *  context existed; no context — and not tree-build either — means `when()` was
+ *  called outside both layers, a misuse. */
+function dispatchWhen(trigger: TriggerFn, body: () => void): void {
   if (activeTree) {
-    const t = activeTree;
-    const frame: WhenFrame = { kind: "when", trigger, children: [] };
-    t.stack[t.stack.length - 1]!.push(frame);
-    t.stack.push(frame.children);
-    try {
-      body();
-    } finally {
-      t.stack.pop();
-    }
+    pushWhenFrame(trigger, body);
     return;
   }
-  if (innerWhenHandler && innerWhenHandler(trigger, body)) return;
-  throw new Error(
-    "when() called outside defineStructure() and outside any managed(...) body. " +
-      "Place this call inside one of the two.",
-  );
+  const handled = innerWhenHandler?.(trigger, body) ?? false;
+  if (!handled) {
+    throw new Error(
+      "when() called outside defineStructure() and outside any managed(...) body. " +
+        "Place this call inside one of the two.",
+    );
+  }
+}
+
+function pushWhenFrame(trigger: TriggerFn, body: () => void): void {
+  const t = activeTree!;
+  const frame: WhenFrame = { kind: "when", trigger, children: [] };
+  t.stack[t.stack.length - 1]!.push(frame);
+  t.stack.push(frame.children);
+  try {
+    body();
+  } finally {
+    t.stack.pop();
+  }
 }
 
 /** Trigger factory: true when at least one file in the leaf's module

package/src/structure/rules/model.ts

@@ -2,47 +2,23 @@
 // `src/index.ts` seed is dropped by `init` and never touched again
 // (block author owns it).
 
-import {
-  scope,
-  fixed,
-  managed,
-  seed,
-  file,
-  generate,
-  when,
-  whenFilesExist,
-  ensureField,
-  removeField,
-  pruneKeysMatching,
-} from "../engine/api";
+import { scope, fixed, managed, seed, file, generate, when, whenFilesExist } from "../engine/api";
 import { getActiveRunContext } from "../engine/builders";
 import { modelPackageJsonInitial, modelPackageJsonRules } from "./model-package-json";
 import { COLOCATED_TEST_GLOB } from "./shared/colocated-tests";
 
 export function modelRules(): void {
   scope("model", () => {
-    // tsconfig is managed (not fixed) so node ambient types can be provided
-    // CONDITIONALLY. The body still enforces the canonical shape —
-    // `{extends, include}` with NO stray keys — and, ONLY when the model
-    // carries co-located unit tests (`src/**/*.test.ts`), adds
-    // `compilerOptions.types: ["node"]` so those tests type-check: provide
-    // node types, do NOT exclude the tests. A test-less model is
-    // canonicalised to bare `{extends, include}`
-    // and stays a refresh fixpoint. The matching `@types/node` devDep is
-    // wired by the package.json rule under the same predicate.
-    managed("tsconfig.json", file("model/tsconfig.json"), () => {
-      ensureField("extends", "@milaboratories/ts-configs/block/model");
-      // Canonical default carries no compilerOptions; drop any legacy block's
-      // before (conditionally) re-adding only `types`.
-      removeField("compilerOptions");
-      when(whenFilesExist(COLOCATED_TEST_GLOB), () => {
-        ensureField("compilerOptions.types", ["node"]);
-      });
-      ensureField("include", ["src/**/*"]);
-      // Strip anything else a legacy tsconfig carried (files, references, a
-      // different extends layout) — keep only the canonical keys.
-      pruneKeysMatching((k) => k !== "extends" && k !== "include" && k !== "compilerOptions");
-    });
+    // Two static end states by co-located-test presence: a test-bearing model
+    // gets node ambient types (`.node.json`) so the tests type-check —
+    // `@types/node` is wired alongside by the package.json rule; a test-less
+    // model stays bare. `fixed` (engine-owned, whole-file overwrite) not
+    // `managed`, so refresh is idempotent by construction — no key-order drift.
+    when(
+      whenFilesExist(COLOCATED_TEST_GLOB),
+      () => fixed("tsconfig.json", file("model/tsconfig.node.json")),
+      () => fixed("tsconfig.json", file("model/tsconfig.json")),
+    );
     fixed(".oxlintrc.json", file("model/.oxlintrc.json"));
     fixed(".oxfmtrc.json", file("model/.oxfmtrc.json"));
 

package/src/structure/rules/ui-package-json.ts

@@ -80,6 +80,13 @@ export function uiPackageJsonRules(): void {
     vitest: "catalog:",
   });
 
+  // `vue-tsc` is owned by `ts-builder` (which runs it internally for
+  // `--target block-ui`), so the ui must NOT declare its own. A direct
+  // `vue-tsc` dep is the vestigial vite/vue-tsc-era artefact: it resolves
+  // independently of the version ts-builder pins, which is how a block ended
+  // up type-checking under a different vue-tsc than the toolchain intends.
+  removeDep("vue-tsc");
+
   // The ui builds with `--target block-ui` (types: []), so by default it
   // carries no browser/vitest/node ambient types — only the `typescript`
   // peer for IDE type resolution. Drop any stray `@types/node` a legacy

package/src/structure/rules/ui.ts

@@ -13,9 +13,6 @@ import {
   blockVars,
   when,
   whenFilesExist,
-  ensureField,
-  removeField,
-  pruneKeysMatching,
 } from "../engine/api";
 import { getActiveRunContext } from "../engine/builders";
 import { uiPackageJsonInitial, uiPackageJsonRules } from "./ui-package-json";
@@ -23,25 +20,16 @@ import { COLOCATED_TEST_GLOB } from "./shared/colocated-tests";
 
 export function uiRules(): void {
   scope("ui", () => {
-    // tsconfig is managed (not fixed) so node ambient types can be provided
-    // CONDITIONALLY. The body still enforces the canonical shape —
-    // `{extends, include}` with NO stray keys — and, ONLY when the ui
-    // carries co-located unit tests (`src/**/*.test.ts`), adds
-    // `compilerOptions.types: ["node"]` so tests importing `node:*`
-    // type-check under vue-tsc: provide node types, do NOT exclude the
-    // tests. A test-less ui is canonicalised to
-    // bare `{extends, include}` and stays a refresh fixpoint. The matching
-    // `@types/node` devDep is wired by the package.json rule under the same
-    // predicate.
-    managed("tsconfig.json", file("ui/tsconfig.json"), () => {
-      ensureField("extends", "@milaboratories/ts-configs/block/ui");
-      removeField("compilerOptions");
-      when(whenFilesExist(COLOCATED_TEST_GLOB), () => {
-        ensureField("compilerOptions.types", ["node"]);
-      });
-      ensureField("include", ["src/**/*"]);
-      pruneKeysMatching((k) => k !== "extends" && k !== "include" && k !== "compilerOptions");
-    });
+    // Two static end states by co-located-test presence: a test-bearing ui gets
+    // node ambient types (`.node.json`) so tests' `node:*` imports type-check
+    // under vue-tsc — `@types/node` is wired alongside by the package.json rule;
+    // a test-less ui stays bare. `fixed` (engine-owned, whole-file overwrite)
+    // not `managed`, so refresh is idempotent by construction — no key-order drift.
+    when(
+      whenFilesExist(COLOCATED_TEST_GLOB),
+      () => fixed("tsconfig.json", file("ui/tsconfig.node.json")),
+      () => fixed("tsconfig.json", file("ui/tsconfig.json")),
+    );
     fixed(".oxlintrc.json", file("ui/.oxlintrc.json"));
     // Block-local oxfmt config — the ui is oxfmt-checked (`ts-builder check
     // --target block-ui`).

package/src/structure/templates/static/model/tsconfig.node.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@milaboratories/ts-configs/block/model",
+  "compilerOptions": {
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}

package/src/structure/templates/static/ui/tsconfig.node.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@milaboratories/ts-configs/block/ui",
+  "compilerOptions": {
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}