@platforma-sdk/block-tools 2.10.16 → 2.10.18

package/src/structure/engine/registry-client.ts

@@ -12,6 +12,15 @@ import { setTimeout as sleep } from "node:timers/promises";
 
 export interface RegistryClient {
   getLatestVersion(packageName: string): Promise<string>;
+  /** Read the version `packageName@version` declares for `depName` in its
+   *  published manifest. `version` may be "latest" (resolved via the
+   *  dist-tags). Looks in `dependencies` first, then `peerDependencies`.
+   *  Returns `undefined` when the dep is declared in neither section. */
+  getDeclaredDependency(
+    packageName: string,
+    version: string,
+    depName: string,
+  ): Promise<string | undefined>;
 }
 
 const RETRY_COUNT = 2;
@@ -60,6 +69,14 @@ async function fetchWithRetry(url: string): Promise<Response> {
   }
 }
 
+/** Shape of the per-version manifest doc fetched from
+ *  `https://registry.npmjs.org/<pkg>/<version>` (only the dep sections are
+ *  read). */
+type PackageManifest = {
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+};
+
 /** Live npm registry client. Hits the network on each call. */
 export function createRealRegistryClient(): RegistryClient {
   return {
@@ -74,11 +91,33 @@ export function createRealRegistryClient(): RegistryClient {
       }
       return latest;
     },
+    async getDeclaredDependency(
+      packageName: string,
+      version: string,
+      depName: string,
+    ): Promise<string | undefined> {
+      const res = await fetchWithRetry(`https://registry.npmjs.org/${packageName}/${version}`);
+      const manifest = (await res.json()) as PackageManifest;
+      return manifest.dependencies?.[depName] ?? manifest.peerDependencies?.[depName];
+    },
   };
 }
 
-/** In-memory client backed by a fixed `name → version` map. */
-export function createMockRegistryClient(versions: Record<string, string>): RegistryClient {
+/** In-memory client backed by a fixed `name → version` map. The optional
+ *  `manifests` map (`pkg@version` → declared deps) backs
+ *  `getDeclaredDependency`; "latest" keys resolve via the `versions` map. */
+export function createMockRegistryClient(
+  versions: Record<string, string>,
+  manifests: Record<string, Record<string, string>> = {},
+): RegistryClient {
+  function resolveVersion(packageName: string, version: string): string {
+    if (version !== "latest") return version;
+    const v = versions[packageName];
+    if (v === undefined) {
+      throw new Error(`mock registry: no version configured for '${packageName}'`);
+    }
+    return v;
+  }
   return {
     async getLatestVersion(packageName: string): Promise<string> {
       const v = versions[packageName];
@@ -87,6 +126,18 @@ export function createMockRegistryClient(versions: Record<string, string>): Regi
       }
       return v;
     },
+    async getDeclaredDependency(
+      packageName: string,
+      version: string,
+      depName: string,
+    ): Promise<string | undefined> {
+      const resolved = resolveVersion(packageName, version);
+      const deps = manifests[`${packageName}@${resolved}`];
+      if (deps === undefined) {
+        throw new Error(`mock registry: no manifest configured for '${packageName}@${resolved}'`);
+      }
+      return deps[depName];
+    },
   };
 }
 
@@ -138,3 +189,66 @@ export async function buildRegistryLookupForNames(
   const resolved = await prefetchLatestVersions(client, names);
   return makeSyncLookup(resolved);
 }
