@platforma-sdk/block-tools 2.11.3 → 2.11.5

package/dist/v2/resolve_to_registry.d.ts

@@ -0,0 +1,37 @@
+import { BlockPackDevV2, BlockPackFromPackV2, BlockPackFromRegistryV2, BlockPackId } from '@milaboratories/pl-model-middle-layer';
+/** File written by `block-tools publish` into `block-pack/`, carrying the
+ * registry coordinates of the published version. Holds only the immutable
+ * coordinates (CDN serve URL + version id). No `channel`: channels are moving
+ * pointers in the registry — a version can be promoted/moved later — so the
+ * channel at publish time is transient state we can't pin here. Update-checking
+ * resolves the channel at read time (`BlockPackFromRegistryV2.channel` is
+ * optional; the watcher defaults stable → any). */
+export declare const PublishedCoordsFileName = "published.json";
+/** Registry coordinates persisted in `block-pack/published.json`. */
+export interface PublishedCoords {
+    /** CDN serve URL the block is fetched from (not the S3 upload bucket). */
+    registryUrl: string;
+    id: BlockPackId;
+}
+/**
+ * Builds the `published.json` payload. Pure (no filesystem) so it is unit
+ * testable.
+ */
+export declare function buildPublishedCoords(args: {
+    registryUrl: string;
+    id: BlockPackId;
+}): PublishedCoords;
+/** Writes `block-pack/published.json` into the given block-pack folder. */
+export declare function writePublishedCoords(blockPackDir: string, coords: PublishedCoords): Promise<void>;
+/**
+ * Resolves a local block locator (`dev-v2` or `from-pack-v2`) to its registry
+ * coordinates by reading `published.json`. `published.json` lives inside the
+ * block-pack directory (written there by `block-tools publish`), so for
+ * `from-pack-v2` we read it directly from `packUrl` (converted to a path at this
+ * Node boundary) — the structurer owns the layout, we do not re-derive it. For a
+ * `dev-v2` block folder it sits under
+ * `<folder>/block-pack/`. The facade's engine-generated `from-pack-v2`
+ * BlockPointer feeds this so a consumed block can be installed via the registry
+ * path. Throws when the block was never published.
+ */
+export declare function resolveToRegistry(locator: BlockPackDevV2 | BlockPackFromPackV2): Promise<BlockPackFromRegistryV2>;

package/dist/v2/source_package.d.ts

@@ -6,3 +6,15 @@ export declare function parsePackageName(packageName: string): Pick<BlockPackId,
 export declare function tryLoadPackDescription(moduleRoot: string, logger?: MiLogger): Promise<BlockPackDescriptionAbsolute | undefined>;
 export declare function loadPackDescriptionRaw(moduleRoot: string): Promise<BlockPackDescriptionRaw>;
 export declare function loadPackDescription(moduleRoot: string): Promise<BlockPackDescriptionAbsolute>;