+
+/** A catalog entry whose version is DERIVED from the version another
+ *  package declares for it. `entry` is the catalog key (== the dep name in
+ *  the source manifest); `of` is the package whose manifest is read; the
+ *  optional `ofVersion` pins which release of `of` to read (default: npm
+ *  latest, the same release the catalog bump pins `of` to). Consumed by
+ *  `pinCatalogToDependencyOf`. */
+export type DerivedCatalogPin = {
+  entry: string;
+  of: string;
+  ofVersion?: string;
+};
+
+/** True iff `version` is a bare exact `x.y.z(-prerelease)?` — no range
+ *  modifier (`^`, `~`, `>=`, `*`, `||`, ` - `, `x`, workspace:, etc.). */
+function isExactVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version);
+}
+
+/** Prefetch every derived pin and build the sync lookup the runner passes
+ *  to `pinCatalogToDependencyOf` (`entry → exact version`). Reads
+ *  `pin.of`'s manifest (at `pin.ofVersion`, default npm latest) and the
+ *  version it declares for `pin.entry`. Policy (b): THROWS at prefetch time
+ *  if the source declares the dep as a non-exact (ranged) version or does
+ *  not declare it at all — a derived pin must resolve to an exact version
+ *  or it is a configuration error. Empty list → a lookup that resolves
+ *  nothing (no network). A registry failure REJECTS. `client` defaults to
+ *  the live npm client; tests inject a mock. */
+export async function buildDerivedPinLookupForPins(
+  pins: readonly DerivedCatalogPin[],
+  client: RegistryClient = createRealRegistryClient(),
+): Promise<(entry: string) => string | undefined> {
+  if (pins.length === 0) return () => undefined;
+  const entries = await Promise.all(
+    pins.map(async (pin) => {
+      const declared = await client.getDeclaredDependency(
+        pin.of,
+        pin.ofVersion ?? "latest",
+        pin.entry,
+      );
+      if (declared === undefined) {
+        throw new Error(
+          `derived catalog pin '${pin.entry}': package '${pin.of}'` +
+            `${pin.ofVersion ? `@${pin.ofVersion}` : " (latest)"} declares no ` +
+            `dependency '${pin.entry}'. A derived pin requires the source to ` +
+            `declare the dep as an exact version.`,
+        );
+      }
+      if (!isExactVersion(declared)) {
+        throw new Error(
+          `derived catalog pin '${pin.entry}': package '${pin.of}'` +
+            `${pin.ofVersion ? `@${pin.ofVersion}` : " (latest)"} declares ` +
+            `'${pin.entry}: ${declared}', which is not an exact version. ` +
+            `A derived pin requires an exact ('x.y.z') source dependency so ` +
+            `the catalog can pin to it precisely.`,
+        );
+      }
+      return [pin.entry, declared] as const;
+    }),
+  );
+  const resolved = new Map(entries);
+  return (entry) => resolved.get(entry);
+}

package/src/structure/engine/runner.ts