+/** Folder name (under a consumed package root) holding the v2 block-pack artifacts. */
+export declare const BlockPackFolderName = "block-pack";
+/**
+ * Loads a block-pack description from a block-pack directory's `manifest.json`,
+ * resolving every relative entry against that directory to an absolute
+ * filesystem path. Takes the pack directory directly (the `from-pack-v2`
+ * pointer's `packUrl`) — the structurer owns the layout, so this does not
+ * re-derive `<root>/block-pack`. Counterpart to `loadPackDescription`, which
+ * reads the authoring `block` field from `package.json` and resolves against
+ * source.
+ */
+export declare function loadPackDescriptionFromManifest(blockPackDir: string): Promise<BlockPackDescriptionAbsolute>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.11.3",
+  "version": "2.11.5",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "license": "UNLICENSED",
   "bin": {
@@ -33,13 +33,13 @@
     "undici": "~7.16.0",
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
-    "@milaboratories/pl-http": "1.2.4",
-    "@milaboratories/pl-model-middle-layer": "1.30.8",
-    "@milaboratories/pl-model-backend": "1.4.8",
+    "@milaboratories/pl-model-backend": "1.4.9",
+    "@milaboratories/pl-model-middle-layer": "1.30.9",
     "@milaboratories/pl-model-common": "1.46.2",
-    "@milaboratories/resolve-helper": "1.1.3",
     "@platforma-sdk/blocks-deps-updater": "2.2.0",
-    "@milaboratories/ts-helpers": "1.8.3"
+    "@milaboratories/pl-http": "1.2.4",
+    "@milaboratories/ts-helpers": "1.8.3",
+    "@milaboratories/resolve-helper": "1.1.3"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
@@ -55,8 +55,8 @@
     "vite-plugin-dts": "^4.5.3",
     "vitest": "^4.1.3",
     "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-configs": "1.2.3",
-    "@milaboratories/ts-builder": "1.5.2"
+    "@milaboratories/ts-builder": "1.6.0",
+    "@milaboratories/ts-configs": "1.3.0"
   },
   "scripts": {
     "build": "vite build",

package/src/cmd/publish.test.ts

@@ -0,0 +1,35 @@
+import { test, expect } from "vitest";
+import * as os from "node:os";
+import * as path from "node:path";
+import fsp from "node:fs/promises";
+import { publishCommand } from "./publish";
+
+function option(cmd: ReturnType<typeof publishCommand>, long: string) {
+  return cmd.options.find((o) => o.long === long);
+}
+
+test("publish keeps --registry required and adds a required --registry-serve-url", () => {
+  const cmd = publishCommand();
+  expect(option(cmd, "--registry")?.mandatory).toBe(true);
+  expect(option(cmd, "--registry-serve-url")?.mandatory).toBe(true);
+});
+
+test("publish errors when the serve URL is absent", async () => {
+  // A real manifest file so the action's read never runs — parsing must reject
+  // on the missing required --registry-serve-url before any registry I/O.
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "publish-flags-"));
+  const manifestPath = path.join(dir, "manifest.json");
+  await fsp.writeFile(manifestPath, "{}");
+
+  // Clear the env binding so the mandatory check, not the environment, decides.
+  const prev = process.env.PL_REGISTRY_SERVE_URL;
+  delete process.env.PL_REGISTRY_SERVE_URL;
+  try {
+    const cmd = publishCommand().exitOverride();
+    await expect(
+      cmd.parseAsync(["-r", "s3://bucket", "-m", manifestPath], { from: "user" }),
+    ).rejects.toThrow(/registry-serve-url/i);
+  } finally {
+    if (prev !== undefined) process.env.PL_REGISTRY_SERVE_URL = prev;
+  }
+});

package/src/cmd/publish.ts

@@ -9,6 +9,7 @@ import {
 } from "@milaboratories/pl-model-middle-layer";
 import { storageByUrl } from "../io/storage";
 import { BlockRegistryV2 } from "../v2/registry/registry";
+import { buildPublishedCoords, writePublishedCoords } from "../v2/resolve_to_registry";
 import path from "node:path";
 
 function simpleDeepMerge<T extends Record<string, unknown>>(
@@ -45,6 +46,14 @@ export function publishCommand(): Command {
       .env("PL_REGISTRY")
       .makeOptionMandatory(),
   );
+  cmd.addOption(
+    new Option(
+      "--registry-serve-url <url>",
+      "CDN serve URL written into block-pack/published.json (npm-consumed blocks)",
+    )
+      .env("PL_REGISTRY_SERVE_URL")
+      .makeOptionMandatory(),
+  );
   cmd.option("-m, --manifest <path>", "manifest file path", `./block-pack/${ManifestFileName}`);
   cmd.option("-v, --version-override <path>", "override package version");
   cmd.addOption(
@@ -90,6 +99,17 @@ export function publishCommand(): Command {
       await registry.addPackageToChannel(manifest.description.id, StableChannel);
     }
 
+    // Write registry coordinates next to the manifest so npm consumers can
+    // resolve the published block via `resolveToRegistry`. Written before
+    // returning so `npm publish`'s tarball generation (after prepublishOnly)
+    // picks it up.
+    const coords = buildPublishedCoords({
+      registryUrl: flags.registryServeUrl,
+      id: manifest.description.id,
+    });
+    await writePublishedCoords(manifestRoot, coords);
+    logger.info(`Wrote published coordinates to ${path.resolve(manifestRoot, "published.json")}`);
+
     if (flags.refresh) await registry.updateIfNeeded();
   });
 

package/src/structure/__tests__/discovery-shortname.test.ts

@@ -36,10 +36,13 @@ describe("DISCOVERY: shortName from the block package name", () => {
       // Nameless root — the standalone shape; classified `root` by path.
       "package.json": "{}",
       // Legacy block package: name IS the bare facade, no `.block` suffix.
+      // Classified `block` via its top-level `block` field (every real block —
+      // legacy shim or migrated facade — carries one).
       "block/package.json": JSON.stringify({
         name: "@platforma-open/test-org.legacy",
         files: ["index.d.ts", "index.js"],
         dependencies: { "@platforma-sdk/block-tools": "*" },
+        block: { components: {}, meta: {} },
       }),
     });
     const ctx = discoverRunContext({ fs, isSdkInternal: false });

package/src/structure/__tests__/facade-end-state.test.ts

@@ -0,0 +1,195 @@
+// Facade end-state coverage — the slim `block/` the structurer emits and
+// enforces: block-scope detection by the top-level `block` field, the four-file
+// `src/` surface + facade `tsconfig.json`, the slim publishable `package.json`,
+// sibling privacy, and legacy-shim cleanup.
+
+import { describe, test, expect } from "vitest";
+import type { BlockVars, RunContext } from "../engine/api";
+import { classifyOne, type WorkspacePackage } from "../engine/discovery";
+import { STRUCTURE } from "../structure-definition";
+import { run as engineRun } from "../engine/runner";
+import { defaultTemplateProvider, simulateInit } from "../engine/testing";
+
+const TEMPLATES = defaultTemplateProvider();
+
+const VARS: BlockVars = {
+  facadeName: "@platforma-open/test-org.demo",
+  baseName: "test-org.demo",
+  npmOrg: "@platforma-open",
+  orgScope: "test-org",
+  shortName: "demo",
+};
+
+function pkg(path: string, pkgJson: Record<string, unknown>): WorkspacePackage {
+  return { path, pkg: pkgJson };
+}
+
+describe("facade: block-scope detection by the top-level `block` field", () => {
+  test("a package with a top-level `block` field is classified `block`", () => {
+    expect(classifyOne(pkg("block", { name: "x", block: { components: {} } }))).toBe("block");
+  });
+
+  test("the `block` field wins over the model shape (the collision the order guards)", () => {
+    // A migrated facade carries `@platforma-sdk/model` (devDep) + `main`, which
+    // matches the model rule — the `block` field must take precedence.
+    expect(
+      classifyOne(
+        pkg("block", {
+          name: "x",
+          main: "./dist/index.js",
+          devDependencies: { "@platforma-sdk/model": "catalog:" },
+          block: { components: {} },
+        }),
+      ),
+    ).toBe("block");
+  });
+
+  test("a model-shaped package WITHOUT a `block` field is still `model`, not `block`", () => {
+    expect(
+      classifyOne(
+        pkg("model", {
+          name: "x.model",
+          main: "dist/index.cjs",
+          dependencies: { "@platforma-sdk/model": "catalog:" },
+        }),
+      ),
+    ).toBe("model");
+  });
+});
+
+describe("facade: four-file source surface + tsconfig", () => {
+  test("init emits the 4 src files + tsconfig, and no legacy shim", () => {
+    const { fs } = simulateInit({ vars: VARS });
+    for (const f of [
+      "block/src/index.ts",
+      "block/src/AGENTS.ts",
+      "block/src/block-extra.ts",
+      "block/src/agents-extra.ts",
+      "block/tsconfig.json",
+    ]) {
+      expect(fs.exists(f), `expected ${f} to be emitted`).toBe(true);
+    }
+    expect(fs.exists("block/index.js")).toBe(false);
+    expect(fs.exists("block/index.d.ts")).toBe(false);
+  });
+
+  test("index.ts carries the per-block model import path and PascalName aliases", () => {
+    const { fs } = simulateInit({ vars: VARS });
+    const index = fs.read("block/src/index.ts");
+    expect(index).toContain('import { platforma } from "@platforma-open/test-org.demo.model"');
+    expect(index).toContain("export type DemoBlockContract = BlockContract;");
+    expect(index).toContain("export const DemoBlockPointer = BlockPointer;");
+    expect(index).toContain('export * from "./block-extra"');
+  });
+
+  test("tsconfig extends the facade preset (singular `block/facade`)", () => {
+    const { fs } = simulateInit({ vars: VARS });
+    const tsconfig = JSON.parse(fs.read("block/tsconfig.json"));
+    expect(tsconfig.extends).toBe("@milaboratories/ts-configs/block/facade");
+  });
+});
+
+describe("facade: slim `package.json` end-state", () => {
+  test("is slim and carries the facade fields, scripts, and sibling devDeps", () => {
+    const { fs } = simulateInit({ vars: VARS });
+    const p = JSON.parse(fs.read("block/package.json"));
+
+    // Slim invariant: zero runtime dependencies.
+    expect(p.dependencies).toEqual({});
+
+    expect(p.type).toBe("module");
+    expect(p.files).toEqual(["dist", "block-pack"]);
+    expect(p.main).toBe("./dist/index.js");
+    expect(p.module).toBe("./dist/index.js");
+    expect(p.types).toBe("./dist/index.d.ts");
+    expect(p.exports).toEqual({
+      ".": {
+        sources: "./src/index.ts",
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js",
+      },
+    });
+
+    expect(Object.keys(p.scripts).sort()).toEqual(["build", "check", "do-pack", "prepublishOnly"]);
+    expect(p.scripts.build).toBe("ts-builder build --target block-facade && block-tools pack");
+    expect(p.scripts.check).toBe("ts-builder type-check --target block-facade");
+
+    // Siblings are build-time devDeps (workspace links), never runtime deps.
+    expect(p.devDependencies["@platforma-open/test-org.demo.model"]).toBe("workspace:*");
+    expect(p.devDependencies["@platforma-open/test-org.demo.ui"]).toBe("workspace:*");
+    expect(p.devDependencies["@platforma-open/test-org.demo.workflow"]).toBe("workspace:*");
+
+    // Author-owned seed + engine-managed components both present.
+    expect(p.block.components).toBeTruthy();
+    expect(p.block.meta).toBeTruthy();
+  });
+});
+
+describe("facade: `prepublishOnly` publish target branches on isSdkInternal", () => {
+  const AUX_DEV =
+    "block-tools publish -r s3://milab-euce1-prod-pkgs-s3-block-registry/aux/dev/?region=eu-central-1 --registry-serve-url https://aux-blocks.pl-open.science";
+
+  test("in-SDK blocks publish to the aux/dev registry, regardless of org", () => {
+    // `@milaboratories` would route to production via ORG_PUBLISH_TARGETS — the
+    // isSdkInternal branch must override that and send it to aux/dev.
+    const vars: BlockVars = {
+      facadeName: "@milaboratories/test-org.demo",
+      baseName: "test-org.demo",
+      npmOrg: "@milaboratories",
+      orgScope: "test-org",
+      shortName: "demo",
+    };
+    const { fs } = simulateInit({ vars, isSdkInternal: true });
+    const p = JSON.parse(fs.read("block/package.json"));
+    expect(p.scripts.prepublishOnly).toBe(AUX_DEV);
+  });
+
+  test("standalone blocks publish to their per-org production target", () => {
+    const open = simulateInit({ vars: VARS });
+    expect(JSON.parse(open.fs.read("block/package.json")).scripts.prepublishOnly).toBe(
+      "block-tools publish -r s3://milab-euce1-prod-pkgs-s3-block-registry/pub/releases/?region=eu-central-1 --registry-serve-url https://blocks.pl-open.science",
+    );
+
+    const milab = simulateInit({
+      vars: {
+        facadeName: "@milaboratories/test-org.demo",
+        baseName: "test-org.demo",
+        npmOrg: "@milaboratories",
+        orgScope: "test-org",
+        shortName: "demo",
+      },
+    });
+    expect(JSON.parse(milab.fs.read("block/package.json")).scripts.prepublishOnly).toBe(
+      "block-tools publish -r s3://milab-euce1-prod-pkgs-s3-block-registry/pub/releases/?region=eu-central-1 --registry-serve-url https://block.registry.platforma.bio/releases",
+    );
+  });
+});
+
+describe("facade: sibling package privacy", () => {
+  test("model / ui / workflow / test are `private` with no `version`", () => {
+    const { fs } = simulateInit({ vars: VARS });
+    for (const scope of ["model", "ui", "workflow", "test"]) {
+      const p = JSON.parse(fs.read(`${scope}/package.json`));
+      expect(p.private, `${scope} must be private`).toBe(true);
+      expect("version" in p, `${scope} must not carry a version`).toBe(false);
+    }
+  });
+});
+
+describe("facade: legacy shim cleanup on refresh", () => {
+  test("a refresh removes a pre-existing block/index.js + index.d.ts, then is idempotent", () => {
+    const { fs, ctx } = simulateInit({ vars: VARS });
+    // Inject the legacy boilerplate shim a pre-facade block would carry.
+    fs.write("block/index.js", "module.exports = { blockSpec: {} };\n");
+    fs.write("block/index.d.ts", "export declare const blockSpec: unknown;\n");
+
+    // Default-mode refresh (not dry-run): the engine's post-run recheck throws
+    // RecheckError if a second pass would change anything — so this asserts
+    // convergence too.
+    const refreshCtx: RunContext = { ...ctx, dryRun: false };
+    expect(() => engineRun(STRUCTURE, fs, refreshCtx, { templates: TEMPLATES })).not.toThrow();
+
+    expect(fs.exists("block/index.js")).toBe(false);
+    expect(fs.exists("block/index.d.ts")).toBe(false);
+  });
+});