@@ -83,6 +83,12 @@ export type RunOptions = {
    *  and passes the resulting sync map here; unit tests pass a mock.
    *  Absent → `ensureCatalogLatest` is a no-op (default refresh). */
   registryLookup?: (packageName: string) => string | undefined;
+  /** Sync accessor for prefetched derived catalog pins
+   *  (`catalogEntry → exact version`), consumed by `pinCatalogToDependencyOf`
+   *  inside `onInitOrUpdate` managed bodies. The CLI / init constructor
+   *  prefetches + validates these before the run (network). Absent →
+   *  `pinCatalogToDependencyOf` is a no-op (default refresh). */
+  derivedPinLookup?: (catalogEntry: string) => string | undefined;
 };
 
 export class RecheckError extends Error {
@@ -189,6 +195,7 @@ function runManagedBody(
   body: ManagedBody,
   tctx: TriggerContext,
   registryLookup: ((packageName: string) => string | undefined) | undefined,
+  derivedPinLookup: ((catalogEntry: string) => string | undefined) | undefined,
 ): string {
   const base = path.split("/").pop() ?? path;
   if (path.endsWith(".json")) {
@@ -203,7 +210,11 @@ function runManagedBody(
   }
   if (path.endsWith(".yaml") || path.endsWith(".yml")) {
     const doc = parseYaml(raw);
-    withManagedYaml(doc, body, { triggerContext: tctx, getLatestVersion: registryLookup });
+    withManagedYaml(doc, body, {
+      triggerContext: tctx,
+      getLatestVersion: registryLookup,
+      getDerivedDependencyPin: derivedPinLookup,
+    });
     return stringifyYaml(doc);
   }
   if (base === ".gitignore" || base.endsWith(".gitignore")) {
@@ -371,6 +382,7 @@ function applyManaged(
   tctx: TriggerContext,
   templates: TemplateProvider | undefined,
   registryLookup: ((packageName: string) => string | undefined) | undefined,
+  derivedPinLookup: ((catalogEntry: string) => string | undefined) | undefined,
   isSdkInternal: boolean,
 ): Change | undefined {
   if (item.leaf.kind !== "managed") return undefined;
@@ -388,7 +400,7 @@ function applyManaged(
     beforeRaw = fs.read(path);
   }
 
-  const after = runManagedBody(path, beforeRaw, leaf.body, tctx, registryLookup);
+  const after = runManagedBody(path, beforeRaw, leaf.body, tctx, registryLookup, derivedPinLookup);
 
   if (created) {
     if (!dryRun) fs.write(path, after);
@@ -419,6 +431,7 @@ function executePass(
   templates: TemplateProvider | undefined,
   initMode: boolean,
   registryLookup: ((packageName: string) => string | undefined) | undefined,
+  derivedPinLookup: ((catalogEntry: string) => string | undefined) | undefined,
 ): Change[] {
   const items = filterByMode(flat, currentMode(ctx, initMode));
   const changes: Change[] = [];
@@ -448,6 +461,7 @@ function executePass(
       tctx2,
       templates,
       registryLookup,
+      derivedPinLookup,
       ctx.isSdkInternal,
     );
     if (change) changes.push(change);
@@ -478,6 +492,7 @@ export function run(
       opts.templates,
       initMode,
       opts.registryLookup,
+      opts.derivedPinLookup,
     );
 
     const isRefreshDefault = !ctx.dryRun && !ctx.updateDepsOnly && !initMode;
@@ -499,6 +514,7 @@ export function run(
         opts.templates,
         false,
         opts.registryLookup,
+        opts.derivedPinLookup,
       );
       // Ignore .structure self-write (already up to date after
       // writeStructureVersion above).

package/src/structure/init-block-constructor.ts

@@ -14,8 +14,12 @@ import { run as engineRun } from "./engine/runner";
 import { createRunContext, modulesForInit } from "./engine/ctx";
 import { STRUCTURE } from "./structure-definition";
 import { STRUCTURE_VERSION } from "./engine/version";
-import { matchesBumpPattern, buildRegistryLookupForNames } from "./engine/registry-client";
-import { SDK_CATALOG_PACKAGES } from "./rules/root-pnpm-workspace";
+import {
+  matchesBumpPattern,
+  buildRegistryLookupForNames,
+  buildDerivedPinLookupForPins,
+} from "./engine/registry-client";
+import { SDK_CATALOG_PACKAGES, DERIVED_CATALOG_PINS } from "./rules/root-pnpm-workspace";
 import type { BlockVars } from "./engine/api";
 
 /** Platform choices `init` can scaffold a software module for. Python is
@@ -145,8 +149,12 @@ export async function runInit(init: InitInput): Promise<BlockVars> {
   // aborts init rather than silently shipping an unresolved placeholder.
   const sdkNames = SDK_CATALOG_PACKAGES.filter(matchesBumpPattern);
   let registryLookup: (name: string) => string | undefined;
+  let derivedPinLookup: (entry: string) => string | undefined;
   try {
     registryLookup = await buildRegistryLookupForNames(sdkNames);
+    // Derived catalog pins (e.g. vue ← ui-vue's declared dep) are resolved on
+    // init too, so a freshly-scaffolded block pins vue exactly from the start.
+    derivedPinLookup = await buildDerivedPinLookupForPins(DERIVED_CATALOG_PINS);
   } catch (err) {
     throw new Error(
       `init requires network access to resolve SDK catalog versions from npm, ` +
@@ -154,7 +162,12 @@ export async function runInit(init: InitInput): Promise<BlockVars> {
     );
   }
 
-  engineRun(STRUCTURE, fs, ctx, { templates, initMode: true, registryLookup });
+  engineRun(STRUCTURE, fs, ctx, {
+    templates,
+    initMode: true,
+    registryLookup,
+    derivedPinLookup,
+  });
   init.log(
     `Initialised block '${vars.facadeName}'${
       vars.softwarePlatform ? ` (software: ${vars.softwarePlatform})` : " (no software)"

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

@@ -15,6 +15,8 @@ import {
   ensureDep,
   ensureDevDep,
   ensureDevDeps,
+  removeDep,
+  removeField,
   ensurePeerDeps,
   enforceAlphabeticalOrder,
   enforceFieldOrder,
@@ -49,8 +51,6 @@ export function modelPackageJsonInitial(ctx: RunContext): Record<string, unknown
       watch: "ts-builder build --target block-model --watch",
       build: "ts-builder build --target block-model && block-tools build-model",
       check: "ts-builder check --target block-model",
-      // No `test`: the vitest `test` script is wired by the body rule ONLY
-      // when co-located test files exist (a freshly-init'd model has none).
     },
     dependencies: {
       "@platforma-sdk/model": "sdk:",
@@ -59,7 +59,6 @@ export function modelPackageJsonInitial(ctx: RunContext): Record<string, unknown
       "@milaboratories/ts-builder": "sdk:",
       "@milaboratories/ts-configs": "sdk:",
       "@platforma-sdk/block-tools": "sdk:",
-      vitest: "catalog:",
     },
     peerDependencies: {
       "@types/node": "*",
@@ -94,7 +93,6 @@ export function modelPackageJsonRules(): void {
     "@milaboratories/ts-builder": "sdk:",
     "@milaboratories/ts-configs": "sdk:",
     "@platforma-sdk/block-tools": "sdk:",
-    vitest: "catalog:",
   });
 
   ensurePeerDeps({
@@ -102,18 +100,39 @@ export function modelPackageJsonRules(): void {
     typescript: "*",
   });
 
-  // The vitest `test` script + node ambient types are wired ONLY when the
-  // model carries co-located unit tests (`src/**/*.test.ts`). A test-less
-  // model gets neither — turbo simply has no `test` task for it, and the
-  // scope stays a refresh fixpoint. When tests ARE present, `@types/node`
-  // is promoted from peer to a devDep (the single-section invariant drops
-  // the peer) so the tests' `node:*` imports resolve under the
-  // `types: ["node"]` that model/tsconfig adds under the same predicate.
-  // Runs AFTER ensurePeerDeps so the promotion is not reverted.
-  when(whenFilesExist(COLOCATED_TEST_GLOB), () => {
-    ensureScript("test", "vitest run --passWithNoTests");
-    ensureDevDep("@types/node", "*");
-  });
+  // The vitest `test` script, the `vitest` devDep, and node ambient types are
+  // wired ONLY when the model carries co-located unit tests (`src/**/*.test.ts`).
+  // A test-less model gets none — turbo simply has no `test` task for it, and
+  // the scope stays a refresh fixpoint. When tests ARE present, `@types/node`
+  // is promoted from peer to a devDep (the single-section invariant drops the
+  // peer) so the tests' `node:*` imports resolve under the `types: ["node"]`
+  // that model/tsconfig adds under the same predicate. Runs AFTER ensurePeerDeps
+  // so the promotion is not reverted.
+  //
+  // Skipped entirely for sdk-internal (in-monorepo) blocks: those live inside
+  // the platforma monorepo's own test infrastructure (build-configs, shared
+  // catalog, coverage providers) and own their test wiring — the structurer
+  // must not impose or strip standalone-block test conventions on them.
+  when(
+    ({ ctx }) => !ctx.isSdkInternal,
+    () =>
+      when(
+        whenFilesExist(COLOCATED_TEST_GLOB),
+        () => {
+          ensureScript("test", "vitest run --passWithNoTests");
+          ensureDevDep("vitest", "catalog:");
+          ensureDevDep("@types/node", "*");
+        },
+        () => removeDep("vitest"),
+      ),
+  );
+
+  // vite/tsup-era artefacts: the canonical model builds via ts-builder, so the
+  // legacy `tsup`/`vite` devDeps and the top-level `tsup` bundler config block
+  // are dropped.
+  removeDep("tsup");
+  removeDep("vite");
+  removeField("tsup");
 
   enforceAlphabeticalOrder("dependencies");
   enforceAlphabeticalOrder("devDependencies");

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/root-catalog-bump.ts

@@ -26,12 +26,14 @@ import {
   generate,
   ensureCatalogLatest,
   ensureCatalogVersion,
+  pinCatalogToDependencyOf,
 } from "../engine/api";
 import { getActiveRunContext } from "../engine/builders";
 import {
   rootPnpmWorkspaceInitial,
   SDK_CATALOG_PACKAGES,
   INFRA_CATALOG_FLOOR,
+  DERIVED_CATALOG_PINS,
   RUNENV_PYTHON,
   RUNENV_PYTHON_VERSION,
 } from "./root-pnpm-workspace";
@@ -57,8 +59,17 @@ export function rootCatalogBumpRules(): void {
               // block's missing standard keys + overwrites the init
               // placeholder).
               for (const name of SDK_CATALOG_PACKAGES) ensureCatalogLatest(name);
+              // Derived catalog pins → the EXACT version their source package
+              // declares (e.g. `vue` from `@platforma-sdk/ui-vue`). OVERWRITES
+              // (seeds when absent, tightens a loose on-disk entry). Resolved
+              // by the prefetched `derivedPinLookup`; a no-op when absent
+              // (default refresh passes none). Must run AFTER ensureCatalogLatest
+              // — the source package's own version is bumped there first.
+              for (const pin of DERIVED_CATALOG_PINS) {
+                pinCatalogToDependencyOf(pin.entry, { of: pin.of, ofVersion: pin.ofVersion });
+              }
               // Curated infra floor → fixed version, ADD-IF-ABSENT (seeds
-              // shx/turbo/vitest/vue/changesets when missing; never touches a
+              // shx/turbo/vitest/changesets when missing; never touches a
               // version the block already pins).
               for (const [name, version] of Object.entries(INFRA_CATALOG_FLOOR)) {
                 ensureCatalogVersion(name, version);

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

@@ -38,7 +38,7 @@ export function rootPackageJsonInitial(_ctx: RunContext): Record<string, unknown
       // refresh → format flow); kept for compatibility.
       "update-sdk": "block-tools structure refresh --update-deps-only",
       update:
-        "block-tools structure refresh --update-deps-only && pnpm i && block-tools structure refresh && pnpm fmt",
+        "block-tools structure refresh --update-deps-only && pnpm i && block-tools structure refresh && pnpm i && pnpm fmt",
     },
     peerDependencies: {
       oxlint: "*",
@@ -79,12 +79,14 @@ export function rootPackageJsonRules(): void {
   // Deprecated in favour of `update`; kept for compatibility.
   ensureScript("update-sdk", "block-tools structure refresh --update-deps-only");
   // Full SDK-update flow: bump catalog (deps-only) → install → re-apply
-  // structure against the freshly-pulled deps → format the result, wrapped
-  // as one script. `pnpm fmt` (turbo run fmt) leaves the tree oxfmt-clean
-  // after the structural rewrite so a follow-up `pnpm check` passes.
+  // structure against the freshly-pulled deps → install AGAIN (the structural
+  // pass can add new devDeps — e.g. ts-builder/oxlint/oxfmt on a first
+  // migration — that `pnpm fmt` then needs on PATH) → format. Wrapped as one
+  // script. `pnpm fmt` (turbo run fmt) leaves the tree oxfmt-clean after the
+  // structural rewrite so a follow-up `pnpm check` passes.
   ensureScript(
     "update",
-    "block-tools structure refresh --update-deps-only && pnpm i && block-tools structure refresh && pnpm fmt",
+    "block-tools structure refresh --update-deps-only && pnpm i && block-tools structure refresh && pnpm i && pnpm fmt",
   );
 
   ensureDevDeps({

package/src/structure/rules/root-pnpm-workspace.ts

@@ -18,8 +18,8 @@
 // npm-latest for the SDK families) lives in the separate `onInitOrUpdate`
 // frame (`rootCatalogBumpRules`), which fires on init + update-deps only.
 
-import { ensureWorkspaceModulePaths, type RunContext } from "../engine/api";
-import { matchesBumpPattern } from "../engine/registry-client";
+import { ensureWorkspaceModulePaths, ensureCatalogAbsent, type RunContext } from "../engine/api";
+import { matchesBumpPattern, type DerivedCatalogPin } from "../engine/registry-client";
 
 /** SDK packages that live in the catalog (membership only — no versions).
  *  Init fetches npm latest for each; refresh leaves them as the lockfile has
@@ -62,14 +62,23 @@ export const INFRA_CATALOG_FLOOR: Record<string, string> = {
   shx: "~0.4.0",
   "@changesets/cli": "~2.29.8",
   vitest: "~4.0.18",
-  // The seeded ui depends on `vue` (catalog:). `@platforma-sdk/ui-vue` pins
-  // vue as an EXACT regular dependency (not a peer), so the block must pin the
-  // SAME exact version — a floated `~` lets the ui resolve a newer 3.5.x than
-  // ui-vue's, yielding two vue instances and a SdkPluginV3-vs-Plugin type
-  // clash in `main.ts`. Keep this in lockstep with ui-vue's vue pin.
-  vue: "3.5.24",
 };
 
+/** Catalog entries whose exact version is DERIVED from the version another
+ *  package declares for them (see `pinCatalogToDependencyOf`). Resolved on
+ *  init + update-deps and OVERWRITES the on-disk entry.
+ *
+ *  `vue`: the seeded ui depends on `vue` (catalog:). `@platforma-sdk/ui-vue`
+ *  pins vue as an EXACT regular dependency (not a peer), so the block must
+ *  pin the SAME exact version — a floated `~` lets the ui resolve a newer
+ *  3.5.x than ui-vue's, yielding two vue instances and a SdkPluginV3-vs-Plugin
+ *  type clash in `main.ts`. Deriving the pin from ui-vue's declared dep keeps
+ *  the block in lockstep with whatever vue ui-vue's npm-latest pins, with no
+ *  hand-maintained version here. */
+export const DERIVED_CATALOG_PINS: readonly DerivedCatalogPin[] = [
+  { entry: "vue", of: "@platforma-sdk/ui-vue" },
+];
+
 /** Catalog name of the python runenv. Added to a block's catalog only when
  *  the block carries a software module. Pinned to an EXACT version — updating
  *  the python runenv is an explicit author decision, never automatic. */
@@ -100,4 +109,11 @@ export function rootPnpmWorkspaceInitial(ctx: RunContext): Record<string, unknow
 
 export function rootPnpmWorkspaceRules(): void {
   ensureWorkspaceModulePaths();
+  // vite/tsup/vue-tsc-era catalog entries: the canonical toolchain (ts-builder
+  // owns vue-tsc; ts-builder + rolldown replace vite/tsup) does not use them.
+  // Drop the orphaned catalog keys — paired with the per-package `removeDep`
+  // so a migrated block sheds both the dep and its catalog entry.
+  ensureCatalogAbsent("vite");
+  ensureCatalogAbsent("tsup");
+  ensureCatalogAbsent("vue-tsc");
 }

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

@@ -16,6 +16,7 @@ import {
   ensurePeerDeps,
   ensureWorkspaceScopeDeps,
   removeDep,
+  removeScript,
   enforceAlphabeticalOrder,
   enforceFieldOrder,
   when,
@@ -38,8 +39,6 @@ export function uiPackageJsonInitial(ctx: RunContext): Record<string, unknown> {
       watch: "ts-builder build --target block-ui --watch",
       build: "ts-builder build --target block-ui",
       check: "ts-builder check --target block-ui",
-      // No `test`: the vitest `test` script is wired by the body rule ONLY
-      // when co-located test files exist (a freshly-init'd ui has none).
     },
     dependencies: {
       "@platforma-sdk/ui-vue": "sdk:",
@@ -51,7 +50,6 @@ export function uiPackageJsonInitial(ctx: RunContext): Record<string, unknown> {
     devDependencies: {
       "@milaboratories/ts-builder": "sdk:",
       "@milaboratories/ts-configs": "sdk:",
-      vitest: "catalog:",
     },
     peerDependencies: {
       typescript: "*",
@@ -77,9 +75,20 @@ export function uiPackageJsonRules(): void {
   ensureDevDeps({
     "@milaboratories/ts-builder": "sdk:",
     "@milaboratories/ts-configs": "sdk:",
-    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");
+
+  // vite-era artefacts: the canonical ui builds + dev-serves via ts-builder,
+  // so a legacy `vite` dep and the `preview` (vite preview) script are dropped.
+  removeDep("vite");
+  removeScript("preview");
+
   // 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
@@ -90,15 +99,27 @@ export function uiPackageJsonRules(): void {
   removeDep("@types/node");
 
   // ...but a ui WITH co-located unit tests (`src/**/*.test.ts`) needs the
-  // vitest `test` script AND node ambient types: re-add `@types/node` as a
-  // devDep so `types: ["node"]` in ui/tsconfig (wired under the same
-  // predicate) resolves the tests' `node:*` imports. A test-less ui keeps
-  // the lean default (no test script, no @types/node) and stays a fixpoint.
-  // Runs AFTER removeDep so the dev dep is not stripped.
-  when(whenFilesExist(COLOCATED_TEST_GLOB), () => {
-    ensureScript("test", "vitest run --passWithNoTests");
-    ensureDevDep("@types/node", "*");
-  });
+  // vitest `test` script, the `vitest` devDep, AND node ambient types: re-add
+  // `@types/node` as a devDep so `types: ["node"]` in ui/tsconfig (wired under
+  // the same predicate) resolves the tests' `node:*` imports. A test-less ui
+  // keeps the lean default (no test script, no vitest, no @types/node) and
+  // stays a fixpoint. Runs AFTER removeDep so the dev deps are not stripped.
+  //
+  // Skipped entirely for sdk-internal (in-monorepo) blocks: they own their test
+  // wiring under the monorepo's shared infrastructure — see model-package-json.
+  when(
+    ({ ctx }) => !ctx.isSdkInternal,
+    () =>
+      when(
+        whenFilesExist(COLOCATED_TEST_GLOB),
+        () => {
+          ensureScript("test", "vitest run --passWithNoTests");
+          ensureDevDep("vitest", "catalog:");
+          ensureDevDep("@types/node", "*");
+        },
+        () => removeDep("vitest"),
+      ),
+  );
 
   enforceAlphabeticalOrder("dependencies");
   enforceAlphabeticalOrder("devDependencies");