package/src/structure/__tests__/model-package-json.snapshot.test.ts

@@ -9,7 +9,7 @@ import type { BlockVars } from "../engine/api";
 
 const EXPECTED_MODEL_PACKAGE_JSON = `{
   "name": "@platforma-open/test-org.demo.model",
-  "version": "1.0.0",
+  "private": true,
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/structure/engine/__tests__/discovery.test.ts

@@ -1,5 +1,5 @@
-// Workspace-package classification — covers all 7 detection rules
-// plus the block-scope override and the unclassified-error path.
+// Workspace-package classification — covers the detection rules plus the
+// block-scope override and the unclassified-error path.
 
 import { describe, test, expect } from "vitest";
 import { classifyOne, discoverModules, DiscoveryError, type WorkspacePackage } from "../discovery";
@@ -14,7 +14,7 @@ describe("discovery — single-package classification", () => {
       name: "x.software",
       "block-software": {},
     });
-    expect(classifyOne(wp, new Set())).toBe("software");
+    expect(classifyOne(wp)).toBe("software");
   });
 
   test("rule 1 alt: software via package-builder + runenv dep", () => {
@@ -25,67 +25,62 @@ describe("discovery — single-package classification", () => {
         "@platforma-open/runenv-python-3": "catalog:",
       },
     });
-    expect(classifyOne(wp, new Set())).toBe("software");
+    expect(classifyOne(wp)).toBe("software");
   });
 
-  test("rule 2: workflow via workflow-tengo dep", () => {
+  test("workflow via workflow-tengo dep", () => {
     const wp = pkg("workflow", {
       name: "x.workflow",
       dependencies: { "@platforma-sdk/workflow-tengo": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("workflow");
+    expect(classifyOne(wp)).toBe("workflow");
   });
 
-  test("rule 3: ui via ui-vue dep and no main", () => {
+  test("ui via ui-vue dep and no main", () => {
     const wp = pkg("ui", {
       name: "x.ui",
       dependencies: { "@platforma-sdk/ui-vue": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("ui");
+    expect(classifyOne(wp)).toBe("ui");
   });
 
-  test("rule 4: block via block-tools + sibling model/ui/workflow", () => {
-    const siblings = new Set(["x.model", "x.ui", "x.workflow"]);
+  test("block via the top-level `block` field", () => {
     const wp = pkg("block", {
       name: "x.block",
-      dependencies: {
-        "@platforma-sdk/block-tools": "catalog:",
-        "x.model": "workspace:*",
-        "x.ui": "workspace:*",
-      },
+      block: { components: {}, meta: {} },
     });
-    expect(classifyOne(wp, siblings)).toBe("block");
+    expect(classifyOne(wp)).toBe("block");
   });
 
-  test("rule 4 fallback: files=[index.d.ts,index.js] + block-tools", () => {
+  test("a block-tools-ish package WITHOUT a `block` field is not classified `block`", () => {
     const wp = pkg("block", {
       name: "x.block",
       files: ["index.d.ts", "index.js"],
       dependencies: { "@platforma-sdk/block-tools": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("block");
+    expect(classifyOne(wp)).toBeUndefined();
   });
 
-  test("rule 5: model via model dep + main", () => {
+  test("model via model dep + main", () => {
     const wp = pkg("model", {
       name: "x.model",
       main: "dist/index.js",
       dependencies: { "@platforma-sdk/model": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("model");
+    expect(classifyOne(wp)).toBe("model");
   });
 
-  test("rule 6: test via @platforma-sdk/test dep", () => {
+  test("test via @platforma-sdk/test dep", () => {
     const wp = pkg("test", {
       name: "x.test",
       devDependencies: { "@platforma-sdk/test": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("test");
+    expect(classifyOne(wp)).toBe("test");
   });
 
-  test("rule 7: root as catch-all", () => {
+  test("root as catch-all", () => {
     const wp = pkg("", { name: "x" });
-    expect(classifyOne(wp, new Set())).toBe("root");
+    expect(classifyOne(wp)).toBe("root");
   });
 
   test("override: block-scope wins over detection", () => {
@@ -94,7 +89,7 @@ describe("discovery — single-package classification", () => {
       "block-scope": "software",
       dependencies: { "@platforma-sdk/workflow-tengo": "catalog:" },
     });
-    expect(classifyOne(wp, new Set())).toBe("software");
+    expect(classifyOne(wp)).toBe("software");
   });
 
   test("override: bad value throws DiscoveryError", () => {
@@ -102,7 +97,7 @@ describe("discovery — single-package classification", () => {
       name: "x",
       "block-scope": "nope",
     });
-    expect(() => classifyOne(wp, new Set())).toThrow(DiscoveryError);
+    expect(() => classifyOne(wp)).toThrow(DiscoveryError);
   });
 
   test("unclassified non-root throws DiscoveryError", () => {
@@ -134,6 +129,7 @@ describe("discovery — full workspace", () => {
       }),
       pkg("block", {
         name: "x.block",
+        block: { components: {}, meta: {} },
         dependencies: {
           "@platforma-sdk/block-tools": "catalog:",
           "x.model": "workspace:*",

package/src/structure/engine/discovery.ts

@@ -25,6 +25,8 @@ export type PackageJsonLike = {
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
   optionalDependencies?: Record<string, string>;
+  // Top-level `block` field — the unambiguous facade marker.
+  block?: unknown;
   // Override field — value MUST be one of the seven scopes.
   "block-scope"?: string;
   "block-software"?: unknown;
@@ -61,11 +63,9 @@ function isRoot(p: string): boolean {
  * Classify one package.
  *
  * @param wp The workspace package.
- * @param siblingNames Set of all workspace package `name`s (used by
- *   rule 4 "block": depends on ≥2 sibling .model/.ui/.workflow).
  * @returns Scope or `undefined` if unclassified.
  */
-export function classifyOne(wp: WorkspacePackage, siblingNames: Set<string>): Scope | undefined {
+export function classifyOne(wp: WorkspacePackage): Scope | undefined {
   const override = wp.pkg["block-scope"];
   if (typeof override === "string") {
     if (!(ALL_SCOPES as string[]).includes(override)) {
@@ -88,6 +88,12 @@ export function classifyOne(wp: WorkspacePackage, siblingNames: Set<string>): Sc
   // sub-package dirs), so this only ever fires in standalone mode.
   if (isRoot(wp.path)) return "root";
 
+  // block (facade) — a top-level `block` field is the unambiguous facade
+  // marker; no non-facade workspace package carries one. MUST precede the model
+  // rule: a migrated facade carries `@platforma-sdk/model` as a devDep plus
+  // `main`, which would otherwise match model.
+  if (wp.pkg.block !== undefined) return "block";
+
   const deps = depKeys(wp.pkg);
 
   // 1. software — top-level `block-software` field OR
@@ -107,30 +113,10 @@ export function classifyOne(wp: WorkspacePackage, siblingNames: Set<string>): Sc
     return "ui";
   }
 
-  // 4. block — block-tools in deps AND ≥2 sibling .model/.ui/.workflow.
-  if (deps.has("@platforma-sdk/block-tools")) {
-    const matches = [...deps].filter(
-      (d) =>
-        siblingNames.has(d) &&
-        (d.endsWith(".model") || d.endsWith(".ui") || d.endsWith(".workflow")),
-    );
-    if (matches.length >= 2) return "block";
-    // Fallback: `files == ["index.d.ts", "index.js"]` + block-tools.
-    const files = wp.pkg.files;
-    if (
-      Array.isArray(files) &&
-      files.length === 2 &&
-      files.includes("index.d.ts") &&
-      files.includes("index.js")
-    ) {
-      return "block";
-    }
-  }
-
-  // 5. model — @platforma-sdk/model in deps AND main is set.
+  // 4. model — @platforma-sdk/model in deps AND main is set.
   if (deps.has("@platforma-sdk/model") && wp.pkg.main) return "model";
 
-  // 6. test — @platforma-sdk/test in deps.
+  // 5. test — @platforma-sdk/test in deps.
   if (deps.has("@platforma-sdk/test")) return "test";
 
   // (root — the workspace root, path "", is classified above, before the
@@ -144,13 +130,9 @@ export function classifyOne(wp: WorkspacePackage, siblingNames: Set<string>): Sc
  * package.json.
  */
 export function discoverModules(packages: WorkspacePackage[]): Module[] {
-  const siblingNames = new Set<string>();
-  for (const p of packages) {
-    if (typeof p.pkg.name === "string") siblingNames.add(p.pkg.name);
-  }
   const out: Module[] = [];
   for (const p of packages) {
-    const scope = classifyOne(p, siblingNames);
+    const scope = classifyOne(p);
     if (!scope) {
       throw new DiscoveryError(
         `Unclassified workspace package at '${p.path}'. ` +