diff --git a/.changeset/milab-6648-block-kinds-and-templates.md b/.changeset/milab-6648-block-kinds-and-templates.md
new file mode 100644
index 0000000000..969a17571b
--- /dev/null
+++ b/.changeset/milab-6648-block-kinds-and-templates.md
@@ -0,0 +1,93 @@
+---
+"@platforma-sdk/block-kind": minor
+"@milaboratories/pl-model-common": minor
+"@milaboratories/pl-model-middle-layer": minor
+"@milaboratories/pl-middle-layer": minor
+"@platforma-sdk/block-tools": minor
+"@milaboratories/ts-builder": minor
+"@platforma-sdk/model": minor
+---
+
+Block kinds and project templates.
+
+A **block kind** is a separately-versioned npm package declaring the typed init-params
+contract a block is created from; many block versions implement one kind version. On top
+of kinds sits the **template engine**: a project exports to `template-v1` YAML, and a
+template — exported or hand-authored — applies into a fresh project.
+
+**New package `@platforma-sdk/block-kind`.** `defineBlockKind<BlockParams>({ name,
+version, parseInitializationParams })` returns a frozen `CompiledBlockKind`. Source `name` /
+`version` from the kind's own `package.json` so the on-wire `{name}@{version}` cannot
+drift from what npm publishes.
+
+```ts
+// <block>/kind/src/index.ts
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { name, version } from "../package.json" with { type: "json" };
+
+export type BlockParams = { numbers?: number[] };
+const Params = z.object({ numbers: z.array(z.number()).optional() }).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
+```
+
+**`@platforma-sdk/model`** — the kind is now part of the model:
+
+```ts
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockDataV1>("v1")
+  .init(({ params }) => ({ numbers: params?.numbers ?? [] }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
+  .templateParams((data) => ({ numbers: data.numbers }))
+  .args(...)
+  .done();
+```
+
+`init` receives the kind's `params` (optional — a block may be created without a
+template) and builds the block's initial storage from them. `templateParams()` is the
+inverse: it projects block state back to the kind's params for export. Both are written in
+live terms — the SDK marks the column identifiers in what the lambda returned, so nothing about
+templates leaks into a block's own code.
+
+**`@milaboratories/pl-model-common`** — `BlockKindReference` + `formatKindRef`, the
+`template-v1` document schema, the kind selector's semver ranges, and the `{ $ref: … }` wrapper
+that marks a column identifier inside template params. `wrapTemplateRefs` puts those wrappers
+on, in the block's own bundle where the reference system is already known; the template engine
+stores what is inside verbatim and redirects the block ids textually, so it holds no model of
+that system at all.
+
+**`@milaboratories/pl-middle-layer`** — `MiddleLayer.exportProjectAsTemplate(id)` and
+`MiddleLayer.applyTemplateToProject(id, document)`, backing "Export Project as
+Template…" and "Create Project from Template…". The template import path is public:
+`parseProjectTemplateV1Yaml`, `validateTemplateV1ForApply`, `resolveTemplateEntries`, plus the
+`BlockPackProvider` seam deciding which registries to consult. Entries resolve against the configured registries, ids are mapped to the blocks
+they become, and each entry's params are offered to the block's kind for a shape check
+before anything is created.
+
+**`@platforma-sdk/block-tools`** — the `kind` part in `.structure` with its own package
+rules and scaffold, a `build-kind-manifest` command, kind-first publication (the kind
+content is written to the registry's `kinds/` tree, source-hash guarded and idempotent,
+before the facade — gated by a version-match check that hard-fails before any write),
+and registry-side kind resolution.
+
+**`@milaboratories/ts-builder`** — `block-kind` build target (rolldown config + tsconfig).
+
+**BREAKING:**
+
+- `BlockModelV3.create(dataModel)` → `BlockModelV3.create({ dataModel, kind })`. A block
+  cannot omit its kind.
+- `new DataModelBuilder()` → `new DataModelBuilder({ kind })`, and `init` takes
+  `({ params })` rather than no argument.
+- `templateParams()` is required — `done()` throws without it. A block whose state
+  cannot be reduced to params returns `{}` explicitly, rather than exporting an entry
+  that silently applies as a default-initialized block.
+- Every kind must declare `parseInitializationParams`. A kind whose params are genuinely empty
+  still declares one; it just rejects everything but `{}`.
+- Publishing a block whose model was compiled against a kind requires the facade to
+  declare that kind as a dependency, at a matching version. Blocks declaring no kind
+  publish exactly as before.
diff --git a/.changeset/milab-6648-example-blocks-declare-kind.md b/.changeset/milab-6648-example-blocks-declare-kind.md
new file mode 100644
index 0000000000..15b23e8969
--- /dev/null
+++ b/.changeset/milab-6648-example-blocks-declare-kind.md
@@ -0,0 +1,10 @@
+---
+"@milaboratories/milaboratories.monetization-test": patch
+"@milaboratories/milaboratories.pool-explorer": patch
+"@milaboratories/milaboratories.ui-examples": patch
+---
+
+Declare a block kind. Each block gains a `kind/` package holding its init-params
+contract, and its model is built with `new DataModelBuilder({ kind })` /
+`BlockModelV3.create({ dataModel, kind })` and projects its params back via
+`templateParams()`.
diff --git a/docs/block-kinds-templates/01-kind-and-lifecycle-implementation-path.md b/docs/block-kinds-templates/01-kind-and-lifecycle-implementation-path.md
new file mode 100644
index 0000000000..a5538e47f5
--- /dev/null
+++ b/docs/block-kinds-templates/01-kind-and-lifecycle-implementation-path.md
@@ -0,0 +1,838 @@
+# Track 1 — Kind + Lifecycle: Implementation Path
+
+**Status: implementation-path draft.** *Where* in the codebase to hook in, with pseudocode — not final code, and not the design. Companion to [`01-kind-and-lifecycle.md`](./01-kind-and-lifecycle.md) (the preamble; scope + open questions).
+
+**Authoritative design:** the `docs/text/work/projects/block-kind-and-templates/` mispec corpus — the **PR #198 rework** ("kind publishes with the facade", branch `feat/kind-publish-with-facade`, not yet on main). Produced by an adversarial multi-agent path-finding pass (2 architects + a judge per concern). Every entry point is cited as `path:line` — treat line numbers as anchors, they shift.
+
+> **Naming convention (reconciled in this doc):** `parseKindRef`/`formatKindRef` are the `{name}@{version}` **reference** codec — one home, `block_kind_ref.ts` (§3), imported by §4. `npmNameToKindPath` is the separate **npm-name → `{org,name}` path** helper — one home, `schema_kinds.ts` (§5), imported by §6. Two distinct functions; never one name for both.
+
+## Scope
+
+This document maps the **correct codebase entry points** for iteration-1 of the block-kind spec — the KIND subsystem end to end: **define** (`@platforma-sdk/block-kind` + `defineBlockKind`) → **build/bake reference** (kind build/pack target; bake the reference into `model.json` and the block manifest) → **publish + version-match** (kind-first publish flow with the pre-publish version gate) → **registry projection** (`kinds/` S3 tree + `overview.json` via the block reconciler) → **resolution** (middle-layer kind → concrete block resolution). The template engine (apply/export, `templateEntry`, the fixed native YAML lambda, and the add-block API) is a deliberate **follow-up document** and is not designed here. This is a **path-finding doc** — grounded entry points (`path:line`) plus pseudocode showing the shape to build — not a line-by-line implementation, and it does **not** decide final code. Every concern section carries its own "Risks & open" list; the cross-cutting and open-questions sections at the end collect what the whole path depends on. Grounded against the spec at `docs/text/work/projects/block-kind-and-templates/decisions.md` and `.../implementation.md`.
+
+## Dependency-Ordered Overview
+
+The six concerns form a mostly linear pipeline; each depends on the artifact the previous one produces.
+
+```
+1. sdk-kind          @platforma-sdk/block-kind + defineBlockKind
+                     → produces the compiled kind object (name/version imported from its package.json + phantom BlockParams type)
+                          │
+2. kind-build        ts-builder "block-kind" target + block-tools build-kind-manifest
+                     → bundles the kind, reads name/version from the kind's package.json for the manifest, computes src/ sourceHash, writes manifest.json
+                          │  (reads the kind's package.json; the bundler inlines the same import into kind.js)
+                          │
+3. model-wiring      DataModelBuilder(kind) + BlockModelV3.create({dataModel, kind})
+                     → bakes the {name}@X.Y.Z reference into model.json (container level) and the block manifest
+                          │  (consumes the kind object from #1; shares the reference type/codecs)
+                          │
+4. publish-flow      publishBlock() orchestrator: version-match gate → publishKind (kind-first) → publishPackage
+                     → hard-fails on a model↔facade kind-version mismatch before any S3 write
+                          │  (reads the model's baked kindRef from #3's manifest field; calls publishKind from #5)
+                          │  (source hash + manifest shape from #2)
+                          │
+5. registry-projection  publishKind (kinds/ tree, source-hash guard) + reconciler overview.json projection
+                     → derives per-kind overview.json (resolvable versions × implementing blocks by channel)
+                          │  (projection derived from the block manifest kind field from #3; ticket rides the block ticket)
+                          │
+6. resolution        pl-middle-layer resolveKind facade → block-tools kind_resolver (pure semver core)
+                     → reads one overview.json (from #5), resolves selector → newest kind version → newest impl block
+                        → emits a from-registry-v2 spec the existing add-block path consumes
+```
+
+Key cross-links:
+- **#1 → #2, #3**: the compiled kind object's runtime shape — the full npm `name` + `version` (imported from the kind package's `package.json`; **no** separate `organization` field, per **A-0052**) — is the contract both the build target and the model wiring read. The `{org,name}` registry path is derived from the npm name via `parsePackageName`. This shape is now settled, not an open dependency.
+- **#3 → #4, #5**: the reference type and its `{name}@X.Y.Z` string form live in one shared module (`block_kind_ref.ts`); the publish gate and the reconciler both read the baked reference (from `model.json`/manifest), never re-derive it.
+- **#5 → #6**: the `kinds/{org}/{name}/overview.json` schema is **co-designed** — the reconciler (#5) is the sole writer, the resolver (#6) the sole reader; they must stay in lockstep.
+- **#2, #4, #5** all share the **source-hash convention** (one sha256 over the sorted `src/` tree) and the **manifest-written-last commit-marker** pattern; the case convention (`.toUpperCase()`) is a live correctness seam across them.
+
+---
+
+## 1. Define — `@platforma-sdk/block-kind` + `defineBlockKind`
+
+**Entry points** — grounded path:line, what to add/modify at each.
+
+- `core/platforma/sdk/block-kind/package.json` **(NEW)** — mirror `sdk/test/package.json:1-46` (verified: `name`, `files:["dist/**/*"]`, `main`/`module`/`types` + single-arm `exports` map `types|require|import → dist/index.{d.ts,cjs,js}`, full ts-builder script block `build/watch/check/formatter:check/linter:check/types:check/do-pack/fmt`). Runtime `dependencies`: **exactly one** — `@milaboratories/pl-model-common: workspace:*`. `devDependencies`: `@milaboratories/build-configs`, `@milaboratories/ts-builder`, `@milaboratories/ts-configs` (workspace:*), `typescript`, `@types/node`, plus `vitest` + `@vitest/coverage-istanbul` (catalog:) for the type-level test. **Explicitly omit** `@platforma-sdk/model`, `@milaboratories/pl-middle-layer`, `pl-client`, `pl-tree`, `computable` — every heavy dep `sdk/test` carries.
+- `core/platforma/sdk/block-kind/tsconfig.json` **(NEW)** — copy `sdk/test/tsconfig.json` verbatim (verified: extends `@milaboratories/ts-configs/tsconfig.node.json`, `outDir ./dist`, `rootDir ./src`, `include:["src"]`).
+- `core/platforma/sdk/block-kind/src/descriptor.ts` **(NEW)** — the compiled type surface: `unique symbol` phantom brand, `CompiledBlockKind<BlockParams>` discriminated-union envelope (`kindSchema:"v1"` + runtime `name`/`version` + contravariant phantom slot), `InferBlockParams<K>` extractor.
+- `core/platforma/sdk/block-kind/src/index.ts` **(NEW)** — public surface: `defineBlockKind`, the `CompiledBlockKind`/`InferBlockParams` types, and `export type { PlRef } from "@milaboratories/pl-model-common"`. (PlRef grounded at `lib/model/common/src/ref.ts:5,26`, surfaced from that package's `index.ts:15` — verified.)
+- `core/platforma/sdk/block-kind/src/index.test.ts` **(NEW)** — type-level test locking `InferBlockParams`.
+- `core/platforma/pnpm-workspace.yaml:62` — add `- sdk/block-kind` immediately after `- sdk/eslint-config` (verified: sdk block is lines 58-62). The **only** edit to a pre-existing file.
+
+**Chosen path** — **Hybrid, leaning Proposal 2 on the type surface, Proposal 1 on file economy.**
+
+Both proposals are structurally identical (new `sdk/block-kind` sibling, trimmed-to-one-dep `sdk/test` skeleton, type-only PlRef re-export, phantom-generic descriptor, an explicit `meta` argument carrying `{ name, version }` — the final form settled by **A-0052**, see below — and one workspace-list line). I adopt:
+
+- **Proposal 2's contravariant phantom brand** (`readonly [BLOCK_PARAMS]?: (p: BlockParams) => void`) over Proposal 1's covariant `[BLOCK_PARAMS]?: BlockParams`. The function-parameter slot makes `BlockParams` contravariant under `strictFunctionTypes`, so a kind typed for `{ ref: PlRef; k: number }` is **not** silently assignable to one typed for `{ ref: PlRef }`. Zero runtime cost, strictly more type-safe. `InferBlockParams<K>` still recovers the declared params (single inference candidate).
+- **Proposal 2's discriminated-union envelope** (`kindSchema:"v1"`). The tag is one string field at near-zero cost and is the exact hook the deferred template-engine / sandbox phases use: they add a `CompiledBlockKindV2` union arm and consumers narrow on `kindSchema`, so v1 kinds keep compiling untouched. This reuses the schema-versioning pattern the code map flags for the workflow envelope.
+- **Proposal 1's file economy** over Proposal 2's four-file split. `refs.ts` holding a single `export type` line is pointless indirection. Land it as `descriptor.ts` (type surface + version union) + `index.ts` (`defineBlockKind` + re-exports). Two files, not four.
+- **`defineBlockKind<BlockParams>({ name, version })` takes a `{ name, version }` argument, sourced from the kind's own `package.json`** (settled by **A-0052** / Q-0005) — the kind's `src/index.ts` imports `{ name, version }` from `../package.json` (`with { type: "json" }`) and passes them straight in: `export const kind = defineBlockKind<Params>({ name, version })`. The bundler (rolldown, `external: () => false`) inlines that JSON import — tree-shaking it to just the two strings — into the compiled `kind.js`; there is **no** build-time injection and **no** rolldown/oxc `define`. The pseudocode below (the `meta: { name, version }` signature) is the **final** form, not an interim baseline. The anti-drift essence is preserved: identity comes from `package.json` (imported, never hand-typed literals).
+
+**Decisive rejection of the "inline PlRef" fork** that Proposal 1 floats as its main open con: do **not** inline the ~20-line PlRef type for a zero-dep package. That would fork the reference type and violate the spec's explicit "introduces no reference type of its own / reuse the existing PlRef." Keep `@milaboratories/pl-model-common` as the single runtime dependency, consumed **type-only** — see Risks for why "one dependency" holds despite its transitive tree.
+
+**Pseudocode**
+
+`src/descriptor.ts` (NEW):
+```ts
+// Phantom brand — declared, never assigned at runtime.
+declare const BLOCK_PARAMS: unique symbol;
+
+// Discriminated-union envelope. Future phases add a `"v2"` arm; consumers
+// narrow on `kindSchema`, so v1 descriptors never break.
+export interface CompiledBlockKindV1<BlockParams> {
+  readonly kindSchema: "v1";
+  readonly name: string;      // full npm package name; no separate organization field
+  readonly version: string;
+  // Contravariant phantom: carries BlockParams as a TYPE only, no runtime bytes,
+  // and blocks structural widening between kinds of different param shapes.
+  readonly [BLOCK_PARAMS]?: (p: BlockParams) => void;
+}
+
+export type CompiledBlockKind<BlockParams> = CompiledBlockKindV1<BlockParams>;
+
+// The contract the deferred DataModelBuilder.init / BlockModelV3.create
+// consumers use to pull BlockParams off a kind object.
+export type InferBlockParams<K> =
+  K extends CompiledBlockKind<infer P> ? P : never;
+```
+
+`src/index.ts` (NEW):
+```ts
+import type { CompiledBlockKind } from "./descriptor";
+export type { CompiledBlockKind, InferBlockParams } from "./descriptor";
+
+// Reuse the canonical reference type from its lightest owner — no new ref type.
+export type { PlRef } from "@milaboratories/pl-model-common";
+
+export function defineBlockKind<BlockParams>(meta: {
+  name: string;      // full npm package name
+  version: string;
+}): CompiledBlockKind<BlockParams> {
+  // Frozen, serializable v1 descriptor. Phantom slot is never assigned.
+  return Object.freeze({
+    kindSchema: "v1" as const,
+    name: meta.name,
+    version: meta.version,
+  });
+}
+```
+
+a kind author's own `src/index.ts` (usage — identity comes from `package.json`, never literals):
+```ts
+import { defineBlockKind, type PlRef } from "@platforma-sdk/block-kind";
+// The bundler (rolldown, external: () => false) inlines this JSON import — tree-shaken
+// to just the two strings — into the compiled kind.js. No build-time injection.
+import { name, version } from "../package.json" with { type: "json" };
+
+export const kind = defineBlockKind<{ ref: PlRef; n: number }>({ name, version });
+```
+
+`src/index.test.ts` (NEW):
+```ts
+import { expectTypeOf } from "vitest";
+import { defineBlockKind, type InferBlockParams, type PlRef } from "./index";
+
+const k = defineBlockKind<{ ref: PlRef; n: number }>({
+  name: "@platforma-open/milaboratories.demo.kind", version: "1.0.0",
+});
+// Locks the contract the future init/create wiring relies on.
+expectTypeOf<InferBlockParams<typeof k>>().toEqualTypeOf<{ ref: PlRef; n: number }>();
+```
+
+`package.json` (NEW, runtime-dep shape — the load-bearing part):
+```jsonc
+{
+  "name": "@platforma-sdk/block-kind",
+  "dependencies": { "@milaboratories/pl-model-common": "workspace:*" }, // exactly one
+  // heavy sdk/test deps deliberately absent: @platforma-sdk/model, pl-middle-layer, ...
+}
+```
+
+`pnpm-workspace.yaml` (edit at line 62):
+```yaml
+- sdk/eslint-config
+- sdk/block-kind      # ADD
+```
+
+**Why this over the alternatives**
+
+- **vs. inlining PlRef for a true zero-dep package** (Proposal 1's floated alternative): rejected — forks the reference type and directly violates the spec's "reuse the existing PlRef, introduce no reference type of its own." The single-source-of-truth requirement outranks a literal-zero-dependency reading.
+- **vs. Proposal 1's covariant phantom** (`?: BlockParams`): rejected — allows silent widening between kinds. The contravariant function-slot form is strictly safer at zero cost.
+- **vs. Proposal 2's four-file split**: rejected — a one-line `refs.ts` is dead indirection for a package this small. Two files carry the same forward-compat structure (version union lives in `descriptor.ts`).
+- **vs. adding `defineBlockKind` to `@platforma-sdk/model`**: rejected on blast radius and the hard constraint — it would pull the full SDK into every kind author. Grounded: `defineBlockKind`/`block-kind` exist nowhere (grep empty), so this is pure addition with zero regression surface in model/middle-layer. The only pre-existing-file change is one workspace line — fully reversible.
+
+Blast radius: 4 new files + 1 workspace line. Nothing existing changes behavior.
+
+**Risks & open**
+
+- **"One dependency" — literal vs. transitive.** `@milaboratories/pl-model-common` brings a moderate transitive tree (verified: `helpers`, `pl-error-like`, `canonicalize`, `es-toolkit`, `zod`) but **crucially not** `@platforma-sdk/model` or `pl-middle-layer`. Because PlRef is consumed via `export type`, ts-builder erases it — the emitted `dist/index.js`/`.cjs` import **nothing** external, so the runtime footprint is just the `defineBlockKind` factory. The dependency must stay a real `dependencies` entry (not `devDependencies`) because PlRef appears in block-kind's public `.d.ts`, so downstream consumers need it for type resolution. "Never pulls in the full SDK" holds structurally; "one dependency" holds as one direct runtime dep with zero emitted runtime imports.
+- **Type-only contract is convention, not enforced.** A careless future edit could `import { PlRef }` (value) and silently pull `zod`/`es-toolkit` into runtime. Mitigation: rely on `verbatimModuleSyntax` (from the shared `ts-configs`) + an `@typescript-eslint/consistent-type-imports` lint rule. **Open:** confirm the shared `ts-configs.node.json` / eslint-config already enforces type-only imports before treating this as guaranteed rather than conventional.
+- **Kind-reference string format is unverified.** Whether the recorded reference is `{name}@X.Y.Z` or `{organization}/{name}@X.Y.Z` is not settled against the model.json / manifest schema. Deliberately kept `name`/`version` as the source-of-truth fields (no separate `organization` field — the full npm name encodes org, per A-0052); the formatter belongs to the `BlockModelV3.create` / manifest wiring concern, not here. Do not guess it in this package.
+- **Q-0005 (kind build mechanism) — RESOLVED (A-0052).** `defineBlockKind<BlockParams>({ name, version })` takes a `{ name, version }` argument; the kind's `src/index.ts` imports `{ name, version }` from its own `package.json` (`with { type: "json" }`) and passes them in. The bundler (rolldown, `external: () => false`) inlines that JSON import — tree-shaken to the two strings — into the compiled `kind.js`; there is no build-time injection and no rolldown/oxc `define`. The `block-kind` build target needs no metadata knowledge and emits a hand-readable `.d.ts` on the stock `ts-builder build` toolchain with no new tooling; the public type contract is unchanged.
+- **Phantom is compile-time only.** No runtime guarantee that declared `BlockParams` matches actual usage — the `index.test.ts` type-level assertion is the guard that locks `InferBlockParams` inference against regression.
+
+---
+
+## 2. Build/Bake — Kind Build/Pack Target
+
+Verdict: **hybrid**. Take Proposal 1's minimal ts-builder half and its verified `hashDirSync` reuse; graft on Proposal 2's one real improvement — a commander-free core (`buildKindDist`) so the deferred publish-time guard reuses the exact hash + manifest shape. Reject Proposal 2's `hashDirSync` port and its `entries[]` parameterization (both refuted below).
+
+**Entry points** — grounded path:line, what to modify or add.
+
+- `core/platforma/tools/ts-builder/src/commands/utils/config-manager.ts:4` — add `"block-kind"` to the `TargetType` union (currently ends at line 11).
+- `config-manager.ts:39` — add a `block-kind` row to `TARGET_CONFIG_MAP` immediately after the `block-facade` row (36-39): `{ filename: "rolldown.block-kind.config.js", outputPath: "./build.block-kind.config.js" }`. (Naming convention confirmed: `rolldown.<target>.config.js` prefix + flat filename.)
+- `config-manager.ts:51` — add `"block-kind": "tsconfig.block-kind.json"` to `TSCONFIG_MAP`.
+- `config-manager.ts:182` — add `"block-kind": "node"` to `TARGET_TO_OXLINT_MAP` (reuse the `node` preset exactly as `block-facade` does at line 182). `OXLINT_CONFIG_MAP` needs **no** change — `node` already exists.
+- `core/platforma/tools/ts-builder/src/configs/utils/createRolldownBlockKindConfig.ts` — NEW. Copy of `createRolldownBlockFacadeConfig.ts` (which is already factored with an internal `entry()` helper + `props.output`) but returning a **single** entry `entry("kind", "src/index.ts")`. Keep `external: () => false` and `dts({ tsconfig: "tsconfig.json", emitDtsOnly: false, sourcemap: true })`. Emits `kind.js` + self-contained `kind.d.ts`.
+- `core/platforma/tools/ts-builder/src/configs/rolldown/block-kind.config.ts` — NEW. `export default defineConfig(createRolldownBlockKindConfig())` (sibling of `block-facade.config.ts`).
+- `core/platforma/tools/ts-builder/src/configs/tsconfig.block-kind.json` — NEW. Mirror `tsconfig.block-facade.json`.
+- `core/platforma/tools/ts-builder/src/commands/build.ts:36` — NO change. `block-kind` is not a vite target, so it falls through to `buildWithRolldown` automatically. Verify only.
+- `core/platforma/tools/block-tools/src/v2/build_kind_dist.ts` — NEW. Commander-free `buildKindDist(opts)` core: read `name`/`version` from the kind package's `package.json`, compute one sha256 over `src/` via the **reused** `util.hashDirSync`, assemble the manifest, write `manifest.json` **last** (build_dist.ts:82-90 commit-marker pattern). Beside `build_dist.ts`.
+- `core/platforma/tools/block-tools/src/cmd/build-kind-manifest.ts` — NEW. Thin commander wrapper (build-model.ts shape) delegating to `buildKindDist`.
+- `core/platforma/tools/block-tools/src/cli.ts:27` — import and `program.addCommand(buildKindManifestCommand())` alongside `buildModelCommand`/`packCommand`.
+- `core/platforma/tools/block-tools/src/structure/rules/block-package-json.ts:79` — **ACTIVATED (A-0053: kind is a confirmed block component).** The structurer discovers `kind/` alongside `model/`/`workflow/`/`ui/`, so this rule asserts `build: "ts-builder build --target block-kind && block-tools build-kind-manifest"`, `check: "ts-builder type-check --target block-kind"`, plus the `blockComponents` mapping for the kind.
+
+**Chosen path** — prose.
+
+The ts-builder half is Proposal 1 verbatim: a near-copy of the `block-facade` rows across the single closed registry (`config-manager.ts`), a single-entry `createRolldownBlockKindConfig.ts`, its thin config file, and a tsconfig template. No dispatch change. The facade's two-pass `index`/`AGENTS` split exists only because it has two entries; the kind has one, so the split is dropped and the code is strictly simpler.
+
+The block-tools half reuses `hashDirSync` from `@platforma-sdk/package-builder-lib` (confirmed already a `workspace:*` dependency at block-tools/package.json:46; exported as `util.hashDirSync` via index.ts:4) — **no port, no new dependency, no drift risk**. But the manifest logic is structured as Proposal 2 argued: a commander-free `buildKindDist()` core plus a thin `build-kind-manifest` command wrapper, because the deferred publish-time source-hash guard (a separate concern) must recompute and compare this exact hash and read this exact manifest shape. Embedding it in the command action (build-model.ts style) would force that concern to duplicate the logic; a commander-free core (build_dist.ts style) lets it `import` directly.
+
+Identity is read from the kind package's `package.json` — its `name` and `version` (no separate `org` field; the registry `{org,name}` path is derived downstream from the full npm name via `parsePackageName`). `buildKindDist` no longer imports the compiled bundle, so there is no ESM `await import()` deviation. The src-tree hash is written **upper-case** (`hashDirSync(src).digest("hex").toUpperCase()`) to match block-tools' `calculateSha256` convention (util.ts:33) so the future publish-side comparator never fails on a case mismatch.
+
+**Pseudocode.**
+
+```ts
+// config-manager.ts
+type TargetType = ... | "block-facade" | "block-kind" | ...;
+TARGET_CONFIG_MAP["block-kind"]   = { filename: "rolldown.block-kind.config.js",
+                                      outputPath: "./build.block-kind.config.js" };
+TSCONFIG_MAP["block-kind"]        = "tsconfig.block-kind.json";
+TARGET_TO_OXLINT_MAP["block-kind"] = "node";   // same preset block-facade uses
+```
+
+```ts
+// createRolldownBlockKindConfig.ts  (facade clone, single entry)
+export function createRolldownBlockKindConfig(props?): RolldownOptions[] {
+  const output = props?.output ?? "dist";
+  return [{
+    input: { kind: "src/index.ts" },
+    external: () => false,                                   // force-inline -> self-contained kind.d.ts
+    plugins: [dts({ tsconfig: "tsconfig.json", emitDtsOnly: false, sourcemap: true })],
+    output: { dir: output, format: "es", entryFileNames: "[name].js", sourcemap: true },
+    transform: { target: "ES2022" },
+  }];                                                        // emits kind.js + kind.d.ts
+}
+```
+
+```ts
+// block-tools/src/configs/rolldown/block-kind.config.ts
+export default defineConfig(createRolldownBlockKindConfig());
+```
+
+```ts
+// block-tools/src/v2/build_kind_dist.ts  (commander-free core)
+import { util } from "@platforma-sdk/package-builder-lib";   // hashDirSync already available
+export async function buildKindDist({ modulePath = ".", srcDir = "src", dst = "dist" }) {
+  const pkg = JSON.parse(await readFile(join(modulePath, "package.json"), "utf-8")); // read identity from package.json, not the bundle
+  if (!pkg?.name || !pkg?.version)                            // shape settled by A-0052: full npm name + version, no org field
+    throw new Error('kind package.json missing name/version');
+  const sourceHash = util.hashDirSync(srcDir).digest("hex").toUpperCase();  // match calculateSha256 case
+  const manifest = { schema, kind: { name: pkg.name, version: pkg.version }, // full npm name; {org,name} derived downstream via parsePackageName
+                     sourceHash, timestamp: Date.now() };
+  // ... (optionally per-artifact sha256 of kind.js/kind.d.ts via calculateSha256) ...
+  await writeFile(join(dst, "manifest.json"), JSON.stringify(manifest));    // LAST = commit marker
+}
+```
+
+```ts
+// block-tools/src/cmd/build-kind-manifest.ts  (thin wrapper)
+export function buildKindManifestCommand() {
+  return new Command("build-kind-manifest")
+    .option("-i, --modulePath <path>", "kind package dir", ".")
+    .action((flags) => buildKindDist({ modulePath: flags.modulePath }));
+}
+// cli.ts: program.addCommand(buildKindManifestCommand());
+```
+
+**Why this over the alternatives.**
+
+- **Reject Proposal 2's `hashDirSync` port.** Its stated rationale — "block-tools is a low-level published tool; depending on package-builder-lib inverts layering" — is refuted by block-tools/package.json:46: the dependency **already exists**. There is no layering to invert. Porting therefore only creates a second copy of a 30-line security-relevant algorithm that must be kept bit-identical to the canonical one (the publish-time guard compares against it), guarded by a "shared test vector + doc comment" maintenance obligation that reuse eliminates outright. Proposal 1's reuse is strictly lower blast radius and zero drift risk.
+- **Reject Proposal 2's `entries[]` parameterization.** Its claim that parameterizing avoids "re-opening the target registry" for deferred phases is false: the registry maps target -> config filename; adding entrypoints later means editing `createRolldownBlockKindConfig.ts`'s returned array, never the registry, regardless of whether an `entries` param exists. Nothing calls the factory with a custom entry set today, so the param is pure YAGNI. The facade itself hardcodes its entries — following that established pattern (hardcode, extend by editing the factory) is the lower-surface choice.
+- **Adopt Proposal 2's commander-free core.** This is its one substantive win. `buildBlockPackDist` (build_dist.ts) already establishes the commander-free-core precedent in this very package, and the deferred publish-time guard genuinely needs to reuse the hash computation and manifest shape without CLI coupling. Splitting `buildKindDist` (core) from `build-kind-manifest` (wrapper) costs one extra file and pays off directly at the next phase.
+- **Both proposals' shared choices are correct and kept:** single closed-registry edit (reviewable in one diff), no `build.ts` dispatch branch (non-vite -> rolldown fallback confirmed), `external:()=>false` + `dts({emitDtsOnly:false})` for the self-contained `kind.d.ts`, manifest-written-last commit marker, structurer activated (A-0053: kind is a confirmed block component).
+
+**Risks & open.**
+
+- **Q-0005 (kind build mechanism) — RESOLVED (A-0052).** `defineBlockKind<BlockParams>({ name, version })` takes a `{ name, version }` argument; the kind's `src/index.ts` imports `{ name, version }` from its own `package.json` (`with { type: "json" }`) and passes them in, and the bundler (rolldown + rolldown-plugin-dts, `external: () => false`) inlines that JSON import into the compiled `kind.js` — no build-time injection, no `define`. `buildKindDist` reads `name`/`version` directly from the kind package's `package.json` (not off the compiled bundle), so its manifest identity is written against a settled shape. **The earlier `organization`-vs-`org` field-name mismatch is resolved by elimination:** the compiled descriptor carries no separate organization/org field at all — only the full npm `name` + `version` — and the registry `{org,name}` path is derived from that npm name via the existing `parsePackageName` parser (`core/platforma/tools/block-tools/src/v2/source_package.ts`).
+- **Case convention is a live correctness seam.** `hashDirSync(...).digest("hex")` is lowercase; block-tools' `calculateSha256` is upper-case (util.ts:33). If the publish-time comparator (separate concern) hashes with one convention and compares against the other, the guard reports "different" on every run. Mitigation baked in: `.toUpperCase()` at the manifest-write site, documented there.
+- **Compiled-config filename mapping unverified end-to-end.** `TARGET_CONFIG_MAP` expects the flat `rolldown.block-kind.config.js`, but the source lives at `configs/rolldown/block-kind.config.ts`. The facade's identical convention works, so this is low-risk, but verify the ts-builder self-build emits the flat name before relying on it (`getConfigPath(filename)` resolution).
+- **Scope boundary (honored):** this concern produces the bundle, `kind.d.ts`, and `manifest.json` with its computed hash. The publish-time source-hash comparison (absent->store / equal->no-op / differ->hard-fail) and the S3 upload are the publication-lifecycle concern; the commander-free `buildKindDist` is shaped so that concern imports the hash + manifest shape without duplicating logic.
+
+---
+
+## 3. Bake Reference — Model→Kind Wiring, `model.json` + Block Manifest
+
+**Entry points** — grounded path:line, what to modify or add.
+
+- `core/platforma/lib/model/common/src/bmodel/block_kind_ref.ts` **(NEW)** — single shared home for the reference type + codecs: `BlockKindReference` (branded string, the on-wire form), `formatKindRef(kind) → "{name}@{version}"`, `parseKindRef(ref) → { name, version }`, and a `z.string()` schema. Export from the bmodel index. Every reader (model.json runtime path, manifest reconciler, future template engine) imports from here — the one place that decides whether the name segment is org-qualified.
+- `core/platforma/sdk/model/src/block_model.ts` (new local type) — `BlockKind<Params> = { reference: BlockKindReference; readonly __params?: Params }`. Minimal interface the SDK consumes so `sdk/model` stays decoupled from the `@platforma-sdk/block-kind` package (whose build mechanism is settled by A-0052 / Q-0005).
+- `core/platforma/sdk/model/src/block_migrations.ts:5` — `DataCreateFn<T> = () => T` → `DataCreateFn<T, Params = never> = (args: { params?: Params }) => T`. Object-arg so future fields (services, resolved refs) extend without a signature break.
+- `core/platforma/sdk/model/src/block_migrations.ts:181` (`MigrationChainBase.init`) — parameter becomes `DataCreateFn<Current, Params>`; thread a third `Params` generic through `MigrationChainBase` and its two subclasses + `DataModelInitialChain` (the same mechanism that already carries `Current`/`Transfers`).
+- `core/platforma/sdk/model/src/block_migrations.ts:498` (`DataModelBuilder`) — add `<Params>` generic + `constructor(kind: BlockKind<Params>)`. Store `kind.reference` on the builder; `from<T>()` seeds `Params` into the chain. Update the two JSDoc examples.
+- `core/platforma/sdk/model/src/block_migrations.ts` (`DataModel`, ~:530) — add a `Params` type generic AND a private `kindRef?: BlockKindReference` set via `FROM_BUILDER`, with an `@internal` getter. The type generic lets `create()` constrain its `kind` at compile time; the runtime field powers the value cross-check.
+- `core/platforma/sdk/model/src/block_model.ts:106` (`BlockModelV3Config`) — add `kind: BlockKindReference`.
+- `core/platforma/sdk/model/src/block_model.ts:170` (`BlockModelV3.create`) — positional → `create({ dataModel, kind })`; set `config.kind = kind.reference`; assert `kind.reference === dataModel.kindRef`. Constrain the type: `kind: BlockKind<Params>` where `Params` comes from `DataModel<Data, Params, Transfers>`.
+- `core/platforma/sdk/model/src/block_model.ts:607` (`done()`, non-UI branch) — set `kind: this.config.kind` at the **container** level of `blockConfig`, alongside `code` (NOT inside `v4`). Rides into model.json via the existing `JSON.stringify(config)` in build-model.ts — no write-path change.
+- `core/platforma/lib/model/common/src/bmodel/container.ts:6` (`BlockConfigContainer`) — add `readonly kind?: BlockKindReference;` next to `code`.
+- `core/platforma/tools/block-tools/src/v2/build_dist.ts:44` — add `modelKindReference(descriptionRelative, dst)`, a near-copy of `workflowRequiredCapabilities` (:22): read the model component's `model.json`, pull `container.kind`, fail-safe `undefined`. Set it on the description before `BlockPackManifest.parse` (:82).
+- `core/platforma/lib/model/middle-layer/src/block_meta/block_description.ts:15,36` — add `kind?: BlockKindReference` to the `BlockPackDescription` type and a `kind: z.string().optional()` to `CreateBlockPackDescriptionSchema`, mirroring `featureFlags` (:45).
+- `core/platforma/tools/block-tools/src/cmd/build-model.ts` — **no code change**; verify `kind` lands at container level in `dist/model.json`.
+- `blocks/clonotype-browser/model/src/dataModel.ts:38` and `.../index.ts:52` — migrate call sites to `new DataModelBuilder(kind)` + params-carrying init, and `BlockModelV3.create({ dataModel, kind })`.
+
+**Chosen path** — Hybrid, anchored on Proposal 2, with three corrections pulled from Proposal 1 / the code.
+
+Proposal 2 wins the two architecture decisions that matter for a spec with deferred phases, and both are grounded in the code, not preference:
+
+1. **Container-level bake, not `v4`.** `BlockConfigContainer` already carries version-independent payload at the container level — `code` (container.ts:12) lives beside `v4`/`v3`, orthogonal to the render envelope. Kind identity is the exact analogue of `code`: needed regardless of which config version renders, and a future `v5` inherits it for free. Placing it in `v4` (Proposal 1) forces `build_dist.ts` to reach into `config.v4.kind` — coupling to the render-envelope layout that Proposal 1 itself lists as a con. Container-level placement *removes* that coupling; the reader does `config.kind`.
+
+2. **One shared reference type + codecs, not an inline string in two files.** Both readers (runtime templateEntry, manifest reconciler) and the deferred template engine must agree on the reference shape. A shared `block_kind_ref.ts` is the single source of truth; `.passthrough()` on the description schemas is a tolerance, not a home.
+
+Three corrections to Proposal 2:
+
+- **Keep the wire form a string, faithful to the spec's `{name}@{version}`** (Proposal 1's shape), rather than storing structured `{name, version}` at rest. Readers overwhelmingly need identity equality (does block X implement kind Y?), for which an opaque canonical string is ideal and avoids premature version-aware logic. `formatKindRef`/`parseKindRef` in the shared module give parts to any reader that needs them, and localize the one open decision (is the name segment org-qualified?) to a single function.
+- **Make the divergence guard both compile-time and runtime.** Thread `Params` onto `DataModel` as a real type generic so `create({ dataModel, kind })` can constrain `kind: BlockKind<Params>` — a type mismatch between the builder's kind and create's kind fails at compile time. The runtime `kindRef` cross-check (Proposal 2) then catches value-level mismatch of two kind objects with the same param type. The builder is handed the object anyway (spec target `new DataModelBuilder(kind)`), so capturing its reference is nearly free.
+- **`Params = never`** (Proposal 2) over `unknown` (Proposal 1): stricter, and `{ params?: never }` correctly says "this block reads no params yet."
+
+**Pseudocode**
+
+```ts
+// NEW: lib/model/common/src/bmodel/block_kind_ref.ts
+export type BlockKindReference = string & { readonly __kindRef: unique symbol };
+export const BlockKindReferenceSchema = z.string();
+// single composition point for the {fullNpmName}@{version} reference (A-0052): the full npm name already encodes org, derived downstream via parsePackageName
+export const formatKindRef = (k: { name: string; version: string }) =>
+  `${k.name}@${k.version}` as BlockKindReference;
+export const parseKindRef = (r: BlockKindReference) => {
+  const at = r.lastIndexOf("@");
+  return { name: r.slice(0, at), version: r.slice(at + 1) };
+};
+```
+
+```ts
+// sdk/model/src/block_migrations.ts
+export type DataCreateFn<T, Params = never> = (args: { params?: Params }) => T;
+
+class DataModelBuilder<Params = never> {
+  readonly #kindRef: BlockKindReference;
+  constructor(kind: BlockKind<Params>) { this.#kindRef = kind.reference; }
+  from<T>(v: string): DataModelInitialChain<T, {}, Params> {
+    return chain.seed({ kindRef: this.#kindRef /* value */ }); // Params flows via the type
+  }
+}
+
+// MigrationChainBase<Current, Transfers, Params>
+init(initialData: DataCreateFn<Current, Params>): DataModel<Current, Params, Transfers> {
+  return DataModel[FROM_BUILDER](initialData, this.transfers, this.kindRef);
+}
+```
+
+```ts
+// sdk/model/src/block_model.ts
+type BlockKind<Params> = { reference: BlockKindReference; readonly __params?: Params };
+
+interface BlockModelV3Config</*...*/> { /* ... */ kind: BlockKindReference; }
+
+static create<Data extends Record<string, unknown>, Params = never, Transfers = {}>(
+  args: { dataModel: DataModel<Data, Params, Transfers>; kind: BlockKind<Params> },
+): BlockModelV3</*...*/> {
+  const { dataModel, kind } = args;
+  // runtime guard: builder-kind vs create-kind value identity
+  if (dataModel.kindRef && dataModel.kindRef !== kind.reference)
+    throw new Error(`kind mismatch: model ${dataModel.kindRef} vs ${kind.reference}`);
+  return new BlockModelV3({ /* ...defaults */, dataModel, kind: kind.reference });
+}
+
+// done(), non-UI branch — container level, beside `code`
+const blockConfig: BlockConfigContainer = {
+  v4: { configVersion: 4, /* unchanged */ },
+  kind: this.config.kind,        // <-- baked into model.json via JSON.stringify(config)
+  sdkVersion: PlatformaSDKVersion, renderingMode: /*...*/, sections: /*...*/, outputs: /*...*/,
+};
+```
+
+```ts
+// tools/block-tools/src/v2/build_dist.ts  (near-copy of workflowRequiredCapabilities)
+async function modelKindReference(desc, dst): Promise<BlockKindReference | undefined> {
+  const model = desc.components.model;              // relative path into dst (block_components.ts:72)
+  try {
+    const cfg = JSON.parse(await fsp.readFile(path.resolve(dst, model.path), "utf-8"));
+    return cfg.config?.kind ?? undefined;           // container-level, fail-safe
+  } catch { return undefined; }
+}
+// inside buildBlockPackDist, before BlockPackManifest.parse:
+const kindRef = await modelKindReference(descriptionRelative, dst);
+if (kindRef) descriptionRelative.kind = kindRef;    // top-level, like featureFlags
+```
+
+```ts
+// block_description.ts — mirror featureFlags
+export type BlockPackDescription<C, M> = { id; components: C; meta: M; featureFlags?; kind?: BlockKindReference };
+// schema:  kind: BlockKindReferenceSchema.optional(),
+```
+
+```ts
+// blocks/clonotype-browser/model — migrated call sites
+export const blockDataModel = new DataModelBuilder(kind)
+  .from<StoredV1>("v1")
+  .init(({ params }) => params ?? { /* defaults */ });
+export const platforma = BlockModelV3.create({ dataModel: blockDataModel, kind }).args(/*...*/).done();
+```
+
+**Why this over the alternatives**
+
+- **Rejected Proposal 1's `v4`-level bake.** It couples `build_dist.ts` to the render-envelope layout (a con Proposal 1 states), and it conflates block identity with render versioning. `code` at container level (container.ts:12) is the grounded precedent for the opposite. Blast radius is identical; container placement is strictly cleaner.
+- **Rejected Proposal 2's structured-at-rest reference.** The spec names the reference `{name}@{version}` — a string. Readers need equality/grouping, not arithmetic on version parts. Structured storage invites premature version logic and multiplies the shape across the wire. A shared type + `format`/`parse` codecs captures the single-source-of-truth benefit at the string form the spec asks for.
+- **Rejected the "drop the second kind param, derive create's ref from dataModel" purist option.** It diverges from the spec target `create({ dataModel, kind })`. Instead the double-pass is turned from a footgun into a compile-time constraint (`kind: BlockKind<Params>`) plus a runtime assert.
+- Both proposals correctly reuse the `workflowRequiredCapabilities` mirror precedent (build_dist.ts:22-72) and the `featureFlags` optional-field precedent (block_description.ts:45); the manifest path is low-novelty either way.
+
+**Risks & open**
+
+- **Q-0005 (kind build mechanism / kind object shape) — RESOLVED (A-0052).** The compiled kind object exposes runtime `{ name, version }` — the full npm `name` + `version` imported from the kind package's `package.json` (via `defineBlockKind({ name, version })`) — plus a phantom `Params` type; there is no separate `organization` field. The reference format is settled as `{fullNpmName}@X.Y.Z`: the full npm name already encodes org, so no separate org-qualification segment is needed, and the `{org,name}` path is derived downstream via `parsePackageName`. `formatKindRef` remains the single composition point for the reference string.
+- **Runtime reader coupling — NEEDS VERIFICATION.** Container-level placement assumes the runtime reader (templateEntry / `extractConfigGeneric`) can read `config.kind` off the container. If that reader is hard-wired to descend into `v4`, fall back to `BlockConfigV4Generic.kind` (Proposal 1's location). Verify before implementing; it decides one line in two files.
+- **Migration sequencing.** Making `DataModelBuilder`'s constructor kind **required** breaks every existing V3 block at once (create's object-destructure is likewise breaking). Options: (a) required + one codemod sweep across all V3 blocks; (b) a transition window with `constructor(kind?)` and fail-safe `undefined` reference (reconciler simply can't project kind-less blocks yet, matching the workflowCapabilities fail-safe). Legacy V1 blocks (block_model_legacy.ts) must reach V3 first — prerequisite, out of scope (see Cross-Cutting).
+- **Generic threading needs a compile check, not just a read.** Adding `Params` across `MigrationChainBase`, both subclasses, `DataModelInitialChain`, `DataModel`, and `create` must be verified to infer through `.from().migrate().transfer().init()` end to end.
+- **Two copies cannot actually drift** in the current build: `build_dist` reads the manifest reference *out of* the already-baked `model.json`, so there is one value source (done()'s container.kind). The cross-check guards the distinct risk of a block author passing two different kind objects (builder vs create), not copy divergence.
+- Out of scope (respected): PlRef / template-local→concrete rewrite of init params (template engine); the `@platforma-sdk/block-kind` package build itself (settled by A-0052, owned by #1/#2); the facade↔kind direct dependency (settled by A-0053 — kind is a fourth block component — owned by #4's `resolve-refs` and #2's structurer).
+
+---
+
+## 4. Publish + Version-Match — Kind-First Publish Flow
+
+**Entry points** — grounded path:line, what to modify or add at each.
+
+- `core/platforma/tools/block-tools/src/cmd/publish.ts:93` — MODIFY. Replace the single `await registry.publishPackage(manifest, fileReader)` call with `await publishBlock(registry, manifest, manifestRoot, fileReader)`. `manifestRoot` (already resolved at :84) is the facade cwd — the read root for the facade's declared kind dep. The channel marker (:97-100), coords write (:106-111) and refresh (:113) tail stays UNCHANGED and still runs only after `publishBlock` resolves. The action shrinks to flag-parse + adapter.
+- `core/platforma/tools/block-tools/src/v2/publish-block.ts` — NEW. Orchestrator `publishBlock(registry, manifest, facadeDir, fileReader)`: (1) resolve both refs, (2) run pure gate — throws before any I/O, (3) `registry.publishKind(...)` — S3 `kinds/` tree, idempotent, (4) `registry.publishPackage(...)` — facade, unchanged. This is the single forward-compat seam the deferred phases extend.
+- `core/platforma/tools/block-tools/src/v2/kind/version-match.ts` — NEW. Pure `checkKindVersionMatch(modelKindRef, facadeKindDep): void` throwing a typed `KindVersionMismatchError`; it **imports** `parseKindRef` (the `{name}@{version}` codec, §3) rather than redefining it. No I/O. Directly unit-tested with the `exitOverride`/`mkdtemp` harness already in `publish.test.ts` — and, being pure, tested with zero registry I/O.
+- `core/platforma/tools/block-tools/src/v2/kind/resolve-refs.ts` — NEW. `readModelCompiledKindRef(manifest)` reads `manifest.description.components.model`'s recorded kind ref (the field the record-kind-ref concern adds; no `model.json` re-read — same field the reconciler consumes). `readFacadeKindDependency(facadeDir)` reads the facade-side kind dep from `package.json`. This module is the single reader of the facade's **direct** kind dependency (A-0053: the kind is a fourth block component, so the facade declares the kind directly in its `dependencies`, not transitively through the model).
+- `core/platforma/tools/block-tools/src/v2/registry/registry.ts:474` — DEPENDENCY (owned by the S3-kinds concern, not authored here). `publishPackage` stays byte-for-byte unchanged. A sibling `publishKind(kindManifest, fileReader)` mirrors the content-first / manifest-last / `marchChanged` pattern PLUS a source-hash guard modeled on `addPackageToChannel:397-408` read-then-decide (absent → write; equal `sourceHash` → idempotent no-op; different → throw for immutability). This concern only CALLS it, kind-first.
+- `core/platforma/tools/block-tools/src/v2/registry/schema_public.ts:22` + `src/util.ts:28` — DEPENDENCY (S3-kinds concern). `kinds/` path-helper analogs of `packageContentPrefix`/`packageUpdateSeedPath`, and `hashSourceTree(srcDir)` folding one `calculateSha256` over the sorted src tree. Consumed by `publishKind`, not written here.
+
+**Chosen path** — Proposal 2 wins, with one blast-radius trim. The three-layer split (pure gate + facade-dep reader + orchestrator seam) is adopted because (a) the facade→kind dependency read deserves a single home — settled by A-0053 as a **direct** facade dependency, so any future change to how that read works stays in one place — and (b) the spec has deferred phases that will add more publishable artifacts and more pre-publish gates. Proposal 2 isolates (a) in one function and gives (b) a seam that is not a commander action. Proposal 1's inline approach couples the gate to the command harness and buries the facade-dep read inside `cmd.action`, making the load-bearing check testable only through a full command build.
+
+The trim vs. literal Proposal 2: `publishBlock` sequences only the two publishes and the gate. The channel marker, coords write and refresh tail stay in `publish.ts` unchanged — Proposal 2 folded them into the orchestrator, which is needless churn on code unrelated to kinds. `publishBlock` takes no `opts` bag yet (YAGNI — add parameters when a deferred phase needs one).
+
+Deliberate, confirmed-acceptable deviation from the literal spec wording: the gate runs before `publishKind`, i.e. before ANY S3 write, not merely before `publishPackage`. Both gate inputs are local reads (parsed manifest + facade `package.json` in cwd), so a mismatch leaves the registry byte-identical. This is a strict superset of "abort before facade" and still honors kind-before-facade on the write path.
+
+**Pseudocode**
+
+`publish.ts` (at :93, replacing the lone publishPackage call):
+```ts
+// was: await registry.publishPackage(manifest, (file) => read(manifestRoot, file));
+await publishBlock(
+  registry,
+  manifest,
+  manifestRoot,                       // facade cwd — prepublishOnly runs here
+  async (file) => Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file))),
+);
+// unchanged tail: stable-channel marker, published.json coords, refresh
+```
+
+`publish-block.ts` (NEW):
+```ts
+export async function publishBlock(registry, manifest, facadeDir, fileReader) {
+  // 1. resolve both refs (facade's direct kind dep read inside resolve-refs)
+  const modelKindRef  = readModelCompiledKindRef(manifest);        // components.model field
+  const facadeKindDep = readFacadeKindDependency(facadeDir);       // facade package.json
+
+  // 2. pure gate — hard-fail before ANY I/O
+  checkKindVersionMatch(modelKindRef, facadeKindDep);              // throws KindVersionMismatchError
+
+  // 3. kind FIRST — idempotent S3 kinds/ tree (source-hash guard inside publishKind)
+  await registry.publishKind(buildKindManifest(manifest), fileReader);
+
+  // 4. facade — unchanged behavior
+  await registry.publishPackage(manifest, fileReader);
+}
+```
+
+`version-match.ts` (NEW):
+```ts
+export class KindVersionMismatchError extends Error {}
+
+// reuse the SINGLE {name}@{version} codec from block_kind_ref.ts (§3) — do not fork it.
+// (that shared parseKindRef must guard a malformed ref: lastIndexOf("@") <= 0 -> throw.)
+import { parseKindRef } from "@milaboratories/pl-model-common"; // "{name}@X.Y.Z" -> { name, version }
+
+export function checkKindVersionMatch(modelKindRef, facadeKindDep) {
+  const m = parseKindRef(modelKindRef);
+  const f = parseKindRef(facadeKindDep);
+  if (m.name !== f.name || m.version !== f.version)   // exact match, no semver range
+    throw new KindVersionMismatchError(
+      `Kind version mismatch: model compiled against ${modelKindRef}, ` +
+      `facade declares ${facadeKindDep}. Rebuild the model against the declared kind.`,
+    );
+  // no soft path, no return value — success is "did not throw"
+}
+```
+
+`resolve-refs.ts` (NEW — reads the facade's direct kind dependency):
+```ts
+export function readModelCompiledKindRef(manifest) {
+  const ref = manifest.description.components.model?.kindRef;   // field from record-kind-ref concern
+  if (!ref) throw new Error("model component carries no compiled-against kind ref");
+  return ref;                                                    // "{name}@X.Y.Z"
+}
+
+export function readFacadeKindDependency(facadeDir) {
+  const pkg = JSON.parse(read(path.join(facadeDir, "package.json")));
+  // A-0053: the facade depends on the kind DIRECTLY (kind is a fourth block component),
+  // so read the direct dependency — no transitive-through-model fallback.
+  const dep = pkg.dependencies?.[KIND_PACKAGE_NAME];
+  if (!dep) throw new Error("facade declares no kind dependency");
+  return `${KIND_PACKAGE_NAME}@${normalizeRange(dep)}`;
+}
+```
+
+`registry.ts` `publishKind` (DEPENDENCY — shown for the contract this concern relies on):
+```ts
+public async publishKind(kindManifest, fileReader) {
+  const prefix = kindContentPrefix(kindManifest.id);            // kinds/{org}/{name}/{version}/
+  const existing = await this.storage.getFile(`${prefix}/${ManifestFileName}`);
+  if (existing !== undefined) {
+    const prev = parse(existing);
+    if (prev.sourceHash === kindManifest.sourceHash) return;    // idempotent no-op
+    throw new Error(`Immutable kind version republished with different content: ${prefix}`);
+  }
+  // ... content-first upload with per-file sha256 verify (copy of publishPackage:480-495)
+  await this.storage.putFile(`${prefix}/${ManifestFileName}`, ...);  // commit-marker LAST
+  await this.marchChanged(/* kinds-tree id */);                       // reconcile ticket
+}
+```
+
+**Why this over the alternatives** — Rejected Proposal 1 (inline into `cmd.action`) on two counts. Testability: it claims coverage via the `publish.test.ts` harness, but that forces the load-bearing version comparison through a full commander build + `mkdtemp` + a synthesized facade `package.json` — the pure `checkKindVersionMatch` is a far cleaner and cheaper test target, and the comparison is exactly the part most worth isolating. Change-locality: Proposal 1's `resolveFacadeKindDep` lives inside the action, whereas Proposal 2 keeps the facade-dep read in one isolated function — so with A-0053 settling that read as a **direct** facade dependency (and for any later tweak to it), the gate and orchestrator do not move. Proposal 1's only genuine win — fewer files — is marginal: the net-new logic (gate, resolver, orchestrator call) is nearly identical LOC either way; Proposal 2 just files it behind seams. Blast radius is equivalent for the risky part: both leave `publishPackage` untouched, both delegate `publishKind`/source-hash/`hashSourceTree`/`kinds/` path helpers to the S3-kinds concern. On correctness both are equal — linear `await` ordering gives kind-before-facade, a plain `throw` gives hard-fail, purity gives idempotency for the gate. The tie-breakers (isolable pure gate, single isolated facade-dep reader, non-command forward-compat seam matching the spec's deferred phases) all favor Proposal 2.
+
+**Risks & open**
+- **Q-0004 (facade↔kind direct dependency) — RESOLVED (A-0053, "the tetrad").** The kind is a fourth block component, and the published facade depends on the kind **directly** — a direct entry in the facade package's `dependencies`, not a transitive resolution through `model/package.json`. `readFacadeKindDependency` reads that direct dep (isolated in `resolve-refs.ts`), and the version-match compares it against the model's recorded kind reference. (The facade's `dependencies` was empty in the pre-decision blocks; the structurer now wires the kind dep in — see #2.)
+- **Hard dependency on the record-kind-ref concern (#3).** `readModelCompiledKindRef` reads `manifest.description.components.model.kindRef`, a field that does not exist yet (added by the build-model.ts / build_dist.ts record-kind-ref concern). This concern cannot land until that field is present; the gate has nothing to read otherwise.
+- **Hard dependency on the S3-kinds concern (#5).** `registry.publishKind`, the `kinds/` path helpers, the source-hash guard, and `hashSourceTree` are owned there. This concern owns only: (a) kind-before-facade call order, (b) the gate throwing before any write, (c) plain hard-fail, (d) idempotency delegated to `publishKind`'s guard.
+- **Q-0005 (kind build mechanism) — RESOLVED (A-0052).** `sourceHash` is a deterministic content hash over the kind's sorted `src/` tree, computed by a single producer at build time — this is what `hashSourceTree` folds over. npm publish of the kind rides `pnpm -r publish` topological order over the workspace (a new workspace package), NOT block-tools — block-tools owns only the S3 `kinds/` tree side. The source-hash input is now pinned; the gate and orchestrator are unaffected either way.
+- **Facade same-version overwrite remains unguarded.** `publishPackage:474-503` still does plain `PutObject` with no immutability guard. Only the `kinds/` tree gets the source-hash guard here; a reader expecting full block immutability from this concern will be surprised. Out of scope, flagged.
+- **Exact-match vs. range.** `checkKindVersionMatch` compares pinned `{name}@X.Y.Z` refs. In the workspace/monorepo case the facade→kind dep is a `workspace:*` (or `workspace:^`, etc.) spec; `readFacadeKindDependency` resolves it to the kind package's concrete `package.json` version before the gate, so the comparison is exact-equality on concrete versions. A raw semver range would likewise be normalized/resolved to a concrete version first — otherwise a legitimate range would spuriously hard-fail.
+
+---
+
+## 5. Registry Projection — `kinds/` Tree + `overview.json` via the Reconciler
+
+**Entry points** — grounded path:line, what to modify or add at each.
+
+- `core/platforma/tools/block-tools/src/v2/registry/registry.ts:474` — NEW `publishKind(kindManifest, fileReader)`, cloned from `publishPackage` (474-503): per-file size + sha256 verify (480-495), upload files, write `kind.d.ts`, write `kinds/{org}/{name}/{version}/manifest.json` LAST as the commit marker (mirrors 498-500). ADD a source-hash guard before writing (net-new — no same-version overwrite guard exists today). DO NOT call `marchChanged` (387).
+- `core/platforma/tools/block-tools/src/v2/registry/registry.ts:247` — inside the existing `newVersions` build (both required inputs already in hand: parsed manifest at 249, channels at 239-245), read `description.kind` and, when present, push `{blockId, version, kindVersion, channels}` into a `touchedKinds` accumulator keyed by `kindOverviewPath`. Zero extra manifest reads.
+- `core/platforma/tools/block-tools/src/v2/registry/registry.ts:162-172` — in the force branch only, after the existing v2/ block scan, LIST `kinds/*/*/overview.json` and seed each into `touchedKinds` with an empty entry set. The block scan already re-enumerates every kind ref (refs live *inside* block manifests), so this LIST exists solely to reset kinds orphaned by migration/removal.
+- `core/platforma/tools/block-tools/src/v2/registry/registry.ts:316` — NEW post-loop step (before the global-overview write at 319): for each touched kind, RMW `kinds/{org}/{name}/overview.json` — load existing (skip load in force mode), filter out the `(blockId, version)` entries updated this pass, re-add fresh ones bucketed by declared kind version, recompute `{stable, any}` per kind version by mirroring the `latestByChannel` + derived `AnyChannel` computation (301-315), write back (delete when the result is empty).
+- `core/platforma/tools/block-tools/src/v2/registry/schema_kinds.ts` (NEW) — `KindsPrefix='kinds/'`, `kindContentPrefix(org,name,version)`, `kindOverviewPath(org,name)`, `npmNameToKindPath` (strip trailing `.kind`, split dotted name → org/name), plus zod `KindManifest` (files + `sourceHash` + `firstUploadTimestamp`, `.passthrough()`) and `KindOverview` (kind versions × implementing block versions grouped `{stable, any}`, `.passthrough()`). Separate file, not sprinkled into `schema_public.ts:11/32`.
+- `core/platforma/lib/model/middle-layer/src/block_meta/block_description.ts:36` — add optional `kind: KindRef.optional()` to `CreateBlockPackDescriptionSchema` so the read at `registry.ts:249` is typed. `.passthrough()` already carries it; explicit declaration is the seam the reconciler depends on. Optional ⇒ kind-less blocks unaffected.
+- `core/platforma/lib/model/middle-layer/src/block_registry/overview.ts:27` — reuse `AnyChannel`/`StableChannel`/`VersionWithChannels`; define `KindRef {name, version}`. No new channel names.
+- `core/platforma/tools/block-tools/src/v2/registry/registry_reader.ts:66` — NEW `getKindOverview(kindNpmName)`: single read of `kinds/{org}/{name}/overview.json` (one-file, no-LIST), then client-side semver resolution (newest kind version satisfying the specifier → newest implementing block on stable-or-any). NOTE: `relativeReader` is rooted at `MainPrefix='v2/'` (74); `kinds/` is a sibling, so this needs an absolute read or a second kinds-rooted reader — verify at implementation time.
+- `core/platforma/tools/block-tools/src/cmd/publish.ts:88-113` — wire a kind-first publish step (construct registry, `publishKind`) ahead of the facade block publish. Kinds take no channel, so no `addPackageToChannel` call. (This is the same wiring concern #4 owns; the two concerns co-design the `publishKind` contract.)
+
+**Chosen path** — Hybrid, taking Proposal 2 ("Dedicated kinds/ module") as the base with one hardening decision made explicit.
+
+Both proposals converge on the same load-bearing mechanism, which I accept: the projection is derived from block manifests inside the *single existing* `updateRegistry` pass, via read-modify-write against each touched `kinds/{org}/{name}/overview.json` — no second reconciler, no `_updates_kinds`, no implementations marker tree. Normal mode is incremental-additive; force mode is the full-consistency backstop. This inherits the exact normal-incremental / force-full contract the package overview already runs on (222-265 for RMW, 301-315 for grouping).
+
+I pick Proposal 2 over Proposal 1 on two decisive points and one soft one:
+
+1. **Force mode as a *true* reconciler (correctness).** Proposal 1 says force mode "starts each touched kind empty" and relies on the block rescan to rebuild. But a kind that has lost *all* implementers is never touched by any block and was never seeded — so its stale `overview.json` survives even a force run. Proposal 2's force-mode `kinds/` LIST seeds every existing kind overview empty, so orphaned kinds are rewritten/deleted. That closes the one hole in the full-rebuild path for the cost of a single force-only LIST.
+
+2. **Correcting the map's KindManifestPattern claim (blast radius).** The code map lists a `KindManifestPattern` force-scan as required. Proposal 2 correctly observes it is *not* — kind refs live inside block manifests, so the pre-existing v2/ scan (162-172) already enumerates every ref. Dropping that pattern removes surface. I adopt this.
+
+3. **`schema_kinds.ts` (fit / forward-compat).** A genuinely new registry tree, plus the deferred template-engine/sandbox phases, justify a cohesive module over mirroring into `schema_public.ts`. Soft call; low stakes either way.
+
+Everything else is common to both and accepted verbatim: `publishKind` drops no ticket (projection rides the block ticket via `marchChanged`, honoring "no `_updates_kinds`"); the source-hash guard is net-new; the `kind` field is optional; backend has no part.
+
+**Pseudocode**
+
+`publishKind` (registry.ts:474, cloned from `publishPackage`):
+```ts
+async publishKind(kindManifest, fileReader) {
+  const { org, name } = npmNameToKindPath(kindManifest.name); // strip .kind, split dotted
+  const base = kindContentPrefix(org, name, kindManifest.version);
+
+  // NET-NEW source-hash guard (no same-version overwrite guard exists in publishPackage)
+  const existing = await this.tryReadKindManifest(base); // read manifest.json if present
+  if (existing) {
+    if (existing.sourceHash === kindManifest.sourceHash) return;          // no-op
+    throw new Error(`kind ${name}@${version} immutability violation`);     // hard-fail
+  }
+  // absent → proceed
+
+  for (const f of kindManifest.files) {          // e.g. kind.d.ts
+    const bytes = await fileReader(f.name);
+    assert(bytes.length === f.size);
+    assert(calculateSha256(bytes) === f.sha256); // per-file, as publishPackage
+    await this.upload(`${base}/${f.name}`, bytes);
+  }
+  // manifest LAST = commit marker; stamp firstUploadTimestamp when absent
+  await this.upload(`${base}/manifest.json`,
+                    KindManifest.parse({ ...kindManifest, firstUploadTimestamp: Date.now() }));
+  // NO marchChanged — projection is derived from BLOCK manifests, rides the block ticket
+}
+```
+
+Accumulate inside the existing pass (registry.ts:247, within `newVersions` build):
+```ts
+const desc = BlockPackManifest.parse(manifestBytes).description; // line 249, already parsed
+const channels = listedChannels;                                  // 239-245, already listed
+if (desc.kind) {
+  const { org, name } = npmNameToKindPath(desc.kind.name);
+  const path = kindOverviewPath(org, name);
+  const acc = touchedKinds.get(path) ?? { touched: new Set(), add: [] };
+  acc.touched.add(`${blockId}@${version}`);
+  acc.add.push({ blockId, version, kindVersion: desc.kind.version, channels });
+  touchedKinds.set(path, acc);
+}
+```
+
+Force-only orphan seed (registry.ts:162-172, force branch, after the v2/ block scan):
+```ts
+if (force) {
+  for (const p of await this.list(`${KindsPrefix}`)) {   // kinds/*/*/overview.json
+    if (isKindOverviewPath(p)) touchedKinds.set(p, { touched: null, add: [] }); // seed empty
+  }
+}
+```
+
+Post-loop write (registry.ts:316, before global-overview write at 319):
+```ts
+for (const [path, acc] of touchedKinds) {
+  const current = force ? emptyKindOverview() : (await this.readKindOverview(path) ?? emptyKindOverview());
+  // RMW, mirroring per-package filter+re-add (222-265)
+  const kept = acc.touched === null
+    ? []                                                    // force: full rebuild from scan
+    : current.entries.filter(e => !acc.touched.has(`${e.blockId}@${e.version}`));
+  const merged = [...kept, ...acc.add];
+
+  // bucket by kind version, then {stable, any} per bucket mirroring 301-315
+  const byKindVersion = groupBy(merged, e => e.kindVersion);
+  const kindVersions = Object.entries(byKindVersion)
+    .map(([kv, impls]) => ({
+      kindVersion: kv,
+      latestByChannel: newestPerChannel(impls),             // StableChannel slot
+      [AnyChannel]: newestRegardlessOfChannel(impls),       // derived any slot
+    }))
+    .sort((a, b) => compareSemver(a.kindVersion, b.kindVersion));
+
+  if (kindVersions.length === 0) await this.delete(path);   // orphaned → remove file
+  else await this.upload(path, KindOverview.parse({ kindVersions }));
+}
+```
+
+`getKindOverview` (registry_reader.ts:66):
+```ts
+async getKindOverview(kindNpmName, kindSpecifier) {
+  const { org, name } = npmNameToKindPath(kindNpmName);
+  const ov = await this.readAbsolute(kindOverviewPath(org, name)); // sibling of v2/, not via relativeReader
+  const kv = newestSatisfying(ov.kindVersions, kindSpecifier);     // client-side semver
+  return kv?.[AnyChannel] ?? kv?.latestByChannel[StableChannel];   // newest impl, stable-or-any
+}
+```
+
+**Why this over the alternatives**
+
+- **Rejected Proposal 1's force-empty-touched-only rebuild** — it leaves fully-orphaned kind overviews stale even after a force run, because an orphaned kind is touched by no block and was never seeded. The force-mode `kinds/` LIST (Proposal 2) is the minimal fix and turns force into a real reconciler. Cost: one LIST, force-path only.
+- **Rejected the map's `KindManifestPattern` force scan** — unnecessary surface. Kind refs live in block manifests; the existing v2/ scan enumerates them for free. Adding a parallel kind-manifest scan would duplicate work and invite the two enumerations to disagree.
+- **Rejected a separate kind reconciler / `_updates_kinds` ticket prefix** — the spec forbids it and it is genuinely unneeded: the projection's only inputs (kind ref + channels) are already in hand mid-pass, and block publish/channel ops already drop the ticket via `marchChanged`. Kind content publish stays inert (no ticket) by design.
+- **Rejected recomputing the source hash in `publishKind`** — the registry lacks `src/` at publish time; the guard trusts the build-time sorted-tree digest carried on the manifest. This is a dependency, not a defect, but it caps the guarantee (see risks).
+- **Chose `schema_kinds.ts` over mirroring into `schema_public.ts`** — a new tree plus deferred phases warrant a cohesive import surface. Reviewers expecting the in-place mirror may push back; the deviation is deliberate and cheap to reverse.
+
+**Risks & open**
+
+- **RMW correctness rests on block-version immutability of the kind ref.** Blocks have no same-version overwrite guard today (`publishPackage` 474-503). A same-version block republish that changes or drops its kind ref orphans the old kind's entry until a force reconcile. Mitigation adopted: force-mode LIST + full rebuild self-heals. Stronger fix (out of scope here, sibling concern): add a same-version block guard mirroring the new `publishKind` sourceHash guard.
+- **Normal-mode staleness window** for kindA→kindB switches / dropped refs is inherent to no-LIST incremental derivation. How often the force backstop runs is governed by **Q-0008 (overview-refresh trigger, implementation.md:354)** — settle with the operator; it directly sets the staleness bound.
+- **Source-hash guard is well-defined under A-0052 (Q-0005).** `sourceHash` is a deterministic content hash over the sorted `src/` tree, produced once at build time (explicitly NOT the per-file `calculateSha256` at util.ts:28). With that input pinned, the guard's absent / equal / differ decision is well-defined.
+- **Kind is invisible until it has an implementer** — `publishKind` drops no ticket, so `getKindOverview` 404s (no `overview.json`) for a kind with zero implementing blocks. Correct per the block-derived projection model, but confirm it is intended UX.
+- **Reader rooting unverified** — `registry_reader` is rooted at `MainPrefix='v2/'` (74); `kinds/` is a sibling. `getKindOverview` needs an absolute read or a second kinds-rooted reader. Quick check at implementation time.
+- **Empty vs delete on orphan** — pseudocode deletes the overview when no implementers remain (cleanest for the no-LIST reader: 404 ⇒ unresolvable). Writing an empty file is the alternative. Low-stakes; confirm preference.
+- **`npmNameToKindPath` convention** (strip trailing `.kind`, split dotted name → org/name) is net-new and unverified; a wrong split silently misfiles both content and projection. Pin it against the actual kind npm-naming convention (implementation.md:131) before shipping.
+
+---
+
+## 6. Resolution — Middle-Layer Kind → Concrete Block
+
+Verdict: **Proposal 2 wins (pure resolver core), with one graft from Proposal 1** — keep P2's IO-free `kind_resolver.ts` module, but lift the selector→range translation into a small named `selectorToRange` helper (P1) rather than folding it silently into `resolveKindVersion`, because the `@`→exact translation and the pre-1.0 caret / prerelease edges each deserve a testable seam. The two proposals are 90% identical (same files, same reuse, same output spec, same "distinct error cases"); the only real fork is *where the net-new version-math lives*. Since the code map flags this concern as **net-new, correctness-critical logic** (there is no existing range resolver to extend), isolating it as a pure, literal-testable unit is the deciding factor.
+
+### Entry points — grounded path:line, action
+
+- `core/platforma/tools/block-tools/src/v2/registry/schema_public.ts:11` — **ADD** `KindsPrefix = "kinds/"` beside `MainPrefix`.
+- `schema_public.ts:22,49` — **ADD** `kindOverviewPath({org,name})` = `kinds/{org}/{name}/overview.json` beside `packageOverviewPathInsideV2`. Reuse `npmNameToKindPath(npmName)` (npm-name → `{org,name}`, strips a trailing `.kind`, implementation.md:131) — defined **once** in §5's `schema_kinds.ts`; do not redefine it here, and do not conflate it with the `{name}@{version}` reference codec `parseKindRef` (§3).
+- `schema_public.ts:77-181` — **ADD** `KindOverviewRawSchema` + `parseKindOverviewReg` + `normalizeKindOverviewEntry`, cloning the `.passthrough()` + post-parse-normalize pattern of `GlobalOverviewEntryRawSchema`/`parseGlobalOverviewReg`. Derive the `any` channel slot once at parse time (union of stable+unstable per kind version).
+- `core/platforma/tools/block-tools/src/v2/registry/kind_resolver.ts:NEW` — **ADD** pure, IO-free module: `selectorToRange(selector)`, `resolveKindVersion(overview, range)` (`semver.maxSatisfying`), `pickImplementingBlock(entry, {allowUnstable})`. Returns a discriminated `Result` union (see error cases below). No FolderReader, no cache, no `semver` beyond range math — everything a caller can feed with a literal.
+- `registry_reader.ts:116` (after `listBlockPacks`) — **ADD** `readKindOverview(ref, {signal})` mirroring `listBlockPacks`' exact IO shape (verified: `readFile → Buffer→JSON.parse → parse*Reg`, retry `Retry2TimesWithDelay`, list-cache + stale-on-error at 124-183). Reuse the same cache/retry treatment.
+- `registry_reader.ts:215` (beside `getSpecificOverview`) — **ADD** `resolveKind(ref, {allowUnstable})` = `readKindOverview` → `kind_resolver` → return the **byte-identical** `from-registry-v2` spec shape at lines 232-237 (`{type:"from-registry-v2", id, registryUrl: this.registryReader.rootUrl.toString(), channel}`). Do **not** reuse `inferUpdateSuggestions` (tier logic, not range satisfaction).
+- `core/platforma/lib/node/pl-middle-layer/src/block_registry/registry.ts:290` — **ADD** facade `resolveKind(registryId, ref, {allowUnstable})` cloned from `getOverview` (resolve `registryId` → assert `remote-v2` → `v2Provider.getRegistry(url).resolveKind(...)`).
+- `registry-v2-provider.ts:9` — **NO CHANGE** (kind + impls co-reside per decisions.md:69; cached reader serves both).
+- `mutator/block-pack/block_pack.ts:123` — **NO CHANGE** (`from-registry-v2` output is already what `getComponents`/`prepareBlockPack` consume).
+
+### Chosen path (prose)
+
+A kind reference `{name}@{selector}` is resolved with **one projection read + client-side semver, then the existing v2/ fetch** — the spec's literal recipe. `readKindOverview` performs exactly one `readFile` against `kinds/{org}/{name}/overview.json`, cache/retry-wrapped identically to the block projection read. The parsed, normalized overview (kind versions × implementing blocks grouped by channel, with `any` derived) is handed to the pure `kind_resolver`. There, `selectorToRange` maps `@X.Y.Z`→`=X.Y.Z`, `~X.Y.Z`→`~X.Y.Z`, `^X.Y.Z`→`^X.Y.Z` (valid semver ranges — the spec redefines tier *meaning*, not range arithmetic, implementation.md:141); `resolveKindVersion` picks the newest in-range kind version via `semver.maxSatisfying`; `pickImplementingBlock` selects the target channel (`StableChannel` default, `AnyChannel` when the apply-time `allowUnstable` flag is set) and takes the newest block version there. The result is a `BlockPackId` wrapped into a `from-registry-v2` spec, which `prepareBlockPack` materializes through the unchanged add-block path via `getComponents`. No cross-registry intersection: kind and its blocks share one registry, so one cached reader answers both reads.
+
+Logic lives in `@platforma-sdk/block-tools`; only the thin facade lands in `pl-middle-layer` — consistent with the no-backend decision (decisions.md:15).
+
+### Pseudocode
+
+```ts
+// schema_public.ts
+export const KindsPrefix = "kinds/";
+export const kindOverviewPath = (loc: { org: string; name: string }) =>
+  `${KindsPrefix}${loc.org}/${loc.name}/overview.json`;
+// npm-name -> {org,name} is npmNameToKindPath, defined ONCE in schema_kinds.ts (§5). Import it.
+// It is NOT parseKindRef: parseKindRef parses the "{name}@{version}" reference string (§3).
+import { npmNameToKindPath } from "./schema_kinds"; // "@org/x.y.kind" -> { org, name }
+export const KindOverviewRawSchema = z.object({
+  versions: z.array(z.object({
+    version: z.string(),
+    implementingBlocks: z.object({
+      // channel -> newest block id per channel; "any" DERIVED at normalize
+      stable: z.array(BlockRef).optional(),
+      // ...other channels passthrough
+    }).passthrough(),
+  }).passthrough()),
+}).passthrough();
+export function parseKindOverviewReg(raw): KindOverview { /* parse + normalize + derive `any` */ }
+```
+
+```ts
+// kind_resolver.ts  (PURE — no IO, unit-tested with literals)
+export type KindResolution =
+  | { ok: true; blockId: BlockPackId; channel: string }
+  | { ok: false; reason: "no-matching-kind-version" }   // maxSatisfying === null
+  | { ok: false; reason: "no-implementation" }          // version exists, zero impls
+  | { ok: false; reason: "no-stable-implementation" };  // impls exist, none stable, !allowUnstable
+
+export function selectorToRange(sel: Selector): string {
+  switch (sel.op) {
+    case "exact": return `=${sel.version}`;   // @  -> exact
+    case "patch": return `~${sel.version}`;   // ~  -> patch floor
+    case "minor": return `^${sel.version}`;   // ^  -> minor floor
+  }
+}
+
+export function resolveKind(ov: KindOverview, sel: Selector, opt: {allowUnstable: boolean}): KindResolution {
+  const versions = ov.versions.map(v => v.version);
+  const picked = semver.maxSatisfying(versions, selectorToRange(sel)); // prerelease policy: see risks
+  if (!picked) return { ok: false, reason: "no-matching-kind-version" };
+  const entry = ov.versions.find(v => v.version === picked)!;
+  const channel = opt.allowUnstable ? AnyChannel : StableChannel;
+  const blocks = entry.implementingBlocks[channel] ?? [];
+  if (channel === StableChannel && blocks.length === 0) {
+    return (entry.implementingBlocks[AnyChannel]?.length ?? 0) > 0
+      ? { ok: false, reason: "no-stable-implementation" }
+      : { ok: false, reason: "no-implementation" };
+  }
+  if (blocks.length === 0) return { ok: false, reason: "no-implementation" };
+  const newest = blocks.reduce((a, b) => semver.gt(b.version, a.version) ? b : a);
+  return { ok: true, blockId: newest.id, channel };
+}
+```
+
+```ts
+// registry_reader.ts — thin IO adapter
+public async readKindOverview(ref, {signal} = {}) {
+  // mirror listBlockPacks 124-183: cache-check → retry(async () => parseKindOverviewReg(
+  //   JSON.parse(Buffer.from(await v2RootFolderReader.readFile(kindOverviewPath(ref), {signal}))))) → cache → stale-on-error
+}
+public async resolveKind(ref, {allowUnstable}) {
+  const ov = await this.readKindOverview(ref);
+  const r = resolveKind(ov, ref.selector, {allowUnstable});
+  if (!r.ok) throw new KindResolutionError(r.reason, ref);   // typed; caller maps to spec errors
+  return {                                                    // === getSpecificOverview shape (232-237)
+    type: "from-registry-v2",
+    id: r.blockId,
+    registryUrl: this.registryReader.rootUrl.toString(),
+    channel: r.channel,
+  };
+}
+```
+
+```ts
+// registry.ts — facade, cloned from getOverview 290-303
+public async resolveKind(registryId, ref, {allowUnstable}) {
+  const reg = this.getRegistryEntry(registryId).spec;
+  if (reg.type !== "remote-v2") throw new Error("kind resolution requires remote-v2 registry");
+  return this.v2Provider.getRegistry(reg.url).resolveKind(ref, {allowUnstable});
+}
+```
+
+### Why this over the alternatives
+
+- **Rejected P1 (inline methods on `RegistryV2Reader`)** on *fit + testability*, not blast radius (both touch the same files). The version-math + channel-selection is the net-new, error-prone core (`^0.x` semver quirk, prerelease inclusion, `@`→exact translation, three empty outcomes). P1 buries it inside a class method that needs FolderReader/LRUCache mocks to exercise; P2 makes it a pure function tested with a KindOverview literal — the highest-value test surface for genuinely new logic. P1's own con concedes `RegistryV2Reader` is already a large multi-responsibility class; adding resolution logic muddies its reader identity further. The verified codebase convention reinforces P2: `inferUpdateSuggestions` is a **top-level pure function**, not a method — pure version-math helpers already live at module scope here.
+- **Rejected P1's "smallest surface" framing** as decisive: one new file + a couple exports is trivial and fully reversible, and both proposals equally expand the `@platforma-sdk/block-tools` public API (both export `readKindOverview`/`resolveKind`). The surface delta is noise.
+- **Rejected P2's over-claim** that the template-engine batch loop (implementation.md:216) is a P2-only win — the LRU/list-cache on `readKindOverview` already dedupes repeated reads, so P1 would batch acceptably too. I did not weight this. P2 still wins on the pure-core testability alone.
+- **Grafted from P1**: the named `selectorToRange` helper (P2 folded it into `resolveKindVersion`). Naming it isolates the two correctness edges below.
+- **Added beyond both**: a *third* error outcome `no-matching-kind-version` (selector satisfies zero kind versions — `maxSatisfying` returns `null`). Both proposals modeled only the two block-implementation empty cases (implementation.md:145) and silently assumed a kind version always resolves. It may not.
+
+### Risks & open
+
+- **Pre-1.0 caret/tilde quirk (correctness, not raised by either proposal):** `semver` treats `^0.2.3` as `>=0.2.3 <0.3.0` (caret behaves like tilde below 1.0) and `~0.2.3` as `>=0.2.3 <0.3.0` as well — so for `0.x` kinds, `^` and `~` collapse to the same range. If the spec's "minor floats" tier must span `0.2 → 0.3` for pre-1.0 kinds, stock semver ranges will **not** deliver it. **Verify against the spec whether kinds are guaranteed `>=1.0.0`;** if not, `selectorToRange` needs an explicit range for the `0.x` minor case rather than `^`.
+- **Prerelease policy (open):** `semver.maxSatisfying` excludes prereleases (e.g. `1.2.0-rc.1`) from `^`/`~` ranges unless `{includePrerelease:true}`. Decide whether prerelease kind versions are eligible; wire the option in `selectorToRange`/`resolveKindVersion` accordingly. Default (exclude) is the safe assumption pending confirmation.
+- **Schema authored blind (co-design):** the `KindOverview` shape is *produced* by the block-overview reconciler/writer (concern #5, `tools/block-tools/src/v2/registry/registry.ts` ~line 250). `.passthrough()`+normalize tolerates additive drift but **not field renames**. Lock the reader schema against the reconciler's emitted JSON (or the spec's canonical example at implementation.md:116-131) before finalizing field names; reader and writer must stay in lockstep.
+- **Q-0005 (kind build mechanism) — RESOLVED (A-0052):** the projection this concern reads exists once kinds are built/registered and the reconciler emits `kinds/{org}/{name}/overview.json`. The build mechanism is now settled (`defineBlockKind<BlockParams>({ name, version })` takes a `{ name, version }` argument imported from the kind's `package.json`, deterministic `src/`-tree `sourceHash`), so the `KindOverview` schema and the channel-grouping assumption in `pickImplementingBlock` rest on a fixed shape. This resolver stays a pure *consumer* of that shape; its correctness now depends only on staying in lockstep with the reconciler (co-design, see above), not on any open build question.
+- **Deferred-phase reuse (unverified benefit):** the sandbox phase reusing the pure core unchanged is asserted, not proven; treat as a nice-to-have, not a design constraint.
+
+---
+
+## Cross-Cutting Concerns
+
+### Naming and paths
+
+- **New SDK package:** `@platforma-sdk/block-kind` at `core/platforma/sdk/block-kind/` (sibling of `sdk/test`, `sdk/model`, `sdk/eslint-config`). Registered in `pnpm-workspace.yaml:62`.
+- **Shared reference type:** `BlockKindReference` + `formatKindRef`/`parseKindRef` codecs live once in `core/platforma/lib/model/common/src/bmodel/block_kind_ref.ts` and are imported by the model wiring (#3), the publish gate (#4), the reconciler (#5), and the resolver (#6). This is the single place that decides whether the reference's name segment is org-qualified — do not fork it.
+- **On-wire reference form:** `{name}@X.Y.Z` string (spec `decisions.md:23`, `implementation.md:181`), recorded at the **container level** of `model.json` (beside `code`) and surfaced into the block manifest (`v2/{org}/{name}/{version}/manifest.json`).
+- **Registry tree:** `kinds/{org}/{name}/` parallel to `v2/` in the **same** registry (`implementation.md:113-121`). Per-version content at `kinds/{org}/{name}/{version}/` (`manifest.json` + `kind.d.ts`); the reconciler-maintained projection at `kinds/{org}/{name}/overview.json`.
+- **npm-name → path convention:** `@platforma-open/milaboratories.mixcr-clonotyping.kind` → dotted name `milaboratories.mixcr-clonotyping.kind`; first segment = org, middle = block name, strip trailing `.kind` → `kinds/milaboratories/mixcr-clonotyping/{version}/` (`implementation.md:131`). Encapsulated in `npmNameToKindPath` (distinct from the `{name}@{version}` reference codec `parseKindRef`); **unverified** — pin before shipping.
+- **Build target name:** `block-kind` in the ts-builder `TargetType` registry (parallel to `block-facade`); config files `rolldown.block-kind.config.js` / `tsconfig.block-kind.json`.
+- **Field-name mismatch — RESOLVED by elimination (A-0052 / Q-0005):** the compiled kind descriptor carries no separate `organization`/`org` field — only the full npm `name` + `version`. The registry `{org,name}` path is derived from that npm name via the existing `parsePackageName` parser (`core/platforma/tools/block-tools/src/v2/source_package.ts`), so there is no `organization`-vs-`org` naming to reconcile.
+
+### Versioning of `@platforma-sdk/block-kind`
+
+The spec requires the package be **additive-only** — new exports may be added, existing ones never change or disappear — which is what lets a kind published long ago keep compiling against it (`implementation.md:39`). The path enforces this structurally via the `kindSchema:"v1"` discriminated-union envelope (#1): future template-engine / sandbox phases add a `CompiledBlockKindV2` union arm and consumers narrow on `kindSchema`, so v1 kinds keep compiling untouched. The package follows the standard changesets-gated `pnpm -r publish` release path like every other SDK package; there is no bespoke versioning machinery. The kind *content* published to the S3 `kinds/` tree is a separate, immutable, source-hash-guarded artifact — do not conflate the npm package version of `@platforma-sdk/block-kind` (the tooling) with a kind's own `{name}@X.Y.Z` version (the contract).
+
+### V1 → V3 block-model migration prerequisite
+
+A block must be on **`BlockModelV3` + `DataModelBuilder`** to carry a kind: the kind object is threaded through `new DataModelBuilder(kind)` and `BlockModelV3.create({ dataModel, kind })`, and the init lambda is typed against the kind's `BlockParams` (`decisions.md:55`, `implementation.md:63`). Legacy `BlockModel` (V1) blocks (`block_model_legacy.ts`) have no such surface and **must migrate to V3 first**. This is a hard prerequisite that sits *outside* the kind subsystem — the kind wiring (#3) does not build the V1→V3 migration. Making `DataModelBuilder`'s constructor kind **required** (#3) is a breaking change to every existing V3 block simultaneously; the two migration-sequencing options are (a) required-kind + one codemod sweep across all V3 blocks, or (b) a transition window with `constructor(kind?)` and a fail-safe `undefined` reference (the reconciler simply can't project kind-less blocks yet, matching the `workflowCapabilities` fail-safe precedent). Choose the sequencing before landing #3.
+
+### Consistency with the mispec spec
+
+The path is grounded against `docs/text/work/projects/block-kind-and-templates/decisions.md` and `.../implementation.md`. Key alignments:
+
+- **TypeScript-only, no backend** (`decisions.md:15`, `implementation.md:7`) — every concern lands in the SDK / block-tools / middle-layer; `core/pl` is untouched. The resolver facade (#6) is the deepest the path reaches into the middle layer, and it is thin (`decisions.md:15`).
+- **Kind is a fourth block component; the facade depends on it directly** (A-0053, reversing note A-0013's earlier v4.0.0 "recorded in the model, not a fourth component" conclusion) — #3 still bakes the reference at the `model.json` container level for the runtime/export path, but the facade's **direct** build-time dependency on the kind is what the publish-time version-match reads (#4's `resolve-refs.ts`), and the structurer discovers `kind/` alongside `model/`/`workflow/`/`ui/` (#2).
+- **Kind-first publish, version-match gate, hard-fail** (`decisions.md:57-83`) — #4 sequences `checkKindVersionMatch` → `publishKind` → `publishPackage`, with the gate before *any* S3 write (a confirmed-acceptable strict superset of "abort before facade").
+- **Source-hash guard: one sha256 over the sorted `src/` tree, stored in the kind manifest, `absent→store / equal→no-op / differ→hard-fail`** (`decisions.md:73-83`, `implementation.md:273-283`) — computed at build (#2), enforced at publish (#4/#5). Explicitly **not** npm `dist.integrity`, `npm pack` bytes, or the Turbo hash.
+- **Projection is derived from block manifests, single source of truth, no `_updates_kinds`, no kind-side markers** (`decisions.md:103-107`, `implementation.md:123-129`) — #5 rides the block ticket via `marchChanged`; `publishKind` drops no ticket.
+- **Three version selectors with redefined-semver tiers** (`decisions.md:87-95`, `implementation.md:135-141`) — #6's `selectorToRange` maps `@/~/^` to exact/patch-floor/minor-floor; the spec redefines tier *meaning* (major=params-break, minor=behavior, patch=additive), not range arithmetic.
+- **Resolution reads one file, client-side semver, stable-by-default / allow-unstable, distinct error cases** (`decisions.md:99`, `implementation.md:145`) — #6 reads one `overview.json`, resolves with `semver.maxSatisfying`, and models the empty cases as a discriminated result union (extended with a third `no-matching-kind-version` case).
+
+---
+
+## Open Risks and Spec Open-Question Dependencies
+
+Two questions that gated this path when the draft was written are now **decided in the spec** and are no longer open:
+
+- **Q-0004 (facade↔kind direct dependency) — RESOLVED (decision A-0053, "the tetrad").** The kind is a fourth block component; the published facade depends on the kind **directly** (a direct entry in the facade package's `dependencies`), not transitively through the model. #4's `readFacadeKindDependency` (`resolve-refs.ts`) reads that direct dep and compares it against the model's recorded kind reference; #2's structurer rule (`block-package-json.ts`) is activated to discover `kind/` and wire/assert the kind build/check plus the `blockComponents` mapping.
+- **Q-0005 (kind build mechanism & identity) — RESOLVED (decision A-0052).** `defineBlockKind<BlockParams>({ name, version })` takes a `{ name, version }` argument; the kind's `src/index.ts` imports `{ name, version }` from its own `package.json` (`with { type: "json" }`) and passes them in, and the bundler (rolldown + rolldown-plugin-dts, `external: () => false`) inlines that JSON import — tree-shaken to the two strings — into the compiled `kind.js`, emitting a readable `kind.d.ts`. There is no build-time injection and no `define`. Identity carries no separate `organization`/`org` field — the registry `{org,name}` path is derived from the full npm name via the existing `parsePackageName` parser. `sourceHash` is a deterministic content hash over the sorted `src/` tree, produced once at build time (not the per-file `calculateSha256`), which makes the source-hash guard's absent/equal/differ decision well-defined. (This reverses note A-0013's earlier v4.0.0 "recorded in the model, not a fourth component" framing; the `model.json` reference is retained for the runtime/export path.)
+
+The remaining open questions the path's correctness is still gated on (`implementation.md:345-354`), ordered by how much of the path each blocks:
+
+- **Q-0008 (overview-refresh trigger)** — *sets the staleness bound on #5.* How the kind overview refresh is triggered in production (cron / on-publish / manual). The reconciler's normal mode is incremental-additive; kindA→kindB switches and dropped refs self-heal only on a force run, so the refresh cadence directly bounds the projection's staleness window. Settle with the operator.
+- **Q-0007 (engine add-block API)** — *does not block this path; it is the entry point of the deferred template-engine document.* The resolver (#6) emits a `from-registry-v2` spec that the existing add-block path (`prepareBlockPack`/`getComponents`) consumes unchanged; how the fixed native YAML lambda then threads params and resolved references through to the init lambda is engine detail resolved in the template doc, not here.
+- **Q-0009 (apply-time params validation)** — *deferred to the template document.* A block's init is compile-time typed against its kind, but a hand-authored YAML's `params` are untyped; what validates them at apply time is a template-engine concern, out of scope for the KIND subsystem.
+
+Standing cross-cutting risks independent of the open questions:
+
+- **Source-hash case convention** (`hashDirSync` lowercase vs `calculateSha256` uppercase) is a live correctness seam across #2/#4/#5; mitigated by `.toUpperCase()` at the manifest-write site. Any comparator on the publish side must use the same convention or the guard reports "different" on every run.
+- **`npmNameToKindPath` / `parseKindRef` split convention** is net-new and unverified; a wrong split silently misfiles both content and projection (#5) and misroutes resolution reads (#6). Pin against the real kind npm-naming convention before shipping.
+- **Reader rooting** — the v2 `registry_reader` is rooted at `MainPrefix='v2/'`; `kinds/` is a sibling, so the kind-overview read (#5/#6) needs an absolute read or a second kinds-rooted reader. Quick verification at implementation time.
+- **Pre-1.0 semver quirk** (#6) — `^0.x` and `~0.x` collapse to the same range under stock semver; if kinds are not guaranteed `>=1.0.0`, `selectorToRange` needs an explicit range for the `0.x` minor case.
+- **Facade same-version overwrite remains unguarded** — only the `kinds/` tree gets the source-hash immutability guard in iteration 1; full block immutability is out of scope and flagged.
diff --git a/docs/block-kinds-templates/01-kind-and-lifecycle.md b/docs/block-kinds-templates/01-kind-and-lifecycle.md
new file mode 100644
index 0000000000..edbd40bb7b
--- /dev/null
+++ b/docs/block-kinds-templates/01-kind-and-lifecycle.md
@@ -0,0 +1,248 @@
+# Track 1 — Kind + Lifecycle (Preamble)
+
+**Status: preamble only.** Scope and open questions, not a plan.
+
+Authoritative design: the `docs/text/work/projects/block-kind-and-templates/` mispec
+corpus. This document reflects the **PR #198 rework** ("kind publishes with the facade",
+branch `feat/kind-publish-with-facade`, not yet on main), which replaced the earlier
+read-back/address-verify and `implementations.json` model. Citations use **atom IDs**
+(e.g. `A-0011`) because rendered line numbers shift.
+
+## Progress Tracker
+
+> **Where we are:** the kind machinery is largely **built and committed** — SDK
+> descriptor, model wiring, reference codec, publish + version-match, registry
+> projection + resolution, and structurer enforcement all exist. The prose below
+> is written in target/"pseudocode" tense and predates that landing; read it as
+> the _design rationale_, and this tracker as the _current state_. Remaining work
+> is fixture migration, `sdk/block-kind` package hardening, and one open cadence
+> question.
+>
+> **Status legend** — implementation: `[x]` done · `[~]` partial · `[ ]` not
+> started/open. Design tags: `DECIDED`/`RESOLVED` (settled), `OPEN` (undecided),
+> `VERIFY` (implemented but not confirmed in the last status pass).
+
+**Kind machinery (in scope)**
+
+- [x] **Kind = 4th component (tetrad), structurer-enforced** — `structure/rules/kind.ts`, `block-package-json.ts` mandatory-kind check (throws if `kindModules.length !== 1`). · DECIDED `Q-0004` (variant B)
+  - [~] **Facade↔kind link — design evolved, prose stale.** Shipped as a **direct facade dependency** (normally a `workspace:*` **devDep**, `.kind`-suffixed — `resolve-refs.ts:61` scans both dep maps) with the reference carried at top-level **`description.kind`** (`resolve-refs.ts:36`); there is no `block.components.kind` map, and `block_components.ts` was intentionally left unchanged. The preamble's "`block.components: { kind, model, workflow, ui }`" wording (below) no longer matches the code. · VERIFY (`A-0053`)
+- [x] **Model wiring** — `DataModelBuilder({ kind })`, `BlockModelV3.create({ dataModel, kind })`, params-carrying `DataCreateFn<T, Params>`, container-level bake — `sdk/model/src/block_migrations.ts`, `block_model.ts`.
+- [x] **Reference carrier** — `lib/model/common/src/bmodel/block_kind_ref.ts` (`formatKindRef`/`parseKindRef`), `container.kind`, `description.kind`, `modelKindReference` reader in `build_dist.ts`.
+- [x] **Publish flow — kind-first + version-match gate** — `v2/publish-block.ts`, `v2/kind/version-match.ts`, `v2/kind/resolve-refs.ts`, `registry.publishKind`; wired in `cmd/publish.ts`.
+- [x] **Source-hash guard** — `buildKindDist` hashes `kind/src/`; `publishKind` enforces immutability (absent→write / equal→no-op / differ→abort).
+- [x] **Registry layout + resolution** — `v2/registry/schema_kinds.ts` (`npmNameToKindPath`, `overview.json` projection), `kind_resolver.ts` (`resolveKind`), middle-layer `resolveKind` facade (`pl-middle-layer/src/block_registry/registry.ts`).
+- [x] **Version selectors `@`/`~`/`^`** — `kind_resolver.ts` (`parseSelector`/`selectorToRange`).
+- [~] **Channels** (`stable` marker; unstable = its absence; `any` = derived newest) — reuses the existing registry channel mechanism; not re-confirmed in the last status pass. · VERIFY
+
+**Kind artifact (decided)**
+
+- [x] `BlockParams` is pinned twice: as a TS type (phantom `InferBlockParams`) and by the kind's
+      **mandatory** `parseTemplateParams` — `descriptor.ts`. A kind therefore ships runtime code;
+      zod is the default the workspace kinds use, not part of the contract.
+- [x] Named export, no default — `defineBlockKind`.
+- [x] Reference `{name}@{version}` derived; registry address never stored.
+- [x] Per-version manifest = sourceHash + first-upload ts — `buildKindDist`. · RESOLVED `A-0052`/`Q-0005` (name+version imported from the kind's own `package.json`; rolldown inlines the JSON import)
+
+**`sdk/block-kind` package (hardening)**
+
+- [x] **Complete for v1** — `defineBlockKind`, `descriptor.ts` (`CompiledBlockKind`/`InferBlockParams`), type-level test; workspace-listed (`pnpm-workspace.yaml:63`).
+  - [~] **Deliberately diverges from impl-path §1 — confirm intent.** The package imports nothing from `@milaboratories/pl-model-common` (the descriptor is fully generic over `BlockParams`), so it does **not** re-export `PlRef`, keeps `pl-model-common` as a devDep, and builds with `--target node`. Impl-path §1 planned a `PlRef` re-export + runtime dep; since `PlRef` never enters the emitted `.d.ts`, the leaner shape is self-consistent — a defensible simplification, not an oversight, but worth confirming as intentional. · VERIFY
+
+**Fixture migration (`etc/blocks`)**
+
+- [x] Structurer seed is a non-building `NEEDS_BLOCK_PARAMS` sentinel that gates unmigrated blocks — `templates/static/kind/src/index.ts`.
+- [x] Migrated with real params: `sum-numbers` (`{ sources?: PlRef[] }`), `table-test` (`{ label: string }`).
+- [x] Not migrated: `enter-numbers`, `filter-column-test`, `model-test`, `pool-explorer`, `ui-examples` (their `kind/` dirs hold only stray untracked build artifacts).
+
+**Open questions & follow-ups**
+
+- [x] `Q-0004` — DECIDED (tetrad, variant B).
+- [x] `Q-0005` — RESOLVED (`A-0052`).
+- [x] `Q-0008` — RESOLVED (`A-0054`): refresh trigger stays as shipped (inline `updateIfNeeded` on publish + manual `refresh-registry`, no new cron); reader ≤5-min stale cache kept as-is; apply **hard-fails** on a not-yet-visible kind/block (no retry/hint, no new code).
+- Out of scope (unchanged): bump-validator, lockfile, yank/deprecation, template engine (tracks 2 & 3).
+
+**Testing** — informational; see "Testing strategy" below. The local `file:`-registry loop is the primary bed. Test-coverage state was not audited for this tracker. · VERIFY
+
+## Goal
+
+A block kind can be declared, wired into a block's model, published as part of the
+block's publish flow, and resolved from the registry — entirely in the TypeScript layer.
+
+## In scope
+
+- **Kind package shape — a fourth component (tetrad).** `kind/` is a first-class block
+  component alongside `model/`/`workflow/`/`ui/`, declaring `BlockParams` + its own
+  version; scaffold generates it. The facade declares it directly in
+  `package.json`'s `block.components: { kind, model, workflow, ui }`, so the facade↔kind
+  link does not route through the model. **Decided: variant B (`Q-0004`).** Note the
+  model _still imports_ the kind for its **types** (`DataModelBuilder({ kind })` needs
+  `BlockParams`) — B decouples the _component/publish_ linkage, not the compile-time
+  type dependency.
+- **Model wiring** — `DataModelBuilder<Data>({ kind })` and
+  `BlockModelV3.create({ dataModel, kind })` take the compiled kind object via an
+  object-style argument (consistent with the object-style `init`); init lambda typed
+  against `BlockParams`; compile-time conformance check (`decisions.md:19-55`). Target
+  signatures, not current code — a block must be on `BlockModelV3` + `DataModelBuilder`
+  first. These are **breaking SDK signature changes**: `DataModelBuilder` currently has
+  an empty constructor and `BlockModelV3.create` takes a single positional `dataModel`.
+- **Reference carrier — facade component, with a `model.json` copy.** Under variant B
+  the authoritative kind **reference** `{name}@X.Y.Z` lives in the facade's
+  `block.components.kind` and flows into the block `manifest.json` (the reconciler reads
+  it there, without loading the model). No address is stored — the registry path is
+  deterministic from the reference. `model.json` still carries **its own copy** of the
+  reference (the version the model was compiled against), used for the version-match
+  check and read at runtime for export (`A-0013`). So the copy in `model.json` is no
+  longer what _publish_ consumes — it is the counterpart the check validates against.
+- **Publish flow — kind-first, one version-match check** — the kind publishes as an
+  ordered first step of the block's publish flow (kind-first, reading the reference from
+  the facade component list); the _kind-before-block_ invariant holds **by construction**
+  of that ordering (publish kind → if it fails, abort → then facade). The single
+  publish-time check is a **version match**: the kind version `model.json` was compiled
+  against must equal the kind version the facade declares as a component — mismatch →
+  hard abort. **No stored address, no existence check, no address read-back/verify**
+  (this replaced the earlier read-back model); under B publish is also **decoupled from
+  `model.json`** as the reference source. A publish failure is a plain hard abort
+  (`A-0011`, `A-0012`).
+- **Source-hash guard** — one `sha256` over the `kind/src/` tree, stored in the
+  per-version kind `manifest.json`; publishing the same version from a different source
+  → hard abort. Orthogonal to the address (`A-0031`).
+- **Registry layout + resolution** — `kinds/{org}/{name}/` holds immutable per-version
+  content (`{version}/manifest.json` with sourceHash + first-upload ts, and `kind.d.ts`)
+  plus a per-kind **`overview.json` projection**. There is **no `implementations/` tree
+  and no kind-side reconciler**: the kind→implementing-blocks map (with channel) is a
+  **projection of block-overview reconciliation**, derived by the existing block
+  reconciler from block manifests + channel markers. Resolution = \*\*one projection read
+  - client-side semver** → newest **stable** by default, or the derived **`any`\*\* when
+    apply-time allow-unstable is set → fetch the block from `v2/`. No cross-registry
+    intersection (`A-0031`, `A-0050`, `A-0051`).
+- **Version selectors** — `@X.Y.Z` (exact), `~X.Y.Z` (patch floor — behavior frozen),
+  `^X.Y.Z` (minor floor — behavior floats). The `.x` forms are **replaced**. Redefined
+  semver: major = params-break, minor = behavior, patch = added-optional-param (`A-0034`).
+- **Channels** — one real marker `stable` (added on release); `--unstable` writes no
+  marker, so "unstable" = its absence; `any` = derived newest-regardless (`A-0051`).
+
+### Kind artifact (decided)
+
+- `BlockParams` is carried **both as a TypeScript type and as a mandatory runtime parser**
+  (`parseTemplateParams`). Typed callers are checked by the compiler; untyped params from a
+  template file are checked by the kind's parser at apply time. The two divide by where the
+  params came from, not by strictness. (Resolves `Q-0009` — `A-0057`.) A validation library
+  is the kind author's choice; zod is what the workspace kinds and the scaffold use.
+- The kind descriptor is exposed via a **named export — no default export**.
+- The descriptor carries the **reference** (`{org}/{name}@version`); the registry
+  address is **derived deterministically** from it and never stored (aligns with
+  `A-0013`). Source-hash is a separate integrity field in the manifest, not part of the
+  address.
+- Published per-version registry content is `manifest.json` (sourceHash + first-upload
+  ts) + `kind.d.ts`. The concrete kind build mechanism (under rolldown) is open —
+  `Q-0005`.
+
+## Testing strategy
+
+The lifecycle assumes a registry that does not yet contain any kind. This once read as
+the track's central risk ("how do we test before the first release?"). It is **resolved**:
+the whole loop — build → publish → reconcile → resolve — runs locally, headless, with no
+CI and no AWS, on a plain temp directory. Grounding: `BlockRegistryV2` writes through a
+driver interface (`RegistryStorage`, `tools/block-tools/src/io/storage.ts`); `storageByUrl`
+picks `FSStorage` for a `file:` URL and `S3Storage` for `s3:`. The reader
+(`RegistryV2Reader` / `folderReaderByUrl`) supports `file:` and `http(s):`. A full local
+loop is already proven by `tests/block-repo/src/simple.test.ts`.
+
+### Publish without CI
+
+CI runs each block facade's generated `prepublishOnly` = `block-tools publish -r s3://… …`.
+Locally it is the **same command with a `file:` target** — no AWS credentials, `FSStorage`
+is selected:
+
+```
+block-tools pack                                        # → block-pack/manifest.json
+block-tools publish -r file:/tmp/reg --registry-serve-url file:/tmp/reg
+```
+
+The new **kind-first** step (publish kind → **version-match check** → then facade) lives
+in `cmd/publish.ts` and writes to the same `file:` registry (kind and block share one
+registry, by construction of the single `block-tools` run). A small script/Make target
+(`publish-etc-local`) runs build → pack → publish for each block in `etc/`, republishing
+all kinds + facades to a throwaway registry in one command.
+
+### No cron needed, and no separate kind reconciler
+
+In production the registry is append-only plain files, and a CronJob reconciler sweeps
+block manifests + channel markers into the `overview.json` projections. Two things
+matter here:
+
+- The cron is only a **scheduler** around a reconciler function that already exists:
+  `BlockRegistryV2.updateIfNeeded` / `updateRegistry`, exposed as `block-tools
+refresh-registry` and run inline by `block-tools publish` (`--refresh`, default on).
+- The per-kind `overview.json` projection is produced by that **same block reconciler
+  pass** — there is **no separate kind-side reconciler** (`A-0050`). The kind→blocks map
+  falls out of block-overview reconciliation.
+
+Locally we invoke the reconciler directly — a **testing advantage**: no eventual
+consistency, we control exactly when the projection rebuilds, and can assert both the
+pre-refresh (no projection) and post-refresh (projection present) states. Production's
+refresh-trigger cadence is a separate open question (`Q-0008`).
+
+### The loop, step by step
+
+| #   | Step                                                                                                    | Exercises                                                                                                                                                                                                                                                                              | Invasiveness                                                                                                                                                 |
+| --- | ------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | Add a `kind/` package to an existing `etc/` block                                                       | package shape, workspace wiring                                                                                                                                                                                                                                                        | ~zero (new folder + workspace entry)                                                                                                                         |
+| 2   | Build locally                                                                                           | `model.json` records the kind **reference** `{name}@X.Y.Z`; `BlockParams` types flow into `init` and type-check                                                                                                                                                                        | **medium** — the breaking `DataModelBuilder({ kind })` / `create({ dataModel, kind })` signature change; only `etc/` fixtures updated, not the 47 bio blocks |
+| 3   | `block-tools publish -r file:/tmp/reg`                                                                  | the new kind-first publish + **version-match check**                                                                                                                                                                                                                                   | low — a step added to `cmd/publish.ts`; storage layer untouched (already driver-based)                                                                       |
+| 4   | Headless tests read the `file:` registry back (vitest, modeled on `simple.test.ts`)                     | **core of the mechanism**: source-hash guard (same version + different `kind/src/` → hard fail), idempotent republish, resolution (single per-kind `overview.json` projection read + client-side semver → newest `stable`, or `any`), version selectors `@X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` | ~zero (new test files)                                                                                                                                       |
+| 5   | Point a local desktop build at the registry via a small static HTTP server + one dev `config.json` line | block still installs and materializes after the kind package + kind-first publish were added                                                                                                                                                                                           | ~zero (config only, no code)                                                                                                                                 |
+
+### Test layers
+
+- **L1 — Lifecycle unit tests on a `file:` registry (primary bed).** Steps 3–4. Where
+  lifecycle correctness lives; needs no desktop, no CI, no AWS.
+- **L2 — Build-time wiring (compile, no publish).** Step 2. `etc/` blocks gain sibling
+  `kind/` packages via the pnpm workspace; `DataModelBuilder({ kind })` type-checks and
+  `block-tools build-model` records the kind reference. No registry involved.
+- **L3 — Desktop end-to-end.** Step 5. **Lighter for track 1 than it looks** — full kind
+  _resolution_ (projection read + client-side semver, newest-block selection) is a
+  template engine / import concern (track 3). Track 1's L3 mainly proves a single block
+  still installs/materializes (it reads the kind reference from `model.json`). Do not
+  over-invest here for track 1.
+- **L4 — Templates (export/import).** Tracks 2 and 3, later.
+
+### Desktop wiring detail
+
+The desktop assembles its registry list in `platforma-desktop-app/packages/worker/src/registry.ts`
+(`buildRegistryEntries(appSettings)`) from `AppSettings`
+(`packages/core/src/validation.ts`, persisted as `config.json` — `./config.json` at the
+repo root in DEV). Three relevant knobs, all on the always-visible Settings page (no
+dev-mode gate):
+
+- `devBlocksPaths` → `local-dev` registries — served straight from `dist/`, **bypasses
+  publish** (good for model/UI iteration, does not exercise the lifecycle).
+- `additionalRegistriesV2: ["http://localhost:PORT/"]` → `remote-v2` via `HttpFolderReader`
+  — the **recommended L3 route**: matches the production http path, passes `z.string().url()`,
+  zero code changes.
+- `file:///abs/path/` in the same field → `remote-v2` via `FSFolderReader` — valid
+  zero-infra fallback (no static server), but not the production http branch.
+
+## Out of scope for this track
+
+- bump-validator, lockfile, yank/deprecation, server-assigned patch numbers, cross-major
+  lineage — pushed onto author discipline + AI-harness CI checks.
+- The template engine and export/import (tracks 2 and 3).
+
+## Open questions
+
+Carried from the spec (atom IDs), plus track-local ones:
+
+- **`Q-0004` — DECIDED: variant B (tetrad).** kind is a fourth sibling component; the
+  facade declares it in `block.components` and publish reads the reference there, not
+  through `model.json`. Implication: `kind` must be added to the middle-layer schemas
+  `block_components.ts` (`BlockComponents`, `BlockComponentsDescriptionRaw`),
+  `block_description.ts`, and `block_manifest.ts` (`BlockPackManifest`).
+- **`Q-0005`** — concrete kind build mechanism under rolldown (how `manifest.json` +
+  `kind.d.ts` are produced; the shape of the compiled descriptor).
+- **`Q-0008`** — production trigger/cadence for the overview-projection refresh (now
+  tied to the block reconciler's schedule).
+- [TODO: migration path for legacy `BlockModel` (V1) blocks that must move to
+  `BlockModelV3` before they can carry a kind.]
+- [TODO: backward-compat for the breaking `create()` / `DataModelBuilder` signature —
+  overload vs. atomic migration of all V3 blocks.]
diff --git a/docs/block-kinds-templates/02-export.md b/docs/block-kinds-templates/02-export.md
new file mode 100644
index 0000000000..bf3a8ff0aa
--- /dev/null
+++ b/docs/block-kinds-templates/02-export.md
@@ -0,0 +1,569 @@
+# Track 2 — Export (Preamble)
+
+**Status: preamble only.** Scope and open questions, not a plan.
+
+Authoritative design: the `docs/text/work/projects/block-kind-and-templates/` mispec
+corpus (PR #198 rework). Citations use atom IDs (`A-00NN`).
+
+## Goal
+
+Turn the active project into a `template-v1` YAML file that re-applies to an equivalent
+project — the export half of the round-trip north-star.
+
+## In scope
+
+- **Serialize** the project's blocks in dependency order, reading each block's
+  template-descriptor output (`decisions.md:148`).
+- **Template-local ids** — each block's project-local UUID is used directly as its
+  template-local `id`; references already stored in params carry those same ids, so
+  export reuses them verbatim, no remap (`decisions.md:139`).
+- **Desktop command** — "Export Project as Template…" writes the file
+  (`decisions.md:148`).
+- **`template-v1` schema** — shared with import; export must emit exactly what import
+  parses (see README "Schema shared across tracks").
+
+## Why export can start early
+
+Export only needs the kind **reference** (`{name}@X.Y.Z`) recorded in `model.json` — read
+back at runtime for the exported template entry (`A-0013`) — plus a block's
+template-descriptor output. It does not need kind _resolution_ or the template-engine
+apply lambda, so it can be built and tested against fixtures ahead of import.
+
+## High-Level TODO
+
+Dependency-ordered. Use `[~]`/`[x]` as work lands, matching the tracker convention in
+`01-kind-and-lifecycle.md`.
+
+**Contracts first (these two gate everything below)**
+
+- [~] **Pin the `template-v1` schema** — prototyped in `pl-model-common` under
+      `lib/model/common/src/template/`: `project_template_v1.ts` (file envelope, `schema:
+      template-v1` marker, entry shape, `TemplateLocalRef`, zod boundary parsers,
+      reference validation) and `kind_selector.ts` (the `{name}@{selector}` grammar with
+      its three tiers). One definition, both tracks import it. Still to do: agreement with
+      import (track 3) and sign-off on five decisions — see "Schema Prototype" below
+- [~] **Define the template-descriptor contract** — prototyped as
+      `.templateParams((data) => params)` on `BlockModelV3` (`A-0041`, renamed — see below),
+      plus facade callback #7 (`__pl_templateParams_derive`). A block exposes only its
+      params, typed as its kind's `Params`; references go out as ordinary `PlRef`s and the
+      SDK rewrites them. See "Template-Descriptor Contract" below for the audit and what it
+      leaves open
+
+**Serialization**
+
+- [~] **Read the kind reference back at runtime** — audited end to end and pinned by
+      `sdk/model/src/kind_reference.test.ts`; **no production code was needed**, the read
+      already works. See "Kind Reference Read-Back" below for the audit, why no helper
+      landed, and the one open decision it surfaced (kind-less blocks)
+- [~] **Dependency-order walk** — `walkProjectForTemplateExport` in
+      `lib/node/pl-middle-layer/src/model/template_export.ts`, plus the ML-side invoker
+      `ProjectHelper.deriveTemplateParamsFromStorage` for facade callback #7. **No
+      topological sort was needed** — see "Dependency-Order Walk" below. Remaining: the
+      provider that reads real project state, which belongs with the serializer
+- [~] **Template-local ids** — verbatim reuse confirmed end to end, and the one thing it
+      depends on is now enforced: `walkProjectForTemplateExport` rejects params that still
+      carry an un-rewritten project-local id. See "Template-Local Ids" below — it resolves
+      one of the open questions above and leaves the dangling-reference check to the
+      serializer
+- [~] **Emit `template-v1` YAML** — `lib/node/pl-middle-layer/src/model/template_serializer.ts`:
+      `assembleProjectTemplateV1` → `stringifyProjectTemplateV1` → `exportProjectAsTemplateV1`.
+      Round-trip pinned against the import-side parser. See "Serializer" below — it
+      **implements a decision that is still awaiting sign-off** (kind-less blocks fail the
+      export). Remaining: the provider that reads real project state, which needs the
+      desktop surface
+
+**Desktop**
+
+- [~] **"Export Project as Template…" command** — wired end to end across both repos:
+      `MiddleLayer.exportProjectAsTemplate(id)` here, and the ProjectCard context-menu
+      item, save dialog and write in `platforma-desktop-app` on branch
+      `MILAB-6648_export-project-as-template` (off `origin/main`). See "Desktop Command"
+      below. Confirmed working against a live backend; the failure path was exercised, the
+      success path needs a project of kind-bearing blocks
+
+**Validation**
+
+- [~] **Fixture-based tests** — five golden `.yaml` files under
+      `lib/node/pl-middle-layer/test_fixtures/template-v1/`, driven by
+      `template_serializer_fixtures.test.ts`. Turned up a real interop bug in the emitter
+      — see "Golden Fixtures" below. Still open: fixtures of a *real* project (through
+      `ProjectMutator`), which need a backend
+- [ ] **Round-trip check once import exists** — export → import → equivalent project;
+      the north-star acceptance criterion, deferred to track 3 landing.
+
+## Schema Prototype
+
+`lib/model/common/src/template/` — `A-0036`'s document as types plus zod boundary
+parsers, with `project_template_v1.test.ts` parsing the atom's example verbatim. Exported
+surface: `ProjectTemplateV1`, `ProjectTemplateV1Entry`, `ProjectTemplateV1Schema`,
+`parseProjectTemplateV1`, `TemplateLocalRef`, `BlockPackReference`,
+`BlockKindSelectorReference`, `collectTemplateLocalRefs`,
+`validateProjectTemplateV1References`, and the params codec `TemplateForm` /
+`toTemplateForm` / `fromTemplateForm`.
+
+**Decisions awaiting sign-off**
+
+1. **Home and boundary** — `pl-model-common` owns the *document* (JS value ↔ types) and
+   takes no `yaml` dependency, since it ships in every block-model and UI bundle. The YAML
+   text layer belongs to `pl-middle-layer`, which already has `yaml`.
+2. **Naming** — `ProjectTemplateV1*`, not `TemplateV1*`: `PlTemplateV1` already names the
+   unrelated backend workflow-template resource (`lib/model/backend/src/`
+   `template_resources_v1.ts:90`).
+3. **Reservation rule** (load-bearing) — a plain object with *exactly* the two string keys
+   `block` and `output` is reserved as a template-local reference anywhere inside an entry's
+   opaque `params`. This is what lets the engine rewrite references generically on apply
+   (`A-0038`) instead of every kind shipping a params codec. Reference resolvability is kept
+   out of the parser (`validateProjectTemplateV1References` is separate) so the parser stays
+   sound if the rule is rejected. Those two fields are the whole reference: `PlRef`'s
+   `requireEnrichments` is dropped on export, since enrichments are out of scope for
+   templates (operator decision, 2026-07-30).
+4. **Strict selector grammar** — `X.Y.Z`, `~X.Y.Z`, `^X.Y.Z` only; `>=1.0.0`, `1.x` and
+   `latest` throw at parse. Deliberate divergence from `tools/block-tools`'s
+   `parseSelector`, which additionally tolerates a leading `@` as exact.
+5. **Zod peg** — `satisfies BoundaryParser<T>` (`z.ZodType<T, z.ZodTypeDef, unknown>`)
+   rather than the repo's `satisfies z.ZodType<T>`: the branded string fields need a
+   `.transform`, whose input is a plain `string`, which the two-parameter form rejects.
+
+Known gap, not schema-specific: `expectTypeOf` assertions in `*.test.ts` are unenforced
+repo-wide — `createVitestConfig` sets no `typecheck` and `tsconfig.base.json` excludes
+test files. The template test was verified by hand against a tsconfig that includes tests.
+
+## Template-Descriptor Contract
+
+What a block exposes is one **required** builder method, the mirror image of the data model's
+`init`. **Named `templateParams`, not `templateEntry`** (operator decision, 2026-07-30): the
+lambda returns only params — the engine assembles the entry around them — so naming it after
+the entry oversells what a block controls. `A-0041 v2.0.0` carries both the name and the
+requirement; `01-kind-and-lifecycle-implementation-path.md` still says `templateEntry`.
+
+**Required, not optional** (operator decision, 2026-08-04 — `A-0056`): `done()` throws
+without it, at the same gate that rejects a model with no `.args`. An optional projection
+bought no expressiveness — an absent `params` and `params: {}` reach the same init factory
+and produce the same storage (`block_migrations.ts:721` vs `:739`) — while costing fidelity
+silently: a block with no projection exported an entry with no params, which applied as a
+default-initialized block that looked restored. A block whose state carries nothing worth
+restoring returns `{}`.
+
+```typescript
+BlockModelV3.create({ dataModel, kind })
+  .args((data) => ({ … }))
+  .templateParams((data) => ({ sources: data.sources })) // → the kind's Params
+  .done();
+```
+
+- **Return type is the kind's `Params`.** `BlockModelV3` now carries a seventh type
+  parameter threaded from `create({ dataModel, kind })`, so a projection that drifts from
+  the block's own init contract fails to compile. Kind-less `create(dataModel)` leaves it
+  `unknown`, which makes `.templateParams` untyped there — one more reason the deprecated
+  overload should go.
+- **References stay live in the lambda.** The block returns ordinary `PlRef`s;
+  `toTemplateForm` (pl-model-common) rewrites them to `{ block, output }` on the way out,
+  and `fromTemplateForm` reverses it on apply. That is the generic engine-side rewrite the
+  reservation rule buys, and it means no block ships a params codec — the answer to "does
+  the lambda or the engine rewrite references".
+- **Omitting the method is legal**, and means "re-initialize from the kind's defaults" —
+  correct for a block like `pool-explorer` whose params are empty by construction. Note
+  `undefined` params and `{}` params are NOT interchangeable: `{}` is written out and used
+  as-is by `init`.
+- **Facade callback #7**, `__pl_templateParams_derive`, is registered by every V3 block
+  whether or not it declares the method; a block without it answers `{ value: undefined }`.
+  Additive per the facade's compatibility rules, and `BlockStorageFacadeHandles` picks it
+  up automatically.
+
+**Does every block already produce it?** No — nothing does yet, and the ceiling is set by
+kind coverage, not by this method:
+
+| Population | Count | Can carry `.templateParams` |
+| --- | --- | --- |
+| `etc/blocks/*` (SDK test blocks) | 13 | Yes — all V3, all `create({ dataModel, kind })` |
+| `blocks/*` on `BlockModelV3` | 26 | Not yet — 0 have a `kind/` package |
+| `blocks/*` on legacy `BlockModel` (V1) | 37 | No — needs V1 → V3 first, then a kind |
+| `blocks/*` with no `model/src` | 3 | N/A (`MMseqs2`, `pseudobulk-generation`, `synthetic-repertoire-profiler`) |
+
+Migration path, in order: V1 → V3 (37 blocks), add a `kind/` package (63 blocks), then add
+`.templateParams` per block. Only the third step is this track's; the first two are track 1
+and the blocks repo. Two of the SDK test blocks (`sum-numbers`, `table-test`) now declare
+the method as worked examples.
+
+**Open — needs a decision**
+
+- **Extra fields are not rejected on the way out.** TypeScript applies no excess-property
+  check to an object literal returned from a contextually-typed arrow, so a lambda can return
+  fields the kind never declared and they land in the file. The kind's parser is no backstop
+  here — it runs on params coming IN, and nothing runs on what the projection hands back. The
+  asymmetry is now the interesting part: such a file is written happily and then rejected on
+  re-import by the same kind that would have caught it, so the round trip fails at the far
+  end rather than at the source. Options: accept it, run the kind's parser over the
+  projection's output too, or strip against a key list. Pinned by a test in
+  `sdk/model/src/template_params.test.ts`.
+- **References inside a `PObjectId` are invisible to the rewrite.** `EnrichmentRef.hit` and
+  `EnrichmentStep.linker` are canonicalized-JSON *strings* holding a block UUID, so a
+  structural walk cannot see them and the UUID survives export to go stale on apply.
+  Whether such a reference reaches persisted params is unverified.
+
+## Kind Reference Read-Back
+
+The TODO's wording ("read the kind reference back at runtime") suggests missing plumbing.
+There is none. Every hop is a verbatim passthrough, audited on disk:
+
+| Hop | Where | Behavior |
+| --- | --- | --- |
+| Bake | `sdk/model/src/block_model.ts:218,233,739` | `formatKindRef` → container-level `kind` |
+| Write | `tools/block-tools/src/cmd/build-model.ts` | `JSON.stringify(config)`, no whitelist |
+| model.json | `etc/blocks/*/model/dist/model.json` | `kind` at **top level**; 13/13 carry it |
+| Manifest lift | `tools/block-tools/src/v2/build_dist.ts:55-70` | `modelKindReference`, fail-safe |
+| Parse | `.../mutator/block-pack/block_pack.ts:43-55` | open record + cast, preserves it |
+| Store | `.../mutator/block-pack/block_pack.ts:353` | `{ config: spec.config, source }` |
+| Read | `.../middle_layer/util.ts:35` | hands every caller the whole `info` |
+
+The single loss is `extractConfigGeneric` (`lib/model/common/src/bmodel/normalization.ts`),
+which drops `kind` in all four arms — deliberately: it normalizes the *render envelope*,
+and `kind` is container-level. So `getBlockPackInfo(...).cfg` is kind-blind by construction
+and the read point is `getBlockPackInfo(...).info.config.kind`.
+
+**Why no helper landed.** `BlockConfigContainer.kind` is already declared
+`readonly kind?: BlockKindReference` (`container.ts:21`), so that property access already
+yields `BlockKindReference | undefined` — an `extractKindRef(cfg)` wrapper would narrow
+nothing, parse nothing, and resolve nothing, while becoming permanent block-author-facing
+API (`pl-model-common` is re-exported wholesale by `@platforma-sdk/model`). The middle-layer
+read is one expression at the serializer's own call site, and that call site does not exist
+yet. What was missing was not code but *proof the path holds*, so this step landed the
+test instead.
+
+**What the test pins** (`sdk/model/src/kind_reference.test.ts`, 6 cases, no backend):
+`done()` bakes the kind at container level; the normalized config does **not** carry it
+(fails loudly if anyone later routes it through the normalizer, creating two sources of
+truth); a kind-less block reads back `undefined` rather than throwing; the reference widens
+to the exact tier with the string unchanged; the org-scoped name survives the last-`@`
+split; and the widened reference is accepted by `ProjectTemplateV1EntrySchema` as an
+entry's `kind`.
+
+**One correction to the TODO's framing.** "No kind _resolution_ needed" is right, but a
+brand *widen* is mandatory and was understated: an entry's `kind` is typed
+`BlockKindSelectorReference`, so the exact reference goes through
+`kindReferenceToSelectorReference`. `A-0041` fixes the tier — "the exact version the block
+implements, `{name}@X.Y.Z`, read from the model's embedded kind reference" — and also
+settles that export never emits a `block` override. Widening happens at the **serializer**,
+not the read point, because it validates and therefore throws; every read site sits inside
+a `Computable` re-evaluated on project-overview recompute, so a malformed stored reference
+must not be able to break the overview of unrelated blocks.
+
+**Open — needs a decision**
+
+- **What does export do with a kind-less block?** A genuine spec contradiction, not a code
+  problem: an entry's `kind` is **required** (`A-0036`, `project_template_v1.ts:95` — "it
+  carries the params contract the entry is typed against") while a block's `kind` is
+  **optional** for backward compatibility (`container.ts:19-21`). For such a block there is
+  no legal entry to write, and no atom in the corpus decides between: (a) fail the export
+  and name every offending block; (b) skip the block with a warning — but downstream entries'
+  params may hold `TemplateLocalRef`s to it, producing a file that fails
+  `validateProjectTemplateV1References`; (c) emit an entry without `kind`, i.e. an invalid
+  file. Recommendation: **(a)**. This is not an edge case — every block published before
+  kinds existed, and every block still on the deprecated `create(dataModel)` overload, is
+  kind-less, so it is what most existing projects will hit until blocks are republished.
+  Gates the serializer step, not this one.
+
+## Dependency-Order Walk
+
+**The project structure is already stored in topological order, so there is no sort.** That
+is not an assumption — it is enforced. `productionGraph` iterates `allBlocks(structure)` and
+passes the set of blocks seen *so far* as the `allowed` set to `inferAllReferencedBlocks`
+(`lib/node/pl-middle-layer/src/model/project_model_util.ts:136-143`, `args.ts:107-110`), so a
+reference to a block not already above is recorded as `missingReferences` rather than as an
+upstream; the upstream scan then stops at the current block (`:155-156`). `BlockGraph`
+documents the same invariant on its node map ("Nodes are stored in the map in topological
+order", `:40`). A block can therefore only legally reference blocks earlier in the sequence
+— which is exactly `A-0036`'s ordering rule ("every block must appear after the blocks it
+references") and `A-0041`'s "the engine emits entries upstream-first". Emitting in structure
+order satisfies both for free. Groups are flattened in order, so cross-group order is the
+structure's too.
+
+The walk deliberately does **not** reorder to repair a structure that violates the rule:
+reordering would change which references are even legal, and the resulting file is caught by
+`validateProjectTemplateV1References` anyway. Pinned by a test.
+
+**What landed**
+
+- `walkProjectForTemplateExport(structure, paramsProvider)` →
+  `{ entries, problems }`. Pure over plain data, 13 unit tests, no backend. It owns the four
+  distinctions that are easy to get wrong: structure order is the answer; `undefined` params
+  (block declares no `templateParams`) is legal and **not** the same as `{}`; a failed
+  derivation is a per-block problem rather than an abort, so every offending block is
+  reported in one pass; and non-object params are rejected — an entry's `params` is a mapping
+  (`A-0036`), but a kind carries `Params` as a type only (`A-0019`), so this walk is the only
+  place that can catch a lambda returning a primitive or an array.
+- `ProjectHelper.deriveTemplateParamsFromStorage` — the middle layer's invoker for
+  `__pl_templateParams_derive`, mirroring `deriveArgsFromStorage`. This did not exist; the
+  callback had been registered by every V3 block since the previous step with nothing on the
+  ML side calling it. Unlike `derivePrerunArgsFromStorage`, it surfaces failures instead of
+  swallowing them: a prerun that cannot derive args just skips a block in staging, whereas an
+  export that silently drops one produces a template that does not describe the project.
+- A block whose state cannot be read at all is a **problem**, not a silent skip — the
+  opposite of `productionGraph`, which skips such blocks by design. Deliberate divergence:
+  surviving entries may hold `TemplateLocalRef`s to the omitted block.
+
+**What is left, and why it is the serializer's**
+
+The provider that supplies real project state. Per-block storage is only reachable from
+`ProjectMutator`'s batched round-trip loader (`mutator/project.ts:1870-1899`) or from inside
+a Computable, and an export is a one-shot user action rather than part of the render loop —
+so where that read lives depends on the desktop surface, and adding it to that
+performance-tuned batching routine now would be guesswork. Note the same loader does
+`info.blockConfig = extractConfig(bpInfo.config)` (`:1897`), so it is kind-blind like every
+other extracted config: an exporter reading from `BlockInfoState` must take
+`bpInfo.config.kind`, not `info.blockConfig`.
+
+## Template-Local Ids
+
+**There is no id namespace to translate into, so there is nothing to remap.** Both sides
+of the id draw from the same source:
+
+| What | Where | Becomes |
+| --- | --- | --- |
+| `Block.id` in the structure | `project_model.ts` | the entry's `id`, verbatim |
+| `PlRef.blockId` inside params | `ref.ts:9` | `TemplateLocalRef.block` via `toTemplateForm` |
+
+`toTemplateForm` copies `ref.blockId` straight into the reference
+(`template_form.ts:49`), so an entry id and every reference naming it are the *same
+string* — pinned by a test asserting exactly that identity. Nothing generates, maps, or
+counts ids.
+
+Two framing corrections to the TODO's wording:
+
+- **"UUID" is the common case, not a constraint.** `addBlock` and `duplicateBlock` only
+  *default* the id to `randomUUID()`; both accept an explicit one
+  (`middle_layer/project.ts:217,288`), and the workspace test blocks use ids like
+  `block1`. An entry `id` is `z.string().min(1)`, so this is fine — but code and docs
+  should not promise UUID shape.
+- **Verbatim reuse is only sound if the rewrite is complete**, and that is the real work
+  this step turned up.
+
+**What landed: a detection-parity guard.** The two walks disagree about what carries a
+block id, and the export path sat on the wrong side of the gap:
+
+| Walk | Recognizes a `PlRef` object | Recognizes a `PlRef` serialized into a string |
+| --- | --- | --- |
+| `toTemplateForm` (`mapRefs`, `template_form.ts:74`) | yes | **no** |
+| `inferAllReferencedBlocks` (`args.ts:40-99`) | yes | yes, peeling N `stringify` passes |
+
+The second is the project's own reference detector — the block dependency graph is built
+from it — so it is the authority on what carries a block id. `walkProjectForTemplateExport`
+now runs it over the already-template-form params and reports any id it still finds as a
+per-block problem. Correct template form has none: a rewritten reference is
+`{ block, output }` with no `__isRef` marker, invisible to the detector. It sits in the
+walk rather than in `toTemplateForm` because the detector is middle-layer code while the
+codec ships in every block-model and UI bundle.
+
+**This resolves the second open question under "Template-Descriptor Contract."** It was
+recorded as "whether such a reference reaches persisted params is unverified". The carrier
+is now verified real and precisely located: `EnrichmentRef.hit` and `EnrichmentStep.linker`
+are declared as global-form `PObjectId`s, i.e. `canonicalize({ __isRef: true, blockId,
+name })` (`ref.ts:139-149`) — and `args.ts`'s string-unwrapping branch exists *because*
+that form occurs in real args. So this was never hypothetical, and export was silently
+writing a project-local UUID into a file with no way to resolve it. It is now a named
+error naming the offending block and id. Still open, and now a smaller question:
+whether to *support* the case by rewriting inside the string (the apply side would have to
+re-canonicalize with a matching escape depth) rather than rejecting it. Rejecting is the
+right default until a block is shown to need it.
+
+**What is deliberately not here: the dangling-reference check.** Verbatim reuse can emit a
+reference to a block that is not in the file, and this is ordinary rather than exotic:
+`deleteBlock` only splices the structure (`mutator/project.ts:1420-1432`) and does not
+rewrite downstream args, which is exactly why `BlockGraphNode` carries a
+`missingReferences` flag. A project in that state exports entries whose params name a
+block with no entry. `validateProjectTemplateV1References` already reports precisely this,
+with the offending entry named in the message, and it needs the whole document — so the
+serializer calls it once instead of the walk approximating it per block.
+
+**Noted, not fixed: duplicate ids are possible upstream.** `updateStructure` diffs
+`stagingGraph`s, which key blocks by id in a `Map` (`mutator/project.ts:1282-1304`), so
+adding a block with an id that already exists collapses in the diff — the new-block
+initializer never fires (`:1371-1374`) and the structure ends up with two blocks of the
+same id. Export would then emit two entries with the same `id`. Not export's hole to fix,
+and `ProjectTemplateV1Schema` rejects duplicate ids at parse, so the exported file cannot
+pass validation silently.
+
+## Serializer
+
+`lib/node/pl-middle-layer/src/model/template_serializer.ts`, three layers so each can be
+tested and reused separately:
+
+| Function | Does |
+| --- | --- |
+| `assembleProjectTemplateV1(walk, kindProvider)` | walk output + kind refs → `{ document, problems }` |
+| `stringifyProjectTemplateV1(document)` | document → YAML text, `lineWidth: 0` |
+| `exportProjectAsTemplateV1(structure, paramsProvider, kindProvider)` | the whole thing, all-or-nothing |
+
+Assembly is dull by design — an entry is the block's id, its widened kind reference, and
+the params the walk already collected. `block` is never emitted: the override exists to pin
+an implementation against a kind version *range*, and export writes the exact version
+(`A-0041`), so it has nothing left to pin.
+
+**The round-trip is asserted on every export, not only in tests.** `exportProjectAsTemplateV1`
+runs the import-side `parseProjectTemplateV1` over the document before rendering it. That
+is the cheapest possible proof of "export emits exactly what import parses", and it is a
+throw rather than a problem: by then the kind grammar was checked by the widening, params
+by the walk, and references by the assembler, so a failure means an assembler bug — with
+the one known exception of the upstream duplicate-id hole noted under "Template-Local Ids".
+
+**Decision taken, still needs sign-off: kind-less blocks fail the export (option (a)).**
+The recommendation under "Kind Reference Read-Back" is implemented, naming every offending
+block, and nothing partial is written. Rationale for choosing rather than blocking: (a) is
+the only reversible option — relaxing it later is a one-line change, whereas a shipped
+export that writes invalid files or silently drops blocks cannot be un-shipped. The other
+two remain available; if you want (b), the change is to demote the problem to a warning and
+let `findProjectTemplateV1ReferenceProblems` catch whatever the dropped block leaves
+dangling.
+
+**Also landed, in `pl-model-common`:** `findProjectTemplateV1ReferenceProblems` returns
+`{ entryId, ref, reason, message }` per problem, and `validateProjectTemplateV1References`
+is now `.map(p => p.message)` over it. Export needs per-block attribution to report which
+block to fix, and the alternative was either parsing the message back apart or duplicating
+the traversal. Same messages, so no caller changes.
+
+**What is left, and it is the same blocker as before:** the two providers. `paramsProvider`
+and `kindProvider` are both plain functions over a block id, deliberately — the serializer
+is pure and fixture-testable — but wiring them to a real project means reading per-block
+storage and `bpInfo.config.kind`, which is reachable only from `ProjectMutator`'s batched
+loader or inside a Computable. Which one is right depends on the desktop surface, so it
+belongs with the desktop command.
+
+## Desktop Command
+
+Spans two repos. Nothing here is verified at runtime — see "What is not proven" below.
+
+**This repo — the providers, which were the standing blocker.** The serializer takes two
+plain functions over a block id; supplying them for a real project needs per-block storage
+and the container-level kind, and both are only reachable from inside `ProjectMutator`:
+
+| Piece | Where |
+| --- | --- |
+| `BlockInfo.kind` | carried through the batched loader, `mutator/project.ts` |
+| `ProjectMutator.exportAsTemplateV1()` | assembles both providers, calls the serializer |
+| `MiddleLayer.exportProjectAsTemplate(id)` | `resolveProjectId` → `withProject`, the entry point |
+
+**The entry point takes a project id, not an open `Project`** (operator decision,
+2026-08-03: the command belongs on a project card, not in the File menu). Exporting is a
+property of the stored project rather than of a session with it, and from a card the
+project is usually closed — `withOpenedProject` would simply throw. Opening one to read it
+would spin up trees and watchers for a one-shot read and then have to decide whether to
+close them again. This matches how the other card-scoped actions work: `duplicateProject`
+and `copyProjectToUser` also go through the middle layer by id. Modelled on
+`setProjectMeta` — `resolveProjectId` then `withProject`.
+
+An earlier `Project.exportAsTemplate()` on the open-project object was removed rather than
+kept alongside: the id-based method covers the open case too, and two entry points where
+one is a strict subset of the other is worse than one.
+
+The kind needed one line in the loader: `bpInfo.config.kind` is read off the container
+right where `extractConfig` already runs, so it costs no extra round-trip. This is what the
+earlier note about "adding a read to that performance-tuned batching routine would be
+guesswork" was worried about, and the worry turned out not to apply — nothing new is
+fetched, a value already in hand is kept. `BlockInfo` now carries it alongside `config`,
+which cannot: `extractConfig` normalizes the render envelope, one level below the kind.
+
+`exportAsTemplate` is a one-shot `withProject` read, deliberately **not** a `Computable`.
+An export is a user action with an answer, not project state to watch, and deriving every
+block's params in the VM is far too much to redo on each overview recompute. The mutator
+touches no field, so `wasModified` is false and the transaction is never committed.
+
+**`platforma-desktop-app`, branch `MILAB-6648_export-project-as-template`** (branched from
+`origin/main`; note `origin/main` carries a change to the same `workerApi.ts`, which does not
+overlap these edits):
+
+| Piece | Where |
+| --- | --- |
+| `ExportProjectAsTemplateResult` | `packages/core/src/types/contract.ts` |
+| `exportProjectAsTemplate` worker method | `packages/worker/src/workerApi.ts` |
+| `ExportProjectAsTemplate(projectId)` task | `packages/main/src/tasks/` + `tasks/index.ts` |
+| "Export as Template..." context-menu item | `packages/renderer/src/start/ProjectCard.vue` |
+
+The command sits in the project card's context menu, next to Share and above Delete — not
+in the OS File menu, where an earlier draft put it. The File menu is `setApplicationMenu`,
+i.e. the macOS menu bar, which this app's users never look at: the in-app menu is a
+separate popup fed by `createMainMenuTemplate`. Unlike Duplicate, the export does not gate
+the context menu while it runs, since it only reads.
+
+Three things there are worth knowing:
+
+- **The catalog lags.** The desktop's committed config pins `pl-middle-layer` 1.66.9;
+  `exportAsTemplate` is in unreleased 1.66.10. Handled with a *catalog-lag adapter*, the
+  convention that file already uses for two other methods — a narrow cast plus a comment
+  saying to delete it after the bump. Unlike those two, a missing method here cannot default
+  to empty, so it surfaces as "not supported by this version of the platform". Note a
+  developer whose working tree activates the local `file:../platforma/...tgz` overrides gets
+  1.66.10 and the method in the typings directly, making the adapter redundant *there* — but
+  it is what keeps the committed code compiling against the catalog.
+- **Render first, ask for a path second.** The opposite order shows a save dialog and only
+  then discovers the project cannot be exported — and with kind-less blocks failing, that is
+  currently the common outcome, not the rare one.
+- **The document does not cross the thread boundary.** The middle layer returns both the
+  YAML and the parsed document; the worker rebuilds only `{ ok, yaml }` / `{ ok, problems }`,
+  since the text carries the same information and the caller only writes text.
+
+**What is not proven.** Type-checked, linted and formatted in all five touched packages
+(three here, three there), and the desktop's `packages/main` suite still passes 31/31. But:
+
+- `ProjectMutator.exportAsTemplateV1` has **no unit test**. Every test that reaches a
+  mutator goes through `withTempRoot`, which needs a live backend (`PL_ADDRESS`), so those
+  suites do not run locally at all — they are the backend CI monorepo tests. The pure layers
+  below it are covered: 20 walk tests, 17 serializer tests, all backend-free.
+- The Electron half cannot be exercised without a built app, so "the menu item appears,
+  is greyed out with no project open, and the dialog writes the file" is unverified.
+
+## Golden Fixtures
+
+`lib/node/pl-middle-layer/test_fixtures/template-v1/` — five expected `.yaml` files,
+driven by `src/model/template_serializer_fixtures.test.ts`. Input side stays in TypeScript
+(typed, so a fixture cannot drift from `ProjectStructure`); expected side is a file on
+disk, which is the artifact a reviewer reads.
+
+| Fixture | Pins |
+| --- | --- |
+| `empty-project.yaml` | `blocks: []`, not a bare `blocks:` that parses as null |
+| `minimal.yaml` | schema marker first; no `params` key at all when none were derived |
+| `linear-chain.yaml` | the canonical shape — three blocks wired up, ids verbatim |
+| `nested-params.yaml` | objects in arrays, refs at depth, `{}` and `[]` and `null` |
+| `scalar-quoting.yaml` | strings a YAML reader would otherwise turn into something else |
+
+**Plain files, not snapshots** (operator decision, 2026-08-03). There is no snapshot
+infrastructure in this repo to fit into — zero `toMatchSnapshot`, zero `__snapshots__` —
+and a snapshot comes with `-u`, which rewrites the expectation without anyone reading it.
+For a file format promised to a second implementation, changing the expectation should be
+a deliberate edit visible in review. Each fixture is also parsed back with the import-side
+parser, so a golden file can never be updated to something import cannot read. They live
+outside `src/` because this package publishes `src/**/*`.
+
+**They immediately earned their keep: the emitter had an interop bug.** YAML 1.2 dropped
+`yes`/`no`/`on`/`off`/`y`/`n` as booleans and dropped sexagesimal integers, so the `yaml`
+package — 1.2 by default — was emitting a params value of `"yes"` as bare `yes` and
+`"1:30"` as bare `1:30`. Our own parser reads those back as strings, so the round-trip
+assertion was green and the field-by-field tests could not see it at all. But PyYAML's
+default and Go's `yaml.v2` are **1.1**, where they are `true` and `90`.
+
+Fixed by emitting with `version: "1.1"` while still parsing as 1.2: quote against the
+stricter ruleset, read with the looser one, since a quoted scalar means the same thing
+under both. It adds no `%YAML` directive — only more quotes. Pinned by a test that asserts
+each hazard is quoted, which is the only kind of test that can catch this, precisely
+because a self-round-trip cannot.
+
+**What is left here.** Fixtures of a *real* project, i.e. driven through `ProjectMutator`
+rather than through the pure serializer. These would catch a provider bug — the current
+fixtures verify the format contract, not that reading a real project produces it. They
+need a backend, so they belong with the monorepo CI suite.
+
+## Out of scope
+
+- Import / apply (track 3).
+- Publishing or browsing templates in-app (`decisions.md:152`).
+
+## Open questions
+
+- Both original open questions are answered above. The live ones are the sign-off items
+  under "Schema Prototype", the extra-fields decision under "Template-Descriptor Contract",
+  and the kind-less-block decision under "Kind Reference Read-Back" — that last one is now
+  **implemented as (a)** rather than blocking, and needs confirming rather than deciding
+  (see "Serializer").
+- A note on code comments: source comments in this track carry no `A-00NN` citations or
+  paths back into these documents — they state the fact inline instead (operator decision,
+  2026-08-03). Citations live here, in the tracker.
diff --git a/docs/block-kinds-templates/03-import.md b/docs/block-kinds-templates/03-import.md
new file mode 100644
index 0000000000..370e26ccec
--- /dev/null
+++ b/docs/block-kinds-templates/03-import.md
@@ -0,0 +1,694 @@
+# Track 3 — Import / Apply
+
+**Status: preamble + high-level TODO.** Dependency ordering and grounded entry points,
+not a per-file implementation path.
+
+Authoritative design: `docs/text/work/projects/block-kind-and-templates/decisions.md`,
+section *Template engine and Desktop* (`decisions.md:125-152`).
+
+## Goal
+
+Apply a hand-authored or exported `template-v1` YAML into a **new** project: parse,
+validate, resolve each entry's kind, create the project, add blocks in file order,
+navigate to the result.
+
+## In scope
+
+- **Fixed native YAML lambda** — the degenerate orchestrator hardcoded in TypeScript;
+  no QuickJS sandbox in v1 (`decisions.md:127`).
+- **Add-block / state API** — designed and used as the injected-lambda contract even
+  though the only v1 caller is native; the lambda reaches construction only through it
+  (`decisions.md:129`). Deriving this API is a hard requirement.
+- **Kind resolution** — resolve each entry's `kind@selector` off the per-kind
+  `overview.json` projection (single read + client-side semver; depends on track 1).
+  Selectors: `@X.Y.Z` / `~X.Y.Z` / `^X.Y.Z`. `allow-unstable` switches from the `stable`
+  set to the derived `any` set for the whole apply (`A-0034`, `A-0039`).
+- **Reference resolution** — engine maps each template-local `id` → fresh project-local
+  UUID and rewrites references to concrete *before* params reach a block's init lambda;
+  the block never sees an unresolved reference (`decisions.md:137,141`).
+- **Desktop command** — "Create Project from Template file…", headless apply, single
+  `allow-unstable` checkbox (default off) (`decisions.md:147`).
+- **Validation failures** — surfaced per stage, each identifying the failing entry and
+  cause; taxonomy/presentation left open (`decisions.md:150`).
+
+## Depends on
+
+- Track 1 kind resolution (per-kind `overview.json` projection, `~`/`^` selectors,
+  derived `any` channel) — **landed** in `2c2c15b3d`, see "Where the Adapter Actually
+  Stands".
+- The `template-v1` schema shared with export (track 2).
+
+## Out of scope
+
+- QuickJS sandbox host and template-delivered custom lambdas (`decisions.md:127-131`).
+- Applying into an **existing** project (`decisions.md:147`).
+- Guided wizard and settings modal (`decisions.md:145`).
+
+## High-Level TODO
+
+Dependency-ordered. Use `[~]`/`[x]` as work lands, matching the tracker convention in
+`01-kind-and-lifecycle.md` and `02-export.md`. Every path:line below was read, not
+inferred.
+
+**Contracts first (these two gate everything else)**
+
+- [~] **Params → initial storage (facade callback #8)** — landed as
+      `__pl_storage_initialFromParams`, a **new** callback rather than a widened
+      `StorageInitial`, wired end to end: `DataModel.getDataFromParams` →
+      `createInitialStorageFromParams` → registration in `BlockModelV3.done()` →
+      `ProjectHelper.getInitialStorageFromParamsInVM`. See "The Missing Half" below for what
+      was missing and why the shape came out this way. `Q-0009` — validating those params
+      against the kind — is now answered too; see "Params Against Their Kind"
+- [~] **Add-block / state API** — landed as `TemplateApplyApi` in
+      `lib/node/pl-middle-layer/src/model/template_apply.ts`, together with the fixed
+      orchestrator `applyProjectTemplateV1` that drives construction through it and nothing
+      else. See "The Construction Contract" below: it came out at **one method**, and the
+      reasons for that are the answer to the first open question. Remaining: the
+      implementation backed by a real project, which belongs with the engine
+
+**Kind resolution — consumed from track 1**
+
+- [~] **Resolve `kind@selector` → block pack spec** — the import side landed as
+      `resolveTemplateEntries` in `lib/node/pl-middle-layer/src/model/template_resolve.ts`,
+      against the `BlockPackProvider` port. Import owns the per-apply `allowUnstable` flag
+      and turning the three failure reasons into messages, both done and tested against a
+      fake provider. **Correction to an earlier entry here, which claimed nothing from
+      track 1 had landed:** `2c2c15b3d` (2026-07-24, "prototype the block-kind subsystem")
+      landed §5 and §6 — `RegistryV2Reader.getKindOverview` / `resolveKind`, the pure
+      `resolveKind` + `KindResolutionError` in
+      `tools/block-tools/src/v2/registry/kind_resolver.ts`, and the
+      `BlockPackRegistry.resolveKind` / `getOverview` facade
+      (`src/block_registry/registry.ts:292-323`). Remaining: the adapter, which is now
+      unblocked — see "Where the Adapter Actually Stands"
+- [~] **Honor the entry's `block` override** — same module, converging on the same
+      `BlockPackSpec` as the kind path (`decisions.md:118`). Includes the npm-name →
+      `{organization, name}` split the schema left to import (`project_template_v1.ts:52-56`),
+      as `parseBlockPackName`
+
+**Engine — parse, validate, construct**
+
+- [x] **YAML text → document** — `parseProjectTemplateV1Yaml` in
+      `lib/node/pl-middle-layer/src/model/template_parser.ts`, mirroring
+      `template_serializer.ts` on the other side. Most of the work turned out to be
+      diagnostics rather than parsing — see "Reading a File Someone Wrote By Hand"
+- [~] **Validate before the project exists** — `validateTemplateV1ForApply` in
+      `lib/node/pl-middle-layer/src/model/template_validate.ts`: reference consistency plus
+      the foreign-id guard, grouped by entry in file order. Entry shape, both grammars and
+      id uniqueness are already the parser's (`project_template_v1.ts:188-200`). Params
+      against their kind is `Q-0009`, now **resolved and implemented** — see "Params
+      Against Their Kind". The single report every stage feeds is `TemplateApplyReport`,
+      assembled by the driver
+- [x] **Reject params carrying a foreign block id** — same module (operator decision,
+      2026-08-03), using `inferAllReferencedBlocks` (`model/args.ts`), the detector export's
+      guard uses. **Correction to this plan:** it runs on the file-form params *before* any
+      rewrite, not after. In file form a legitimate reference is `{ block, output }`, which
+      the detector does not recognize at all, so everything it finds is foreign by
+      construction — nothing to subtract, and the check lands before the project exists,
+      where the plan says validation belongs. See "Stale Ids in Strings"
+- [x] **Id map + reference rewrite** — `createTemplateIdMap` in
+      `lib/node/pl-middle-layer/src/model/template_ids.ts`: assign a fresh UUID per entry,
+      then `fromTemplateForm(params, resolve)` (`template_form.ts:65`, already implemented
+      and tested) before params reach the block. Single forward pass, as planned — file
+      order is instantiation order and forward references are already rejected, so every
+      upstream id is mapped by the time it is needed. Assignment and publication came out
+      as two steps rather than one; see "Two Steps, Not One"
+- [x] **Construction loop** — `createTemplateApplyApi` in
+      `lib/node/pl-middle-layer/src/mutator/template_construct.ts` is the in-transaction
+      half, `MiddleLayer.applyTemplateToProject(id, document, provider, options)` the
+      driver. Both decisions the plan left open are resolved, and neither the way it
+      guessed: **one** transaction rather than N, because the construction contract already
+      committed to a synchronous API and `Project.addBlock` is async end to end; and
+      `NewBlockSpec.fromModel` gained an optional `initialStorage` rather than a third arm,
+      because seeding from params produces exactly the storage the block would have written
+      itself. See "Four Stages, and Where the Project Appears"
+- [x] **Failure policy — keep the partial project and report** (operator decision,
+      2026-08-03). Wired: the three stages before construction create nothing, so a bad
+      file leaves the project untouched, and a failure inside construction commits the
+      blocks that landed and reports the entry that stopped it. **Correction to this plan:**
+      apply does *not* create the project — the caller does, which is what makes the first
+      three stages free of cleanup. Deleting the project was never on the table for the
+      same reason it was rejected here: the blocks that landed are valid and the report is
+      the only record of how far it got
+
+**Desktop**
+
+- [x] **"Create Project from Template file…"** — `CreateProjectFromTemplate` in
+      `platforma-desktop-app/packages/main/src/tasks/`, over a `createProjectFromTemplate`
+      worker method. Asks for the file first (the reverse of export, which must render
+      before it can offer a path), parses before creating anything, then navigates to the
+      result. The root block pack the existing `CreateProject` auto-adds
+      (`tasks/CreateProject.ts:41-52`) is deliberately absent — the template supplies every
+      block. `allow-unstable` is a task option, default off, with no control yet: the
+      checkbox belongs with the dialog that does not exist. See "The Desktop Command"
+- [x] **Entry point placement** — a ghost button beside "Create New Project" on the
+      projects list, where the create flow already lives; import creates a project, so it
+      has no card to hang off. UX deferred as export's was: a button and a native alert,
+      no dedicated dialog
+
+**Validation**
+
+- [ ] **Apply the golden fixtures** — the five files under
+      `lib/node/pl-middle-layer/test_fixtures/template-v1/` are ready-made inputs, and
+      `scalar-quoting.yaml` covers the scalar hazards a hand-authored file brings. Needs a
+      stub kind resolver plus a stub block-pack preparer to run without a registry
+- [ ] **Round-trip** — export → import → equivalent project. The north-star acceptance
+      criterion and the last open checkbox in `02-export.md`. Defining "equivalent" is
+      part of the work: structure order, per-block derived args, not resource ids
+
+## The Missing Half — Params → Initial Storage
+
+Export's callback #7 turns a block's stored data into params. Apply needs the inverse, and
+**it does not exist at runtime today** — verified end to end:
+
+- The type channel is already there: `DataCreateFn<T, Params> = (args: { params?: Params })
+  => T` (`sdk/model/src/block_migrations.ts:13`), and a kind's `Params` "flows into
+  `.init()`" through `DataModelBuilder` (`:542-555`).
+- Nothing ever fills it. `DataModel.initialData()` and `getDefaultData()` both call
+  `initialDataFn({})` (`:667`, `:675`), so `params` is always `undefined`.
+- The facade callback takes no arguments — `StorageInitial: () => StringifiedJson`
+  (`sdk/model/src/block_storage_facade.ts:192`) — and neither does its middle-layer
+  invoker, `ProjectHelper.getInitialStorageInVM(blockConfig)`
+  (`model/project_helper.ts:250`). Its three callers are new-block creation
+  (`mutator/project.ts:1221`, the `fromModel` arm of `initializeNewBlock` — the exact seam
+  apply needs), `resetToInitialStorage` (`:857`) and `migrateBlockPack` (`:1541`).
+
+### What Landed
+
+A params-carrying variant at every one of those layers, mirroring what export added for #7:
+
+| Layer | Added |
+|-------|-------|
+| `sdk/model/src/block_migrations.ts` | `DataModel.getDataFromParams(params)` beside `getDefaultData()` |
+| `sdk/model/src/block_storage_callbacks.ts` | `createInitialStorageFromParams`, sharing `assembleStorage` with `createInitialStorage` |
+| `sdk/model/src/block_storage_facade.ts` | `StorageInitialFromParams: "__pl_storage_initialFromParams"` and its signature |
+| `sdk/model/src/block_model.ts` | registration in `done()` |
+| `lib/node/pl-middle-layer/src/model/project_helper.ts` | `getInitialStorageFromParamsInVM(blockConfig, params)` |
+
+Pinned by `sdk/model/src/template_init.test.ts` (11) and
+`lib/node/pl-middle-layer/src/model/project_helper_params_init.test.ts` (7). The middle-layer
+tests drive a hand-written model bundle, which is what lets every failure branch be
+exercised on purpose — and needs neither a built block nor a backend.
+
+**A new callback, not a widened `StorageInitial`** — the one decision worth recording. A
+widened callback is the smaller surface, but a block bundled with an older SDK would still
+accept the call and ignore the extra argument, producing a default-initialized block that
+looks like a successful apply. A separate callback is simply absent from such a block, so the
+middle layer sees it missing and says so. That asymmetry between *cannot* and *silently did
+not* is the whole argument, and it matches the facade's own rule that new callbacks are the
+compatible way to extend it (`block_storage_facade.ts:25-32`).
+
+Consequences worth knowing:
+
+- **There is no params-less path any more** (2026-08-04 — `A-0056`). An entry that omits
+  `params` is read as `{}` and goes through the params callback like any other, rather than
+  being routed to `StorageInitial`. The block produced is identical either way — both reach
+  the same init factory — but only this way is the entry checked against its kind, so an
+  omitted key can no longer apply params the contract would have rejected. `StorageInitial`
+  remains the UI-creation path, where there genuinely are none. A block predating the storage
+  facade is still refused outright, for a reason that has nothing to do with params; see
+  "Four Stages, and Where the Project Appears".
+- **Params cross as text, references already resolved.** `undefined` is normalized to `{}` at
+  the boundary, because `JSON.stringify(undefined)` is not a string and the callback would be
+  handed nothing.
+- **A block's init factory decides what is valid.** A factory that throws is reported as a
+  per-entry problem, not propagated — the same collect-everything shape export uses.
+- **`Q-0009` was answered at this seam.** It is the only place a hand-authored file's params
+  meet the kind that types them, and that is where the check landed — see "Params Against
+  Their Kind".
+
+## The Construction Contract
+
+`TemplateApplyApi` is one method — `addBlock({ id, params? }) → { ok, blockId } | { ok, error }`
+— and the fixed orchestrator that drives it is a dozen lines. That is the design, not an
+unfinished draft: everything an orchestrator does not decide was pushed to the
+implementation, because every one of those decisions is either unsafe or duplicated work if
+an orchestrator makes it.
+
+What is deliberately **not** in the request, and why:
+
+| Absent | Why |
+|--------|-----|
+| block pack / kind / version | The entry is named by its template-local `id` and the implementation looks up what it already resolved for it, so no orchestrator can substitute an implementation the document was never validated against |
+| the project-local id | Assigned by the implementation, which keeps the id map in the one place that needs it to rewrite references |
+| a label | A template names no block instances, so the label is the implementation's to choose — the block package's own title once the provider returns it, the entry's id until then |
+| resolved references | Params cross **in file form**, references still naming entries; rewriting them is the implementation's job, since only it knows the assigned ids. An orchestrator that rewrote them would need the id map, and every orchestrator would own a copy of the same logic |
+
+Two properties follow from this being the contract a sandboxed orchestrator will receive,
+and both constrain the eventual implementation:
+
+- **Plain data only.** Arguments and results are JSON values — hence failures as strings in
+  a result rather than throws.
+- **Synchronous.** Everything slow must already be in hand before the orchestrator runs:
+  kinds resolved, block packs fetched, project created. What remains is in-memory work
+  inside a single transaction, so no async bridge is needed for the sandbox and an apply
+  cannot be interrupted mid-way by a network call. This also settled the transaction question
+  in the construction-loop item before it was asked: prepare all entries up front, add them
+  in one mutator pass, rather than one transaction per block as `Project.addBlock` does.
+
+**Stop at the first failure** — the refinement of the keep-and-report policy. Entries after
+the failure may reference it, so continuing would place blocks whose upstream is missing:
+a project wired to nothing in the middle is worse than one short a tail. What already
+landed is kept and returned, paired file-id to assigned-id, so the caller can say how far
+it got.
+
+Pinned by `template_apply.test.ts` (9), driven against a recording fake. That the tests need
+no project, backend or registry is itself the check that the contract is narrow enough to
+hand to a sandbox.
+
+## Reading a File Someone Wrote By Hand
+
+`parseProjectTemplateV1Yaml(text)` is two library calls — `YAML.parse` then the shared
+`parseProjectTemplateV1` — wrapped in the diagnostics that make the difference between a
+file someone can fix and one they can only re-generate. Export's reader was always our own
+output; this one's input is a person's.
+
+Failures return one message rather than per-entry problems: until the document parses there
+are no entries to attach anything to. The message is multi-line when the file has several
+fixable issues, because fixing it should take one pass.
+
+Cases given their own wording, each replacing something unhelpful:
+
+| Input | Instead of | Says |
+|-------|-----------|------|
+| empty / blank / comments only | `expected object, received null` | "The file is empty." |
+| top-level scalar or list | `expected object, received array` | what a template's top level looks like |
+| `schema: template-v2`, or no `schema` | `Invalid literal value, expected "template-v1"` | that this is not a template-v1 file, and what it claims to be |
+| YAML syntax error, repeated key, tab indent | the library's code frame | the same message trimmed to `at line L, column C` |
+| schema issues | `blocks.0.kind` | `blocks[0].kind`, counted and listed together |
+
+Two behaviours worth knowing, both pinned by tests:
+
+- **Read as YAML 1.2**, while export quotes as if for 1.1. Deliberate on both ends: quoting
+  against the stricter ruleset makes a file we write mean one thing to every reader, and
+  reading with the looser one keeps a hand-written bare `yes` or `1:30` the string it looks
+  like instead of `true` or `90`.
+- **Repeated keys are an error**, not last-wins. A copied entry with a field left unchanged
+  would otherwise apply, wrongly and silently.
+
+Pinned by `template_parser.test.ts` (18), which also parses every golden export fixture and
+round-trips document → text → document, so the two text layers are checked against each
+other and not only against files.
+
+## Params Against Their Kind — `Q-0009` Resolved
+
+**A kind ships a runtime check for its params** (operator decision, 2026-08-03, chosen to
+spend build-time effort instead of debugging time later; made **mandatory** 2026-08-04 —
+`A-0057`). `defineBlockKind` requires `parseTemplateParams: (value: unknown) => BlockParams`;
+the SDK applies it wherever params arrive untyped, and the middle layer asks for it alone as
+a pre-flight.
+
+This **reverses** track 1's "`BlockParams` is a pure TS type" decision rather than narrowing
+it. A kind is no longer a types-only artifact: every kind ships executable code, depends on
+whatever validates its params, and enters the model bundle. The validator is the author's
+choice — the field is a plain function and a hand-written check satisfies it — with zod as
+the default the workspace kinds and the scaffold use.
+
+There is no unchecked pass left, so the `checked` flag that used to distinguish one is gone
+from `TemplateParamsValidationResult`, the facade callback, and `validateTemplateParamsInVM`.
+The only remaining unchecked path is a block whose model predates the callback, and such a
+block is refused outright at placement.
+
+### Why it was worth doing
+
+Measured on `enter-numbers` (kind params `{ numbers?: number[] }`) before the check existed
+— params straight from a file, through init, to derived args:
+
+| YAML | Was | Now |
+|------|-----|-----|
+| `numbers: [3,1,2]` | `args={numbers:[1,2,3]}` | accepted |
+| `number: [3,1,2]` (typo) | block created empty, later "Numbers are required!" | `Unrecognized key(s) in object: 'number'` |
+| `numbers: ["3","1","2"]` | **silently** `args={numbers:["1","2","3"]}` — numeric sort became lexicographic | `numbers[0]: Expected number, received string; …` |
+| `numbers: "1,2,3"` | `args() threw: not a function` | `numbers: Expected array, received string` |
+| `numbers: [1], colour: red` | extra key silently dropped | `Unrecognized key(s) in object: 'colour'` |
+| `numbers: null` | block created empty, later "Numbers are required!" | `numbers: Expected array, received null` |
+
+The third row is the one that mattered: no error anywhere, and a wrong scientific result.
+
+### Shape of it
+
+- **The kind owns the check, not the block.** Many block versions implement one kind; a
+  per-block check could drift between them and from the type.
+- **`.strict()` is where most of the value is.** Two of the six rows above are a
+  misspelled or stray key — invisible to any type-shaped check that only looks at what it
+  knows about.
+- **The parser returns the params to use**, so it can strip and coerce; its output is what
+  reaches the block's `init`.
+- **TypeScript keeps schema and type in step**: the parser must return `BlockParams`, so a
+  schema missing a declared field does not compile. A schema *looser* than the type is not
+  caught — the honest limit.
+- **Two call sites, one function.** Facade callback #9 `__pl_templateParams_validate` is
+  the pre-flight (`ProjectHelper.validateTemplateParamsInVM`) — nothing is created, so a bad
+  file is reported entry by entry with no project to half-build. Callback #8 re-checks
+  anyway, so the factory can never be handed params the kind refused, whichever path got
+  there.
+- **`checked: false` is not a failure.** It reports that the kind declares no check. A
+  block whose model predates the callback is treated the same way: the pre-flight creates
+  nothing, so proceeding costs nothing, and the entry still fails clearly when applied.
+- **Rejections are rendered, not dumped.** A zod error's own `message` is its whole issue
+  array as JSON; the SDK duck-types `{ issues: [{ path, message }] }` and renders
+  `numbers[0]: Expected number, received string`, matching how the file is written. No
+  schema library is prescribed or depended on.
+
+### Cost, measured — and the build change it forced
+
+Declaring the schema first grew `enter-numbers`' model bundle **382 kB → 501 kB**: zod was
+bundled *inside* the kind's own `dist/kind.js` (that build inlines everything) and so arrived
+as a second copy alongside the model's own zod. Not a static cost —
+`executeSingleLambda` evaluates the whole model bundle on **every** callback invocation, so a
+duplicated dependency is paid per call.
+
+**Fixed by building a kind twice, the way a model already is** (operator direction):
+
+| Artifact | Dependencies | Who consumes it |
+|----------|--------------|-----------------|
+| `dist/index.js` / `index.cjs` | external | blocks importing the kind |
+| `dist/kind.js` | inlined | the registry, and `build-kind-manifest`'s hash |
+
+`createRolldownBlockKindConfig` now prepends the standard node config, and the structurer's
+`kind-package-json` rule points `main`/`module`/`types`/`exports` at the externalized pair
+(all three of `import`/`require`/`default` spelled out, since `build-model` reaches a kind
+through `require`). The self-contained bundle stays on disk for the registry and is no longer
+an entry point.
+
+Result: **382 kB → 401 kB**, one copy of zod in the bundle (verified), i.e. ~19 kB for the
+schema itself instead of ~119 kB for the schema plus a duplicate library. A kind that
+declares no check still pays nothing.
+
+## Validation: Two Checks, One Report
+
+`validateTemplateV1ForApply(document)` holds everything knowable from the document alone —
+no registry, no project. That placement is the substance of the check: the same findings
+made one stage later would have to be reported against a half-built project.
+
+- **References name an earlier entry.** Detection is shared with export
+  (`findProjectTemplateV1ReferenceProblems`); the wording is not. Export tells a developer
+  their project cannot be written out; this tells a reader which edit fixes their file —
+  "move 'b' above this entry", not "blocks order is the instantiation order". The shared
+  finding is structured (`reason` is a discriminant) precisely so each direction can word
+  it for its own reader.
+- **No params carry a block id from another project.** The mirror of export's guard, and
+  the reason it is cheap: in file form a legitimate reference is `{ block, output }`, a
+  shape `inferAllReferencedBlocks` does not recognize, so anything it finds is foreign with
+  nothing to subtract. Caught in an object, in a canonicalized string, and through repeated
+  `JSON.stringify` nesting — the enrichment case that started this.
+
+Problems are grouped by entry in file order, so the report reads alongside the file and an
+entry's problems appear together. Everything is collected: three mistakes, one pass.
+
+Params against their kind are checked separately, and one stage later: that check needs each
+entry's block config, which only exists once resolution has fetched it. See "Params Against
+Their Kind".
+
+Pinned by `template_validate.test.ts` (14). Two of them exist to keep the guard from
+over-reaching: a `{ block, output }` reference must not be mistaken for a foreign id, and a
+uuid that is merely *data* in params — a sample id, a note — must be left alone.
+
+## Resolution, and What It Left Open
+
+`resolveTemplateEntries(document, provider, { allowUnstable })` is the first stage of an
+apply and the only one that touches the network. It runs before the project exists, which
+is what makes "no block for this entry" a message about a file rather than a half-built
+project — and, since it hoists all the slow work, it is also what lets the construction API
+be synchronous.
+
+Both of an entry's routes to an implementation go through `BlockPackProvider` and come back
+as the same `BlockPackSpec`, so nothing downstream cares which route an entry took:
+
+| Route | Port method | When |
+|-------|-------------|------|
+| kind selector | `byKind(kind, { allowUnstable })` | the normal case |
+| pinned version | `byExactVersion(id)` | the entry carries a `block` override |
+
+Import owns the messages, and each of the resolver's three failure reasons has a different
+way out — which is the reason they stay distinct rather than collapsing into "not found":
+the selector matches no published kind version (the file or the registry is wrong), the kind
+version exists but nothing implements it (nothing can be installed yet), or implementations
+exist but none is stable (**import again with unstable allowed** — the only one the reader
+can clear without editing the file, and the reason the checkbox exists). Every entry is
+attempted and every failure collected, so an unapplicable file takes one pass to fix.
+`resolved` shorter than the document is the signal not to apply it.
+
+`allowUnstable` is per apply, never per entry: a file that resolved some entries to stable
+blocks and others to pre-releases would be unreproducible in a way the file itself does not
+record.
+
+**Open — which registry.** A template names no registry, and both routes need one. The port
+keeps that on the far side deliberately (it is a property of the environment, not the file),
+but the adapter has to answer it: the primary registry only, or every configured one in
+order, with a policy for a name that exists in two. Worth settling before the adapter, since
+it also decides what "not found" means in a multi-registry setup.
+
+## Where the Adapter Actually Stands
+
+This tracker said for three entries that nothing from track 1 had landed. That was wrong,
+and it made the adapter look blocked when it is not. `2c2c15b3d` (2026-07-24) landed the kind
+subsystem prototype, including everything the port needs:
+
+| Port method | What already exists |
+|-------------|---------------------|
+| `byKind` | `BlockPackRegistry.resolveKind(registryId, ref, { allowUnstable })` (`block_registry/registry.ts:314`) → `RegistryV2Reader.resolveKind` → `getKindOverview` + the pure `resolveKind` in `block-tools/src/v2/registry/kind_resolver.ts` |
+| `byExactVersion` | `BlockPackRegistry.getOverview(registryId, id, channel)` → `RegistryV2Reader.getSpecificOverview`, which returns `{ id, meta, spec }` |
+
+The reader's own `KindResolution` carries **exactly** the three reasons this port declares —
+`no-matching-kind-version`, `no-implementation`, `no-stable-implementation` — because the port
+was written against it. The one shape difference is real and unchanged: the reader *throws*
+`KindResolutionError` where the port returns a union, so the adapter's `byKind` is a
+try/catch that reads `e.reason`.
+
+What is still genuinely open is the registry question below, plus `registryId`: both facade
+methods take one, while a resolved spec carries a `registryUrl`. The adapter picks the
+registry, so it has the id in hand — but that is the same decision as "which registry", not a
+separate one.
+
+## The Label, and Why It Is the Registry's
+
+A block created from a template is placed under the block package's published title, which
+resolution carries as `ResolvedEntry.title`. The first implementation used the entry's own id
+instead, which is wrong in a way worth recording, because the reasoning that produced it was
+plausible:
+
+- **An exported template names its entries by the source project's block ids**
+  (`template_export.ts:19-22`), which the golden fixtures show as
+  `aaaaaaaa-0000-4000-8000-000000000001`. So "the id is what the file called this block" holds
+  only for hand-written files — on the export → import path it is a UUID.
+- **That UUID would be visible.** `project_overview.ts:288` computes `label: title ??
+  defaultLabel`, where `title` comes from the model's own `title` lambda and `defaultLabel` is
+  the structure's `label`. Nine of the 63 blocks in `blocks/*` declare no `title` lambda —
+  `graph-maker`, `table`, `differential-expression`, `blast`, `makeblastdb`, `gene-browser`,
+  `immuno-match`, `import-bulk-count-matrix`, `xsv-import` — and the desktop renders
+  `overview.title`, so for those the label *is* the name in the sidebar.
+- **`Block.label` is `@deprecated` but not optional**, and there is no replacement field to
+  write instead: `title`/`subtitle` are render lambdas in the block's config, not project
+  state. So the question was never whether to write it, only what to write.
+- **The middle layer has no other source, by construction.** `Project.addBlock` takes the
+  label as an argument precisely because of that, and both desktop callers pass
+  `pack.meta.title` off a registry listing they already fetched for display
+  (`AddBlockModal/components/DetailedCard.vue:123`, `main/src/tasks/CreateProject.ts:50`). A
+  prepared block pack carries the model, the workflow and the frontend; none of them names the
+  block. The update watcher returns specs, not meta.
+
+Hence `title` on the port, required rather than optional: an adapter always has one — it reads
+the manifest — and every fallback a caller downstream could invent is worse than asking.
+
+**Cost, and a cheaper follow-up.** On the pinned route it is free: `getSpecificOverview`
+already returns `meta`. On the kind route the adapter needs one extra manifest read after
+`resolveKind`. Note that `prepare` *already* reads that manifest — `getComponents`
+(`registry_reader.ts:250-265`) parses all of it and keeps only the component URLs in its LRU.
+Widening that cache to retain `description.meta` would make the title free on both routes; it
+touches block-tools' caching, so it is a follow-up rather than part of this.
+
+## What Import Gets For Free
+
+Track 2 left more than the schema behind. Already implemented and tested, consumed by
+import unchanged: `parseProjectTemplateV1` (shape, grammars, id uniqueness),
+`findProjectTemplateV1ReferenceProblems` (self / unknown / forward, structured),
+`fromTemplateForm` (the apply half of the params codec), the selector grammar in
+`kind_selector.ts` (`~`/`^`/exact, which track 1's `selectorToRange` translates to semver
+ranges), and five golden `template-v1` files.
+
+## Open questions
+
+- ~~[TODO: concrete add-block API shape — add-by-kind vs add-by-exact-version,
+  inter-block reference resolution order (`decisions.md:133`).]~~ **Answered** — see "The
+  Construction Contract". Neither: an orchestrator adds by *entry*, and which
+  implementation that entry resolved to is not its to choose. Reference order is the single
+  forward pass, and the rewrite itself never crosses the API.
+- [TODO: concrete type for a template-local reference — distinct unresolved type vs
+  reused reference shape (`decisions.md:143`).] **Answered by track 2**: a distinct type,
+  `TemplateLocalRef`, recognized structurally by the reserved `{ block, output }` shape.
+  Confirm rather than re-decide.
+- [TODO: validation taxonomy and presentation — blocking dialog vs inline list,
+  fail-fast vs collect-all.] **Fail-fast vs collect-all is settled**, and by stage rather
+  than by taste: everything that creates nothing collects every problem, placement stops at
+  the first. One report shape carries both (`TemplateApplyReport`). Presentation is still
+  open, and is the desktop's.
+- ~~**`Q-0009`** — apply-time validation of untyped YAML params.~~ **Resolved** (operator
+  decision, 2026-08-03; parser made mandatory 2026-08-04 — `A-0057`): every kind declares
+  `parseTemplateParams`, applied wherever params arrive untyped. See "Params Against Their
+  Kind". The bundle-size cost is now paid by every kind rather than by opt-in ones; the
+  twice-built kind keeps it to the schema itself (~4 kB per model) instead of a second copy
+  of the validator inside the model bundle.
+- ~~References inside a `PObjectId` string are invisible to the structural rewrite —
+  decide whether apply rejects them.~~ **Decided: apply rejects** (operator decision,
+  2026-08-03). See "Stale Ids in Strings" and the guard in the validation stage.
+
+## Stale Ids in Strings
+
+Why the guard above exists, since the case is easy to miss. An ordinary inter-block
+reference is an object, so the rewrite sees it:
+
+```ts
+{ __isRef: true, blockId: "aaaaaaaa-…-0001", name: "clonotypes" }
+```
+
+An enrichment reference carries the same object *inside a string*: `EnrichmentRef.hit` and
+`EnrichmentStep.linker` are `PObjectId`s in global form, i.e. `canonicalize` of exactly that
+object (`lib/model/common/src/ref.ts:139-151`):
+
+```yaml
+params:
+  enrichment:
+    __isEnrichment: v1
+    hit: '{"__isRef":true,"blockId":"aaaaaaaa-0000-4000-8000-000000000001","name":"clonotypes"}'
+```
+
+`mapTemplateRefs` reaches `hit`, finds a string, and returns it untouched. On apply the
+entry's own id is remapped to a fresh UUID and every `{ block, output }` is rewritten, while
+this string keeps pointing at a UUID from the project the file was written in — a block that
+does not exist here. Nothing throws: the shape is valid, the schema is valid, the params
+merely name nothing. That silence is the reason to reject rather than warn.
+
+Rewriting inside the string was rejected instead: it would require matching the escape
+depth on both sides, and no block is known to put an enrichment reference in its params.
+
+## Two Steps, Not One
+
+`createTemplateIdMap` is the whole of the id map: `assign` hands an entry a project-local
+UUID, `record` publishes it as a reference target, and `liveParams` rewrites one entry's
+params from file form into live form. It lives with the `TemplateApplyApi` implementation
+rather than with the orchestrator, because an orchestrator that knew the map would also own
+the rewrite, and every orchestrator would then carry a copy of it.
+
+The plan said "assign a fresh UUID per entry, then rewrite" — one step. It came out as two,
+and the split is the only design content in the module. An id is generated when a block is
+about to be created, but only becomes resolvable once the block exists, so the window
+between the two is where a per-entry pass rewrites that entry's params. Two things fall out
+of it, both for free:
+
+- **An entry cannot reference itself.** Its own id is still unpublished while its params are
+  being rewritten, so a self-reference is reported instead of silently connecting a block to
+  its own output.
+- **Params are never wired to a block that failed to be created.** Which matters
+  specifically here: a failed apply keeps the blocks that already landed, so there is no
+  unwind to hide a bad mapping.
+
+Both are already rejected by validation. The point is not to check twice — it is that the
+map's ordering makes the failures unreachable rather than trusting an earlier stage, and if
+one does arrive it comes back as a reported problem rather than a throw. That direction is
+forced: by the time params are rewritten, earlier blocks are in the project, and the failure
+policy is to keep them and say how far the apply got. A duplicate `assign` is the one thing
+that does throw — entry ids are unique by the schema, so a second assignment for the same
+entry means the document never went through the parser, and the first block would be
+silently orphaned.
+
+Id generation is injectable, defaulting to the `randomUUID` that `Project.addBlock` would
+have used itself. That is what lets `template_ids.test.ts` (15) run the forward pass —
+assign, rewrite, create, record over a three-entry chain — with named ids and no project.
+
+## Four Stages, and Where the Project Appears
+
+`MiddleLayer.applyTemplateToProject(id, document, provider, options)` is the driver, and
+`createTemplateApplyApi` is what it hands the orchestrator inside the transaction. The
+stages, in order:
+
+| Stage | Creates | On failure |
+|-------|---------|------------|
+| check the document | nothing | every problem at once, project untouched |
+| resolve every entry | nothing | every problem at once, project untouched |
+| prepare every block | nothing in the project | every problem at once, project untouched |
+| place the blocks | the blocks | stops at the entry, keeps what landed |
+
+The ordering is the whole failure policy. Three stages that create nothing means almost
+every way a template can be wrong is reported with nothing to clean up, and the one stage
+that does create is left with only in-memory work — which is what lets it be a single
+transaction, and what made the synchronous construction contract implementable.
+
+**The project is the caller's.** The plan said apply creates it; it does not. Applying a
+template is a property of the stored project rather than of a session with it — the same
+reasoning `exportProjectAsTemplate` uses — so the entry point takes a project id, and
+"Create Project from Template file…" is `createProject` followed by this. That also removes
+the awkward case the plan carried: a document that fails validation would otherwise have
+left an empty project behind.
+
+Two plan questions resolved, neither the way it framed them:
+
+- **N transactions or a batch?** Neither was open, in the end. The construction contract
+  fixed a synchronous `addBlock`, and `Project.addBlock` is async end to end — prepare, cache,
+  transaction, refresh — so it cannot be called from one. Everything slow is hoisted into
+  stage 3 and the transaction is entered once. The mutator's own `addBlock` is called N times
+  inside it, which is in-memory work.
+- **`NewBlockSpec`: extend `fromModel` or add a third arm?** Extended, with an optional
+  `initialStorage`. What comes back from the block's params initializer is the same storage
+  that block would have written itself, so args derivation downstream is untouched — this is
+  `fromModel` with one input supplied, not a new mode. Passing it in rather than having the
+  mutator call the VM is also what keeps the rejection *outside* the mutation: params a block
+  declines are a reported problem, and the mutator gains no failure path it did not have.
+
+Two smaller things the implementation settled:
+
+- **A block too old for the facade is refused**, even with no params to ignore. Every entry
+  names a kind and a block predating the facade implements none, so creating one would honour
+  the entry's pinned version while contradicting the kind it claims. Kind resolution cannot
+  produce this; a `block` override can.
+- **The pre-flight params check runs on the live shape with the file's own ids**
+  (`liveParamsForCheck`). Checking the file form directly would fail every entry that carries
+  a reference: a kind describing a param as a reference sees `{ block, output }` and rejects
+  it. Feeding it `PlRef`s whose `blockId` is still a template-local id asks the only question
+  this stage can answer — are the params the right shape — and leaves what they point at to
+  validation, which already owns it.
+
+The label is the block package's published title, carried from resolution. It went in as the
+entry's own id first, which would have put UUIDs in the sidebar — see "The Label, and Why It
+Is the Registry's".
+
+Pinned by `template_construct.test.ts` (13), which fakes the one mutator method construction
+uses and keeps everything else real: a real `ProjectHelper`, a real model VM, real block code.
+The driver itself is not covered — it needs a backend — which is why nothing but sequencing
+lives in it.
+
+## The Desktop Command
+
+`CreateProjectFromTemplate` (main) over `createProjectFromTemplate` (worker), with a ghost
+button beside "Create New Project". The flow, and the two decisions in it:
+
+1. Ask for the file. **First**, unlike export, which has to render the document before it
+   can offer a save path — here the file is the input, so there is nothing to compute
+   before asking.
+2. Read it, derive the project's label from the file name, deduplicate against existing
+   labels (`Name (2)`, the shape `DuplicateProject` already uses).
+3. Parse. A file that is not a template creates nothing.
+4. `createProject`, then `applyTemplateToProject`.
+5. Navigate to the project.
+
+**The label comes from the file name, not a prompt.** Export names its file after the
+project's label (`My-Study.template.yaml`), so stripping the two suffixes recovers it and
+the round trip keeps the name. It also keeps the command at one dialog, which is the whole
+UX budget this step has.
+
+**Landing nothing drops the project again.** The middle layer's stages that create nothing
+run *inside* `applyTemplateToProject`, so the worker has to create the project before it can
+learn that, say, resolution failed — and then it holds an empty project the user never
+asked for. So: zero blocks added and at least one problem → delete it and report. An empty
+project is not a partial result, it is litter, and it is seconds old. One or more blocks
+added → keep, navigate, and say what is missing, since a project short a few blocks looks
+exactly like a complete one.
+
+`allow-unstable` is a task option defaulting to off, with nothing wired to it yet. The
+checkbox the plan calls for belongs with the import dialog, and the dialog is the deferred
+part; the resolution path already honours the flag, and it is one argument away.
+
+**Not exercised end to end, and cannot be yet.** `byKind` asks a registry for a kind
+projection, and no published block declares a kind — `sdk/block-kind` exists only on this
+branch. Until a kind is published, the only template that can apply against a real registry
+is one whose entries carry a `block` override, which takes the `byExactVersion` route. That
+is the check to run first once a kind ships.
diff --git a/docs/block-kinds-templates/04-column-refs-migration.md b/docs/block-kinds-templates/04-column-refs-migration.md
new file mode 100644
index 0000000000..38835867c2
--- /dev/null
+++ b/docs/block-kinds-templates/04-column-refs-migration.md
@@ -0,0 +1,192 @@
+# Amendment — References In `template-v1`
+
+Amends the schema shared by [`02-export.md`](./02-export.md) and
+[`03-import.md`](./03-import.md). Status: **implemented** (`05e901eee`, `5d810ec7a`).
+Nothing here is released — `template-v1` is not on main and no template has shipped — so this
+replaced the earlier shape in place, with no `v2` and no migration path for existing files.
+
+## What Changed
+
+The template engine used to parse column identifiers in order to move block ids between
+projects. That meant it carried a model of the whole reference system: five key forms, nesting
+by string, canonicalization, identifiers in map keys. Every time that system grew, the engine
+would have to grow with it — or silently drop whatever it did not recognize.
+
+It parses nothing now. A block's params travel **as is**, and the only structure anyone
+downstream recognizes is a wrapper:
+
+```ts
+type TemplateRef<T> = { $ref: T };
+```
+
+The SDK puts those wrappers on inside the block's own bundle, where the reference system is
+already known; the document stores what is inside them verbatim; apply redirects the block ids
+inside a payload textually and hands the payload back unwrapped.
+
+Three layers, and each knows exactly one thing:
+
+| Layer | Knows |
+|-------|-------|
+| `wrapTemplateRefs` (`pl-model-common`, runs in the block's bundle) | which values are column identifiers |
+| the document | that `{ $ref: … }` marks something redirectable |
+| `remapRefPayload` / `resolveTemplateRefs` | how to replace a JSON string token |
+
+## The File
+
+Params are the block's own values, with wrappers where the identifiers were. Kind names below
+are illustrative; the golden fixture this mirrors is
+`lib/node/pl-middle-layer/test_fixtures/template-v1/wrapped-refs.yaml`.
+
+```yaml
+schema: template-v1
+blocks:
+  - id: aaaaaaaa-0000-4000-8000-000000000001
+    kind: "@platforma-open/milaboratories.import-fastq.kind@2.1.0"
+    params: {}
+
+  - id: bbbbbbbb-0000-4000-8000-000000000002
+    kind: "@platforma-open/milaboratories.clonotype-browser.kind@1.2.10"
+    params:
+      # A filtered column id: a canonical JSON string with the block id buried two encodings
+      # deep. Written exactly as the block stored it — ugly, and nobody has to read it.
+      anchor:
+        $ref: '{"__isFiltered":true,"axisFilters":[[0,"IGH"]],"source":"{\"__isRef\":true,\"blockId\":\"aaaaaaaa-0000-4000-8000-000000000001\",\"name\":\"clonotypes\"}"}'
+      # The same column as a `PlRef` object, marked the same way.
+      upstream:
+        $ref:
+          __isRef: true
+          blockId: aaaaaaaa-0000-4000-8000-000000000001
+          name: clonotypes
+      # Each identifier is marked where it sits, so an array of references is an array of
+      # wrappers rather than one wrapper around the array.
+      inputs:
+        - $ref:
+            __isRef: true
+            blockId: aaaaaaaa-0000-4000-8000-000000000001
+            name: reads
+      # Ordinary data, untouched: a uuid that is a sample id, not a reference.
+      sampleId: 3f1b8c2e-5d4a-4c9f-8b17-2a6e0d9f4c31
+      species: hsa
+```
+
+`blockId` inside a payload names a **template entry**, which on export is the block's own
+project-local id — a template has no id namespace of its own, so nothing is renamed on the way
+out.
+
+## How A Redirect Reaches A Nested Id
+
+`remapRefPayload` serializes the payload, replaces the ids, and parses it back. The pattern is
+`String.raw`(\\*")(id1|id2)(\\*")`` — whole JSON string tokens, with **any run** of backslashes
+escaping their quotes.
+
+That run is the whole trick. One JSON encoding around an identifier means one backslash before
+its quotes, two means three, three means seven. Because the run is unbounded, nesting depth
+does not exist as a case: a filtered id over a discovered id over a leaf matches at exactly one
+place, and the delimiters found are put back unchanged.
+
+Anchoring on the quotes is not cosmetic: without it an entry id of `a` would rewrite the `a`
+inside an unrelated `"reads"`. Both properties are pinned in
+`lib/model/common/src/template/template_ref.test.ts`.
+
+Canonical form survives, because canonical JSON sorts keys and a redirect only changes values.
+The one exception is below.
+
+## Normative Behavior
+
+### The Marker
+
+When projecting a block's template params, the SDK shall wrap each column identifier it
+recognizes in a `{ $ref: … }` wrapper.
+
+The SDK shall recognize a column identifier in either spelling — the key object and the
+canonical string — at any depth inside the params, and under any number of `JSON.stringify`
+passes.
+
+The SDK shall not descend into a value it recognized as a column identifier.
+
+The SDK shall leave a value that is already wrapped unchanged.
+
+### Document Parser
+
+The document parser shall treat an object whose only key is `$ref` as a reference.
+
+The document parser shall not treat any other value inside an entry's `params` as a reference.
+
+The document parser shall not inspect what a reference wraps.
+
+### Exporter
+
+The exporter shall write an entry's `params` exactly as the block projected them.
+
+### Apply
+
+When applying a template, the apply engine shall replace, inside each reference payload, every
+template-local entry id it was given with the block id that entry received.
+
+The apply engine shall replace each reference with its payload once the payload has been
+redirected.
+
+If a reference payload names an entry that has no block, then the apply engine shall leave that
+name unchanged.
+
+### Reference Validator
+
+The reference validator shall report a reference whose payload names the entry holding it as
+`self`.
+
+The reference validator shall report a reference whose payload names an entry declared later in
+`blocks` as `forward`.
+
+The reference validator shall not report a reference whose payload names an id the document
+does not define.
+
+## What Was Deleted
+
+- `TemplateLocalRef` — the `{ block, output }` notation, and the reservation of that shape
+  inside opaque params.
+- The `columns` dictionary, its interner, and the `as` surface-form marker at each reference
+  site. Interning deduplicated identifiers and gave block ids a single home, but it required
+  the engine to take identifiers apart.
+- The params codec: `TemplateForm`, `toTemplateForm`, `fromTemplateForm`.
+- `remapColumnIdBlockIds` and its walk (`remapIdString`, `remapKey`, `remapDiscoveredKey`),
+  added earlier on this branch and left with no callers.
+- Both guards over an entry's params — the export-side check for block ids outside a wrapper
+  and for wrapped ids naming a block the project does not contain, and the import-side
+  `foreignBlockIds`. All three were the last places the engine modelled references.
+
+Kept: `peelJsonLayers`, which the project's own reference detector
+(`inferAllReferencedBlocks`) is built on, now with tests of its own in
+`lib/model/common/src/drivers/pframe/spec/ids.test.ts`.
+
+## What The Engine Can No Longer Report
+
+Each of these is pinned by a test that states the boundary rather than the behaviour, so it
+reads as a decision and not as a bug waiting to be fixed.
+
+1. **A reference a block did not wrap.** Written out as data; the applied block is wired to
+   nothing. Not the engine's business — which values carry block ids is the block's statement
+   to make, and getting it wrong is a defect in the block like any other. Since the SDK now
+   marks references automatically, reaching this requires a genuinely unrecognizable carrier.
+2. **A reference to a block the project no longer contains.** Deleting a block does not rewrite
+   what pointed at it, so a live project holds these routinely. Surfaces on apply.
+3. **A dangling reference** — an id naming no entry in the file. Detection asks which of the
+   ids the document defines appear in a payload, so an id naming none is indistinguishable from
+   the rest of the payload's text.
+
+All three need the same thing: knowing which values are identifiers.
+
+## Still Open
+
+- **Canonical key order when an identifier is a map key.** `ColumnDiscoveredKey.queriesQualifications`
+  is `Record<PObjectId, …>`, and a redirect there changes what the sorted order should be — the
+  result is valid JSON that is no longer canonical, so it is a different string from the
+  identifier the same column would have in a fresh project. Only string equality suffers.
+  Pinned by a test; fixing it means either re-canonicalizing a payload after the redirect
+  (JSON knowledge, not reference knowledge, but it would have to guess which nested strings are
+  JSON) or normalizing the shape on the way out, which contradicts storing values as is.
+- **Blocks built before this change.** The params projection used to run inside the block's
+  bundle in its old form, and that bundle is frozen in `model.json` (`code.content`, stamped
+  with `sdkVersion`). Such a block still emits the old shape, and the engine — modelling
+  nothing — writes it out. Rebuilding every block is required either way on this branch, since
+  `kind` became mandatory; the open question is whether `BLOCK_STORAGE_FACADE_VERSION` should be
+  raised so an un-rebuilt block is refused instead of producing a template that does not work.
diff --git a/docs/block-kinds-templates/README.md b/docs/block-kinds-templates/README.md
new file mode 100644
index 0000000000..997072723e
--- /dev/null
+++ b/docs/block-kinds-templates/README.md
@@ -0,0 +1,64 @@
+# Block Kinds & Templates — Implementation Breakdown
+
+Working notes for turning the spec into shippable pieces. **This is a decomposition
+document, not a spec.** The authoritative design lives in the
+`docs/text/work/projects/block-kind-and-templates/` mispec corpus (workspace repo),
+currently as the **PR #198 rework** ("kind publishes with the facade", branch
+`feat/kind-publish-with-facade`, not yet on main). When this document and the spec
+disagree, the spec wins — flag the drift here. Citations use **atom IDs** (`A-00NN`)
+since rendered line numbers shift.
+
+Status: draft. The three implementation documents below are **preambles only** — scope
+and open questions, not detailed plans.
+
+## What we are building (one paragraph)
+
+A **block kind** is a separately-versioned npm package that declares a typed
+`BlockParams` contract; many block versions implement one kind version. On top of kinds
+sits a **template engine**: a project can be *exported* to a YAML template, and a
+hand-authored or exported template can be *imported* (applied) into a fresh project. All
+of it lives in the TypeScript layer — SDK, Middle Layer, Desktop. The backend
+(`core/pl`) has no part.
+
+## Why three tracks
+
+The work splits along the natural seams in the spec, ordered by dependency:
+
+| # | Track | Depends on | Document |
+|---|-------|-----------|----------|
+| 1 | **Kind + lifecycle** | — (foundational) | [`01-kind-and-lifecycle.md`](./01-kind-and-lifecycle.md) |
+| 2 | **Export** (project → template YAML) | kind reference in `model.json` | [`02-export.md`](./02-export.md) |
+| 3 | **Import** (template YAML → new project) | kind resolution + template engine | [`03-import.md`](./03-import.md) |
+
+- **Kind + lifecycle is the foundation.** Nothing above it works until a kind can be
+  declared, wired into a block's model, published, and resolved from a registry.
+- **Export and import are inverses** (`decisions.md:139`) and share the `template-v1`
+  YAML schema, so they must agree on that schema even though they ship as separate
+  streams. Export is the simpler half (serialize what already exists); import carries
+  kind resolution and the template-engine lambda.
+- Import depends on kind resolution being real; export only needs the kind reference
+  recorded in `model.json`, so it can start earlier / against stubs.
+
+## Testing before the first release — resolved
+
+Kind publication is a release-time step (kind-first inside the block's publish flow).
+That once read as the central risk: how do we exercise the full lifecycle — publish,
+version-match check, source-hash guard, resolution — before any kind has been released?
+
+**Resolved.** The whole loop runs locally, headless, with no CI and no AWS, against a
+plain temp directory: `block-tools`'s registry storage is driver-based (`file:` →
+`FSStorage`, `s3:` → `S3Storage`) and the reader supports `file:`/`http(s):`. See
+`01-kind-and-lifecycle.md` → **Testing strategy** for the step-by-step loop, layers
+L1–L4, and desktop wiring.
+
+## Schema shared across tracks
+
+`template-v1` YAML is the contract between export and import. It must be pinned down
+once and referenced by both. Open: where the canonical schema definition lives, and
+whether it is a shared package both tracks import.
+
+## Out of scope (iteration 1)
+
+Per `decisions.md:11`: settings modal and guided wizard UI; template-delivered custom UI
+pages and lambdas; applying a template into an existing project; in-app template
+browsing / publishing / drag-and-drop.
diff --git a/etc/blocks/blob-url-custom-protocol/.structure b/etc/blocks/blob-url-custom-protocol/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/blob-url-custom-protocol/.structure
+++ b/etc/blocks/blob-url-custom-protocol/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/blob-url-custom-protocol/block/package.json b/etc/blocks/blob-url-custom-protocol/block/package.json
index e9321db2f3..d235ea42e3 100644
--- a/etc/blocks/blob-url-custom-protocol/block/package.json
+++ b/etc/blocks/blob-url-custom-protocol/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-blob-url-custom-protocol.kind": "workspace:*",
     "@milaboratories/milaboratories.test-blob-url-custom-protocol.model": "workspace:*",
     "@milaboratories/milaboratories.test-blob-url-custom-protocol.ui": "workspace:*",
     "@milaboratories/milaboratories.test-blob-url-custom-protocol.workflow": "workspace:*",
diff --git a/etc/blocks/enter-numbers-v3/model/.oxfmtrc.json b/etc/blocks/blob-url-custom-protocol/kind/.oxfmtrc.json
similarity index 100%
rename from etc/blocks/enter-numbers-v3/model/.oxfmtrc.json
rename to etc/blocks/blob-url-custom-protocol/kind/.oxfmtrc.json
diff --git a/etc/blocks/enter-numbers-v3/ui/.oxlintrc.json b/etc/blocks/blob-url-custom-protocol/kind/.oxlintrc.json
similarity index 71%
rename from etc/blocks/enter-numbers-v3/ui/.oxlintrc.json
rename to etc/blocks/blob-url-custom-protocol/kind/.oxlintrc.json
index 5cb5522788..b1a139038f 100644
--- a/etc/blocks/enter-numbers-v3/ui/.oxlintrc.json
+++ b/etc/blocks/blob-url-custom-protocol/kind/.oxlintrc.json
@@ -1,3 +1,3 @@
 {
-  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-block-ui.json"]
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
 }
diff --git a/etc/blocks/blob-url-custom-protocol/kind/package.json b/etc/blocks/blob-url-custom-protocol/kind/package.json
new file mode 100644
index 0000000000..9cfee5fed0
--- /dev/null
+++ b/etc/blocks/blob-url-custom-protocol/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-blob-url-custom-protocol.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the blob-url-custom-protocol block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/blob-url-custom-protocol/kind/src/index.ts b/etc/blocks/blob-url-custom-protocol/kind/src/index.ts
new file mode 100644
index 0000000000..5d09a01796
--- /dev/null
+++ b/etc/blocks/blob-url-custom-protocol/kind/src/index.ts
@@ -0,0 +1,29 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the blob-url-custom-protocol block — deliberately
+ * empty. The block's whole `BlockData` is two `ImportFileHandle`s, and those are
+ * desktop-signed, machine- and session-local references produced by a real OS
+ * file-dialog gesture (see the upload flow). Nothing a creator or a project
+ * template could serialize ahead of time, so this block takes no init params and
+ * `init` always returns the unset defaults.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/blob-url-custom-protocol/kind/tsconfig.json b/etc/blocks/blob-url-custom-protocol/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/blob-url-custom-protocol/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/blob-url-custom-protocol/model/package.json b/etc/blocks/blob-url-custom-protocol/model/package.json
index 7c71fb507b..4e52ad12de 100644
--- a/etc/blocks/blob-url-custom-protocol/model/package.json
+++ b/etc/blocks/blob-url-custom-protocol/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-blob-url-custom-protocol.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/blob-url-custom-protocol/model/src/index.ts b/etc/blocks/blob-url-custom-protocol/model/src/index.ts
index a7aa2c03b4..00767519b5 100644
--- a/etc/blocks/blob-url-custom-protocol/model/src/index.ts
+++ b/etc/blocks/blob-url-custom-protocol/model/src/index.ts
@@ -1,10 +1,6 @@
 import type { ImportFileHandle, InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import {
-  BlockModel,
-  extractArchiveAndGetURL,
-  getResourceField,
-  MainOutputs,
-} from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-blob-url-custom-protocol.kind";
 import { z } from "zod";
 
 export const ImportFileHandleSchema = z
@@ -14,26 +10,51 @@ export const ImportFileHandleSchema = z
     ((_a) => true) as (arg: string | undefined) => arg is ImportFileHandle | undefined,
   );
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   inputTgzHandle: ImportFileHandleSchema,
   inputZipHandle: ImportFileHandleSchema,
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+/** What the workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  inputTgzHandle: ImportFileHandle | undefined;
+  inputZipHandle: ImportFileHandle | undefined;
+};
 
-  .withArgs({
-    inputTgzHandle: undefined,
-    inputZipHandle: undefined,
-  })
+// This block takes no init params (its kind declares `Record<string, never>`):
+// both fields are desktop-signed `ImportFileHandle`s, which no template can
+// pre-wire. So `init` ignores params and returns the unset defaults.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(() => ({ inputTgzHandle: undefined, inputZipHandle: undefined }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
+
+  .args<BlockArgs>((data) => ({
+    inputTgzHandle: data.inputTgzHandle,
+    inputZipHandle: data.inputZipHandle,
+  }))
+
+  // Nothing to project: the kind takes no params, because both handles are signed,
+  // session-local references from an OS file-dialog gesture and would not resolve in
+  // the project a template is applied into.
+  .templateParams(() => ({}))
 
   .output("handleTgz", (ctx) => ctx.outputs?.resolve("handleTgz")?.getImportProgress())
   .output("handleZip", (ctx) => ctx.outputs?.resolve("handleZip")?.getImportProgress())
 
-  .output("tgz_content", extractArchiveAndGetURL(getResourceField(MainOutputs, "siteTgz"), "tgz"))
+  // Both archive outputs use the accessor form. V1 drove `tgz_content` through
+  // the config-based `extractArchiveAndGetURL(getResourceField(MainOutputs, …))`
+  // helpers so the block covered both surfaces; those helpers return a
+  // `TypedConfig`, which only V1's `output()` accepts — `BlockModelV3.output()`
+  // takes render lambdas only. The config surface is therefore gone here, and
+  // the two outputs differ solely in the archive format they extract.
+  .output("tgz_content", (ctx) => ctx.outputs?.resolve("siteTgz")?.extractArchiveAndGetURL("tgz"))
 
   .output("zip_content", (ctx) => ctx.outputs?.resolve("siteZip")?.extractArchiveAndGetURL("zip"))
+
   .sections((_ctx) => {
     return [{ type: "link", href: "/", label: "Main" }];
   })
diff --git a/etc/blocks/blob-url-custom-protocol/ui/src/MainPage.vue b/etc/blocks/blob-url-custom-protocol/ui/src/MainPage.vue
index 0111dd1961..ed90b15af1 100644
--- a/etc/blocks/blob-url-custom-protocol/ui/src/MainPage.vue
+++ b/etc/blocks/blob-url-custom-protocol/ui/src/MainPage.vue
@@ -7,8 +7,8 @@ const app = useApp();
 
 <template>
   <PlBlockPage style="max-width: 100%">
-    <PlFileInput v-model="app.model.args.inputTgzHandle" label="Select tgz file to import" />
-    <PlFileInput v-model="app.model.args.inputZipHandle" label="Select zip file to import" />
+    <PlFileInput v-model="app.model.data.inputTgzHandle" label="Select tgz file to import" />
+    <PlFileInput v-model="app.model.data.inputZipHandle" label="Select zip file to import" />
 
     <PlAlert type="success">
       Blob tgz content:
@@ -25,8 +25,8 @@ const app = useApp();
     </PlAlert>
 
     <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>Data (app.model.data)</legend>
+      {{ app.model.data }}
     </fieldset>
     <h3>app.model</h3>
     <code>{{ app.model }}</code>
diff --git a/etc/blocks/blob-url-custom-protocol/ui/src/app.ts b/etc/blocks/blob-url-custom-protocol/ui/src/app.ts
index 4070f68f64..b59d43c4cf 100644
--- a/etc/blocks/blob-url-custom-protocol/ui/src/app.ts
+++ b/etc/blocks/blob-url-custom-protocol/ui/src/app.ts
@@ -1,20 +1,20 @@
 import type { Equal, Expect } from "@milaboratories/helpers";
 import { platforma } from "@milaboratories/milaboratories.test-blob-url-custom-protocol.model";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import { computed, reactive } from "vue";
 import MainPage from "./MainPage.vue";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
   });
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -25,7 +25,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 
 type __cases = [
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
 ];
 
 export const useApp = sdkPlugin.useApp;
diff --git a/etc/blocks/download-file/.structure b/etc/blocks/download-file/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/download-file/.structure
+++ b/etc/blocks/download-file/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/download-file/block/package.json b/etc/blocks/download-file/block/package.json
index fed4306469..ac2f3ae568 100644
--- a/etc/blocks/download-file/block/package.json
+++ b/etc/blocks/download-file/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-download-file.kind": "workspace:*",
     "@milaboratories/milaboratories.test-download-file.model": "workspace:*",
     "@milaboratories/milaboratories.test-download-file.ui": "workspace:*",
     "@milaboratories/milaboratories.test-download-file.workflow": "workspace:*",
diff --git a/etc/blocks/sum-numbers-v3/model/.oxfmtrc.json b/etc/blocks/download-file/kind/.oxfmtrc.json
similarity index 100%
rename from etc/blocks/sum-numbers-v3/model/.oxfmtrc.json
rename to etc/blocks/download-file/kind/.oxfmtrc.json
diff --git a/etc/blocks/sum-numbers-v3/ui/.oxlintrc.json b/etc/blocks/download-file/kind/.oxlintrc.json
similarity index 71%
rename from etc/blocks/sum-numbers-v3/ui/.oxlintrc.json
rename to etc/blocks/download-file/kind/.oxlintrc.json
index 5cb5522788..b1a139038f 100644
--- a/etc/blocks/sum-numbers-v3/ui/.oxlintrc.json
+++ b/etc/blocks/download-file/kind/.oxlintrc.json
@@ -1,3 +1,3 @@
 {
-  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-block-ui.json"]
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
 }
diff --git a/etc/blocks/download-file/kind/package.json b/etc/blocks/download-file/kind/package.json
new file mode 100644
index 0000000000..51bb69d8c7
--- /dev/null
+++ b/etc/blocks/download-file/kind/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "@milaboratories/milaboratories.test-download-file.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the download-file block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@milaboratories/pl-model-common": "workspace:*",
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/download-file/kind/src/index.ts b/etc/blocks/download-file/kind/src/index.ts
new file mode 100644
index 0000000000..2cc86fd33b
--- /dev/null
+++ b/etc/blocks/download-file/kind/src/index.ts
@@ -0,0 +1,42 @@
+import type { ImportFileHandle } from "@milaboratories/pl-model-common";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the download-file block — what a creator or a
+ * project template supplies to seed a new instance. The block's `BlockData` is a
+ * single field, `inputHandle`, and it is author-supplied at creation: a template
+ * can pre-wire the file this block imports and re-exports. Optional, because a
+ * block may also be created without a template, in which case `init` falls back
+ * to an unset input.
+ */
+export type BlockParams = { inputHandle?: ImportFileHandle };
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `ImportFileHandle` is a template-literal union of two URI forms, so the check is the
+ * prefix test rather than a plain string: a handle that carries neither scheme is not a
+ * handle, and letting it through would surface much later as a failed import naming
+ * nothing about the file. What cannot be checked here is whether the handle still
+ * resolves — it is machine- and session-local, so only the importing side knows.
+ *
+ * `.strict()` rejects and names any key this contract does not declare, instead of
+ * dropping it and applying a block that looks configured and is not.
+ */
+const ImportFileHandleParam = z.custom<ImportFileHandle>(
+  (value) =>
+    typeof value === "string" &&
+    (value.startsWith("upload://upload/") || value.startsWith("index://index/")),
+  { message: "must be an import file handle (upload://upload/… or index://index/…)" },
+);
+
+const Params = z.object({ inputHandle: ImportFileHandleParam.optional() }).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/download-file/kind/tsconfig.json b/etc/blocks/download-file/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/download-file/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/download-file/model/package.json b/etc/blocks/download-file/model/package.json
index fb3bfcd571..fe5c210fde 100644
--- a/etc/blocks/download-file/model/package.json
+++ b/etc/blocks/download-file/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-download-file.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/download-file/model/src/index.ts b/etc/blocks/download-file/model/src/index.ts
index fc0fe01d52..9b5b962d99 100644
--- a/etc/blocks/download-file/model/src/index.ts
+++ b/etc/blocks/download-file/model/src/index.ts
@@ -1,16 +1,6 @@
 import type { ImportFileHandle, InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import {
-  BlockModel,
-  getBlobContent,
-  getBlobContentAsJson,
-  getBlobContentAsString,
-  getDownloadedBlobContent,
-  getImportProgress,
-  getOnDemandBlobContent,
-  getResourceField,
-  getResourceValueAsJson,
-  MainOutputs,
-} from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-download-file.kind";
 import { z } from "zod";
 
 export const ImportFileHandleSchema = z
@@ -20,25 +10,46 @@ export const ImportFileHandleSchema = z
     ((_a) => true) as (arg: string | undefined) => arg is ImportFileHandle | undefined,
   );
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   inputHandle: ImportFileHandleSchema,
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+/** What the workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  inputHandle: ImportFileHandle | undefined;
+};
 
-  .withArgs({
-    inputHandle: undefined,
-  })
+// `params` is optional — a block may be created without a template supplying
+// them — so the kind-declared field keeps a fallback default.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(({ params }) => ({ inputHandle: params?.inputHandle }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
-  .output("blob", getResourceValueAsJson()(getResourceField(MainOutputs, "blob")))
+  .args<BlockArgs>((data) => ({ inputHandle: data.inputHandle }))
 
-  .output("handle", getImportProgress(getResourceField(MainOutputs, "handle")))
+  // The kind declares `inputHandle` as an init param, so the projection emits it —
+  // narrowing the contract here is not this block's call to make. Whether the handle
+  // still resolves is the importing side's problem, and only it can tell.
+  .templateParams((data) => ({ inputHandle: data.inputHandle }))
 
-  .output("content", getBlobContent(getResourceField(MainOutputs, "downloadable")))
+  .output("blob", (ctx) => ctx.outputs?.resolve("blob")?.getDataAsJsonOrUndefined<unknown>())
 
-  .output("contentAsString", getBlobContentAsString(getResourceField(MainOutputs, "downloadable")))
+  .output("handle", (ctx) => ctx.outputs?.resolve("handle")?.getImportProgress())
+
+  // The V3 render context exposes no raw-bytes blob accessor (only base64 and
+  // string), so the former `content` output — V1's `getBlobContent` — becomes
+  // base64 here, and is named for what it actually returns.
+  .output("contentAsBase64", (ctx) =>
+    ctx.outputs?.resolve("downloadable")?.getFileContentAsBase64(),
+  )
+
+  .output("contentAsString", (ctx) =>
+    ctx.outputs?.resolve("downloadable")?.getFileContentAsString(),
+  )
 
   .output("contentAsString1", (ctx) =>
     ctx.outputs
@@ -47,9 +58,8 @@ export const platforma = BlockModel.create("Heavy")
       .mapDefined((v) => v + v),
   )
 
-  .output(
-    "contentAsStringRange",
-    getBlobContentAsString(getResourceField(MainOutputs, "downloadable"), { from: 1, to: 2 }),
+  .output("contentAsStringRange", (ctx) =>
+    ctx.outputs?.resolve("downloadable")?.getFileContentAsString({ from: 1, to: 2 }),
   )
 
   .output("contentAsStringRange1", (ctx) =>
@@ -59,16 +69,14 @@ export const platforma = BlockModel.create("Heavy")
       .mapDefined((v) => v + v),
   )
 
-  .output("contentAsJson", getBlobContentAsJson()(getResourceField(MainOutputs, "downloadable")))
-
-  .output(
-    "downloadedBlobContent",
-    getDownloadedBlobContent(getResourceField(MainOutputs, "downloadable")),
+  .output("contentAsJson", (ctx) =>
+    ctx.outputs?.resolve("downloadable")?.getFileContentAsJson<unknown>(),
   )
 
-  .output(
-    "onDemandBlobContent",
-    getOnDemandBlobContent(getResourceField(MainOutputs, "downloadable")),
+  .output("downloadedBlobContent", (ctx) => ctx.outputs?.resolve("downloadable")?.getFileHandle())
+
+  .output("onDemandBlobContent", (ctx) =>
+    ctx.outputs?.resolve("downloadable")?.getRemoteFileHandle(),
   )
 
   .output("onDemandBlobContent1", (ctx) =>
diff --git a/etc/blocks/download-file/ui/src/MainPage.vue b/etc/blocks/download-file/ui/src/MainPage.vue
index f9b658e96c..2d382610d2 100644
--- a/etc/blocks/download-file/ui/src/MainPage.vue
+++ b/etc/blocks/download-file/ui/src/MainPage.vue
@@ -104,14 +104,14 @@ const onDemandRangeContent1 = computedAsync(async () => {
 <template>
   <PlBlockPage style="max-width: 100%">
     <PlFileInput
-      v-model="app.model.args.inputHandle"
+      v-model="app.model.data.inputHandle"
       label="Select file to import"
       :progress="progress"
     />
 
     <PlAlert type="success">
-      File content:
-      {{ app.model.outputs.content }}
+      File content as base64:
+      {{ app.model.outputs.contentAsBase64 }}
     </PlAlert>
 
     <PlAlert type="success">
@@ -163,12 +163,12 @@ const onDemandRangeContent1 = computedAsync(async () => {
       {{ app.error }}
     </PlAlert>
     <fieldset>
-      <legend>Args (app.snapshot.args)</legend>
-      {{ app.snapshot.args }}
+      <legend>Block storage (app.snapshot.blockStorage)</legend>
+      {{ app.snapshot.blockStorage }}
     </fieldset>
     <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>Data (app.model.data)</legend>
+      {{ app.model.data }}
     </fieldset>
     <h3>app.model</h3>
     <code>{{ app.model }}</code>
diff --git a/etc/blocks/download-file/ui/src/app.ts b/etc/blocks/download-file/ui/src/app.ts
index 2676b3cfca..f6927adbfc 100644
--- a/etc/blocks/download-file/ui/src/app.ts
+++ b/etc/blocks/download-file/ui/src/app.ts
@@ -1,11 +1,11 @@
 import { platforma } from "@milaboratories/milaboratories.test-download-file.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
@@ -15,12 +15,12 @@ export const sdkPlugin = defineApp(platforma, (base) => {
     data.counter++;
   }
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
     incrementCounter,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -32,7 +32,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/etc/blocks/enter-numbers-v3/.structure b/etc/blocks/enter-numbers-v3/.structure
deleted file mode 100644
index 491d734467..0000000000
--- a/etc/blocks/enter-numbers-v3/.structure
+++ /dev/null
@@ -1 +0,0 @@
-{"version":1}
\ No newline at end of file
diff --git a/etc/blocks/enter-numbers-v3/block/CHANGELOG.md b/etc/blocks/enter-numbers-v3/block/CHANGELOG.md
deleted file mode 100644
index 310a8b24a3..0000000000
--- a/etc/blocks/enter-numbers-v3/block/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-enter-numbers-v3
diff --git a/etc/blocks/enter-numbers-v3/block/logos/block-logo.png b/etc/blocks/enter-numbers-v3/block/logos/block-logo.png
deleted file mode 100644
index e03221e11f..0000000000
Binary files a/etc/blocks/enter-numbers-v3/block/logos/block-logo.png and /dev/null differ
diff --git a/etc/blocks/enter-numbers-v3/block/logos/organization-logo.png b/etc/blocks/enter-numbers-v3/block/logos/organization-logo.png
deleted file mode 100644
index e03221e11f..0000000000
Binary files a/etc/blocks/enter-numbers-v3/block/logos/organization-logo.png and /dev/null differ
diff --git a/etc/blocks/enter-numbers-v3/block/package.json b/etc/blocks/enter-numbers-v3/block/package.json
deleted file mode 100644
index 072ff751d3..0000000000
--- a/etc/blocks/enter-numbers-v3/block/package.json
+++ /dev/null
@@ -1,55 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-enter-numbers-v3",
-  "version": "1.0.0",
-  "private": true,
-  "files": [
-    "dist",
-    "block-pack"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "sources": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "ts-builder build --target block-facade && block-tools pack",
-    "prepublishOnly": "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",
-    "do-pack": "shx rm -f package.tgz && pnpm pack && shx mv *.tgz package.tgz",
-    "check": "ts-builder type-check --target block-facade"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@milaboratories/milaboratories.test-enter-numbers-v3.model": "workspace:*",
-    "@milaboratories/milaboratories.test-enter-numbers-v3.ui": "workspace:*",
-    "@milaboratories/milaboratories.test-enter-numbers-v3.workflow": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "@platforma-sdk/block-tools": "workspace:*",
-    "@platforma-sdk/model": "workspace:*",
-    "shx": "catalog:",
-    "typescript": "catalog:"
-  },
-  "block": {
-    "components": {
-      "workflow": "@milaboratories/milaboratories.test-enter-numbers-v3.workflow/dist/tengo/tpl/main.plj.gz",
-      "model": "@milaboratories/milaboratories.test-enter-numbers-v3.model/dist/model.json",
-      "ui": "@milaboratories/milaboratories.test-enter-numbers-v3.ui/dist"
-    },
-    "meta": {
-      "title": "Enter Numbers (new api)",
-      "description": "Enter Numbers",
-      "logo": "file:logos/block-logo.png",
-      "organization": {
-        "name": "MiLaboratories Inc",
-        "url": "https://milaboratories.com/",
-        "logo": "file:logos/organization-logo.png"
-      }
-    }
-  }
-}
diff --git a/etc/blocks/enter-numbers-v3/block/src/AGENTS.ts b/etc/blocks/enter-numbers-v3/block/src/AGENTS.ts
deleted file mode 100644
index 5cf2589c3b..0000000000
--- a/etc/blocks/enter-numbers-v3/block/src/AGENTS.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// This file is managed by `block-tools structure`. Do not edit by hand.
-// Narrow MCP / AI surface.
-
-export type { BlockContract, BlockOutputs, BlockData } from "./index";
-export * from "./agents-extra";
diff --git a/etc/blocks/enter-numbers-v3/block/src/agents-extra.ts b/etc/blocks/enter-numbers-v3/block/src/agents-extra.ts
deleted file mode 100644
index 228811f462..0000000000
--- a/etc/blocks/enter-numbers-v3/block/src/agents-extra.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// Author-owned. `block-tools structure` does not modify this file.
-// MCP / AI extension surface. Add types and functions the agent
-// surface should expose.
-//
-// In the future this file will host JS functions the MCP runtime
-// can execute. The `.d.ts` declarations stay visible to the agent;
-// the JS bodies execute in the MCP code-execution context (the
-// agent sees the types but not the implementation).
diff --git a/etc/blocks/enter-numbers-v3/block/src/block-extra.ts b/etc/blocks/enter-numbers-v3/block/src/block-extra.ts
deleted file mode 100644
index fc00cdd4b3..0000000000
--- a/etc/blocks/enter-numbers-v3/block/src/block-extra.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// Author-owned. `block-tools structure` does not modify this file.
-// Add block-specific helper types or values the consumer surface
-// should expose. Anything you `export` here flows out via the
-// main entry (./index re-exports this file).
-//
-// Do NOT redefine: BlockContract, BlockOutputs, BlockData,
-// BlockPointer, platforma, or the block-named <PascalName>Block*
-// aliases — those names come from ./index and `export *` from this
-// file would shadow them.
diff --git a/etc/blocks/enter-numbers-v3/block/src/index.ts b/etc/blocks/enter-numbers-v3/block/src/index.ts
deleted file mode 100644
index f195d1ae7d..0000000000
--- a/etc/blocks/enter-numbers-v3/block/src/index.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-// This file is managed by `block-tools structure`. Do not edit by hand.
-// Author content lives in ./block-extra.ts.
-
-import { platforma } from "@milaboratories/milaboratories.test-enter-numbers-v3.model";
-import {
-  InferOutputsType,
-  InferDataType,
-  InferHrefType,
-} from "@platforma-sdk/model";
-
-export { platforma };
-
-export type BlockContract = {
-  outputs: InferOutputsType<typeof platforma>;
-  data:    InferDataType<typeof platforma>;
-  href:    InferHrefType<typeof platforma>;
-};
-
-export type BlockOutputs = BlockContract["outputs"];
-export type BlockData    = BlockContract["data"];
-
-// import.meta.url is a file: URL (always forward-slash, even on Windows:
-// file:///C:/…). We expose URLs, NOT paths — the facade stays dependency-free
-// and loadable in minimal engines (e.g. QuickJS), and each consumer converts
-// at its own edge with the right tool (fileURLToPath in Node), where Windows
-// drive letters / %-encoding / UNC are handled correctly. The bundled entry
-// sits one dir under the package root (dist/index.js, or src/index.ts in dev),
-// so the root is two URL segments up. The structurer owns this layout —
-// consumers read these URLs, they never reconstruct <root>/block-pack.
-//
-// TypeScript ships `ImportMeta.url` only in the `dom`/`webworker` libs; the
-// facade tsconfig is lib-minimal (no `dom`, no `@types/node`) by design. We
-// type the one ESM-standard member we use with a local cast rather than a
-// `declare global` — a global augmentation would leak into the published
-// `dist/index.d.ts` and clash with `@types/node`'s `ImportMeta` in full-Node
-// consumers (test packages, the Middle Layer).
-const selfUrl = (import.meta as ImportMeta & { url: string }).url;
-const dirUrl  = selfUrl.slice(0, selfUrl.lastIndexOf("/"));
-const rootUrl = dirUrl.slice(0, dirUrl.lastIndexOf("/"));
-
-export const BlockPointer = {
-  type: "from-pack-v2" as const,
-  packUrl: rootUrl + "/block-pack",
-  rootUrl,
-} as const;
-
-// Block-named aliases for readable cross-block imports in tests and
-// consumer code. Same types / same runtime value as the universal
-// names above; the aliases avoid `as`-renames at the import site.
-export type TestEnterNumbersV3BlockContract = BlockContract;
-export type TestEnterNumbersV3BlockOutputs  = BlockOutputs;
-export type TestEnterNumbersV3BlockData     = BlockData;
-export const TestEnterNumbersV3BlockPointer = BlockPointer;
-
-export * from "./block-extra";
diff --git a/etc/blocks/enter-numbers-v3/block/tsconfig.json b/etc/blocks/enter-numbers-v3/block/tsconfig.json
deleted file mode 100644
index 8b5ec69745..0000000000
--- a/etc/blocks/enter-numbers-v3/block/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/facade",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/enter-numbers-v3/model/CHANGELOG.md b/etc/blocks/enter-numbers-v3/model/CHANGELOG.md
deleted file mode 100644
index c2d1f728fc..0000000000
--- a/etc/blocks/enter-numbers-v3/model/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-enter-numbers-v3.model
diff --git a/etc/blocks/enter-numbers-v3/model/package.json b/etc/blocks/enter-numbers-v3/model/package.json
deleted file mode 100644
index 076e56749a..0000000000
--- a/etc/blocks/enter-numbers-v3/model/package.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-enter-numbers-v3.model",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Block model",
-  "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "sources": "./src/index.ts",
-      "import": "./dist/index.js"
-    },
-    "./dist/*": "./dist/*"
-  },
-  "scripts": {
-    "build": "ts-builder build --target block-model && block-tools build-model",
-    "check": "ts-builder check --target block-model",
-    "formatter:check": "ts-builder formatter --check",
-    "linter:check": "ts-builder linter --check",
-    "types:check": "ts-builder type-check --target block-model",
-    "fmt": "ts-builder format",
-    "watch": "ts-builder build --target block-model --watch"
-  },
-  "dependencies": {
-    "@platforma-sdk/model": "workspace:*",
-    "zod": "catalog:"
-  },
-  "devDependencies": {
-    "@milaboratories/build-configs": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "@platforma-sdk/block-tools": "workspace:*",
-    "vitest": "catalog:"
-  },
-  "peerDependencies": {
-    "@types/node": "*",
-    "typescript": "*"
-  }
-}
diff --git a/etc/blocks/enter-numbers-v3/model/src/index.ts b/etc/blocks/enter-numbers-v3/model/src/index.ts
deleted file mode 100644
index 5e74374a33..0000000000
--- a/etc/blocks/enter-numbers-v3/model/src/index.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import type { InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
-import { z } from "zod";
-
-// Data version 1: just numbers
-type BlockDataV1 = {
-  numbers: number[];
-};
-
-// Data version 2: added labels
-type BlockDataV2 = {
-  numbers: number[];
-  labels: string[];
-};
-
-// Data version 3 (current): added description
-export const $BlockData = z.object({
-  numbers: z.array(z.coerce.number()),
-  labels: z.array(z.string()),
-  description: z.string(),
-});
-
-export type BlockData = z.infer<typeof $BlockData>;
-
-// Define data model with migrations from v1 to current
-const dataModel = new DataModelBuilder()
-  .from<BlockDataV1>("v1")
-  // Migration v1 → v2: sort numbers and add labels
-  // Throws if numbers contain 666 (for testing migration failure recovery)
-  .migrate<BlockDataV2>("v2", (data) => {
-    if (data.numbers.includes(666)) {
-      throw new Error("Migration failed: number 666 is forbidden!");
-    }
-    return { numbers: data.numbers.toSorted(), labels: ["migrated-from-v1"] };
-  })
-  // Migration v2 → v3: add description
-  .migrate<BlockData>("v3", (data) => {
-    return { ...data, description: `Migrated: ${data.labels.join(", ")}` };
-  })
-  .init(() => ({ numbers: [], labels: [], description: "" }));
-
-export const platforma = BlockModelV3.create(dataModel)
-
-  .args((data) => {
-    if (data.numbers.length === 0) {
-      throw new Error("Numbers are required!");
-    }
-    // Test sentinel: args() returns undefined (without throwing) to exercise the
-    // "derivation succeeds but value is undefined" contract used by real blocks
-    // (e.g. `if (!Valid.safeParse(data).success) return undefined`).
-    if (data.numbers.length === 1 && data.numbers[0] === 777) {
-      return undefined;
-    }
-    return { numbers: data.numbers.toSorted() };
-  })
-
-  .prerunArgs((data) => {
-    return { evenNumbers: data.numbers.toSorted().filter((n) => n % 2 === 0) };
-  })
-
-  .output("numbers", (ctx) => ctx.outputs?.resolve("numbers")?.getDataAsJson<number[]>())
-
-  .output("activeArgs", (ctx) => ctx.activeArgs)
-
-  .output(
-    "numbersCount",
-    (ctx) => ctx.prerun?.resolve("numbersCount")?.getDataAsJson<number>() ?? 0,
-  )
-
-  .output("prerunArgsJson", (ctx) =>
-    ctx.prerun?.resolve("prerunArgsJson")?.getDataAsJson<Record<string, unknown>>(),
-  )
-
-  .output("errorIfNumberIs999", (ctx) => {
-    const numbers = ctx.args?.numbers;
-
-    if (numbers?.length === 1 && numbers[0] === 999) {
-      return ctx.prerun?.resolve("numbers")?.getFileContentAsJson<number[]>();
-    }
-
-    return numbers ?? [];
-  })
-
-  .output("ctx", (ctx) => ctx)
-
-  .output("ctx.activeArgs", (ctx) => ctx.activeArgs)
-
-  .output("ctx.args", (ctx) => ctx.args)
-
-  .output("ctx.data", (ctx) => ctx.data)
-
-  .sections((_ctx) => {
-    return [{ type: "link", href: "/", label: "Main" }];
-  })
-
-  .done();
-
-export type BlockOutputs = InferOutputsType<typeof platforma>;
-export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/enter-numbers-v3/model/tsconfig.json b/etc/blocks/enter-numbers-v3/model/tsconfig.json
deleted file mode 100644
index ccde31405f..0000000000
--- a/etc/blocks/enter-numbers-v3/model/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/model",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/enter-numbers-v3/ui/.oxfmtrc.json b/etc/blocks/enter-numbers-v3/ui/.oxfmtrc.json
deleted file mode 100644
index ba9bb8f00d..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/.oxfmtrc.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "ignorePatterns": ["dist", "CHANGELOG.md"]
-}
diff --git a/etc/blocks/enter-numbers-v3/ui/CHANGELOG.md b/etc/blocks/enter-numbers-v3/ui/CHANGELOG.md
deleted file mode 100644
index 88af1cb255..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-enter-numbers-v3.ui
diff --git a/etc/blocks/enter-numbers-v3/ui/index.html b/etc/blocks/enter-numbers-v3/ui/index.html
deleted file mode 100644
index c604936261..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta http-equiv="Content-Security-Policy" content="script-src 'self' blob:" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>
diff --git a/etc/blocks/enter-numbers-v3/ui/package.json b/etc/blocks/enter-numbers-v3/ui/package.json
deleted file mode 100644
index 1448102021..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/package.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-enter-numbers-v3.ui",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "ts-builder serve --target block-ui",
-    "watch": "ts-builder build --target block-ui --watch",
-    "check": "ts-builder check --target block-ui",
-    "formatter:check": "ts-builder formatter --check",
-    "linter:check": "ts-builder linter --check",
-    "types:check": "ts-builder type-check --target block-ui",
-    "build": "ts-builder build --target block-ui",
-    "fmt": "ts-builder format"
-  },
-  "dependencies": {
-    "@milaboratories/milaboratories.test-enter-numbers-v3.model": "workspace:*",
-    "@platforma-sdk/ui-vue": "workspace:*",
-    "vue": "catalog:"
-  },
-  "devDependencies": {
-    "@faker-js/faker": "catalog:",
-    "@milaboratories/helpers": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "vitest": "catalog:",
-    "zod": "catalog:"
-  },
-  "peerDependencies": {
-    "@types/node": "*",
-    "typescript": "*"
-  }
-}
diff --git a/etc/blocks/enter-numbers-v3/ui/src/MainPage.vue b/etc/blocks/enter-numbers-v3/ui/src/MainPage.vue
deleted file mode 100644
index 2393653ce7..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/src/MainPage.vue
+++ /dev/null
@@ -1,85 +0,0 @@
-<script setup lang="ts">
-import {
-  PlAlert,
-  PlBlockPage,
-  PlTextField,
-  PlBtnPrimary,
-  useWatchFetch,
-} from "@platforma-sdk/ui-vue";
-import { useApp } from "./app";
-import { computed } from "vue";
-import { delay } from "@milaboratories/helpers";
-
-const app = useApp();
-
-const numbers = computed({
-  get() {
-    try {
-      return app.model.data.numbers.join(",");
-    } catch (error) {
-      return "error: " + error;
-    }
-  },
-  set(v) {
-    const numbers = v.split(",").map(Number);
-
-    app.model.data.numbers = v
-      .split(",")
-      .map((v) => v.trim())
-      .filter((v) => v !== "")
-      .map(Number);
-
-    if (numbers.some((n) => isNaN(n))) {
-      app.setError("Invalid value: contains NaNs +++");
-    }
-  },
-});
-
-const fetchTestResult = async (n: number) => {
-  await delay(1000);
-  return n;
-};
-
-const sumNumbers = (numbers: number[] | undefined) => (numbers ?? []).reduce((x, y) => x + y, 0);
-
-const resultRef = useWatchFetch(
-  () => app.model.outputs.numbers,
-  (numbers) => {
-    return fetchTestResult(sumNumbers(numbers));
-  },
-);
-
-const helperText = computed(() => {
-  return `Even numbers count: ${app.model.outputs.numbersCount}`;
-});
-</script>
-
-<template>
-  <PlBlockPage style="max-width: 100%">
-    <PlTextField
-      v-model:model-value="numbers"
-      label="Enter numbers (as comma-separated string)"
-      :helper="helperText"
-    />
-    <PlAlert v-if="app.error" type="error">
-      {{ app.error }}
-    </PlAlert>
-    <fieldset>
-      <legend>app.model</legend>
-      {{ app.model }}
-    </fieldset>
-    <fieldset>
-      <legend>Block Storage (app.snapshot.blockStorage)</legend>
-      {{ app.snapshot.blockStorage }}
-    </fieldset>
-    <h4>Result ref</h4>
-    <code>{{ resultRef }}</code>
-    <PlAlert label="app.model.outputs" type="info" white-space-pre monospace>{{
-      JSON.stringify(app.model.outputs, null, 2)
-    }}</PlAlert>
-    <PlAlert v-if="app.hasErrors" type="error">
-      {{ app.model.outputErrors }}
-    </PlAlert>
-    <PlBtnPrimary v-if="app.error" @click="app.revert">Revert changes</PlBtnPrimary>
-  </PlBlockPage>
-</template>
diff --git a/etc/blocks/enter-numbers-v3/ui/src/app.ts b/etc/blocks/enter-numbers-v3/ui/src/app.ts
deleted file mode 100644
index b3e30c4557..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/src/app.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { platforma } from "@milaboratories/milaboratories.test-enter-numbers-v3.model";
-import MainPage from "./MainPage.vue";
-import { defineAppV3, ensureError } from "@platforma-sdk/ui-vue";
-import type { Component } from "vue";
-import { computed, reactive, ref } from "vue";
-import type { Equal, Expect } from "@milaboratories/helpers";
-
-export const sdkPlugin = defineAppV3(
-  platforma,
-  () => {
-    // Additional data
-    const data = reactive({
-      counter: 0,
-    });
-
-    const error = ref<string | undefined>(undefined);
-
-    function incrementCounter() {
-      data.counter++;
-    }
-
-    const stateAsJson = computed(() => "not implemented");
-
-    return {
-      data,
-      error,
-      incrementCounter,
-      stateAsJson,
-      setError(e: unknown) {
-        error.value = ensureError(e).message;
-      },
-      revert() {
-        alert("revert: not implemented");
-      },
-      routes: {
-        "/": () => MainPage,
-      },
-    };
-  },
-  {
-    debug: true,
-  },
-);
-
-type App = ReturnType<typeof sdkPlugin.useApp>;
-
-type __cases = [
-  Expect<Equal<App["incrementCounter"], () => void>>,
-  Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["stateAsJson"], string>>,
-  Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
-];
-
-export const useApp = sdkPlugin.useApp;
diff --git a/etc/blocks/enter-numbers-v3/ui/src/main.ts b/etc/blocks/enter-numbers-v3/ui/src/main.ts
deleted file mode 100644
index cef5df0ab4..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/src/main.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createApp } from "vue";
-import { sdkPlugin } from "./app";
-import { BlockLayout } from "@platforma-sdk/ui-vue";
-
-createApp(BlockLayout).use(sdkPlugin).mount("#app");
diff --git a/etc/blocks/enter-numbers-v3/ui/tsconfig.json b/etc/blocks/enter-numbers-v3/ui/tsconfig.json
deleted file mode 100644
index bf561dd728..0000000000
--- a/etc/blocks/enter-numbers-v3/ui/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/ui",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/enter-numbers-v3/workflow/CHANGELOG.md b/etc/blocks/enter-numbers-v3/workflow/CHANGELOG.md
deleted file mode 100644
index 5b8796ae8c..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-enter-numbers-v3.workflow
diff --git a/etc/blocks/enter-numbers-v3/workflow/format.el b/etc/blocks/enter-numbers-v3/workflow/format.el
deleted file mode 100644
index dff4aa786d..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/format.el
+++ /dev/null
@@ -1,42 +0,0 @@
-;; This program formats all files inside src directory. Usage: emacs --script ./format.el
-
-(defun install-go-mode ()
-  "Installs go-mode"
-  (require 'package)
-  (add-to-list 'package-archives
-               '("melpa-stable" . "https://stable.melpa.org/packages/"))
-  (package-initialize)
-  (unless package-archive-contents
-    (package-refresh-contents))
-
-  (package-install 'go-mode t)
-  (require 'go-mode))
-
-;; spaces -> tabs only at the beginning of lines
-(setq tabify-regexp "^\t* [ \t]+")
-
-(defun format-file (file)
-  "Formats a file according to slightly changed Go rules"
-  (message "Format %s" file)
-  (save-excursion
-    (find-file file)
-    (delete-trailing-whitespace)            ;; deletes whitespaces
-    (go-mode)                               ;; sets golang rules for indentation
-    (tabify (point-min) (point-max))        ;; spaces -> tabs in the whole file
-    (indent-region (point-min) (point-max)) ;; indentation in the whole file
-    (save-buffer)))                         ;; save file
-
-(install-go-mode)
-
-;; change syntax of a standard go-mode a bit
-(advice-add
- 'go--in-composite-literal-p
- :filter-return
- (lambda (&rest r) t))
-
-;; find all files in src
-(setq files (directory-files-recursively "src" "\\.tengo\\'"))
-
-;; call format on every file.
-(dolist (file files)
-  (format-file file))
diff --git a/etc/blocks/enter-numbers-v3/workflow/package.json b/etc/blocks/enter-numbers-v3/workflow/package.json
deleted file mode 100644
index 393768cd0a..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-enter-numbers-v3.workflow",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Tengo-based template",
-  "type": "module",
-  "scripts": {
-    "build": "shx rm -rf dist && pl-tengo build",
-    "check": "pl-tengo check",
-    "format": "/usr/bin/env emacs --script ./format.el || echo 'No emacs.'"
-  },
-  "dependencies": {
-    "@platforma-sdk/workflow-tengo": "workspace:*"
-  },
-  "devDependencies": {
-    "@platforma-sdk/tengo-builder": "workspace:*",
-    "@platforma-sdk/test": "workspace:*",
-    "shx": "catalog:",
-    "vitest": "catalog:"
-  }
-}
diff --git a/etc/blocks/enter-numbers-v3/workflow/src/main.tpl.tengo b/etc/blocks/enter-numbers-v3/workflow/src/main.tpl.tengo
deleted file mode 100644
index 5a48439d7e..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/src/main.tpl.tengo
+++ /dev/null
@@ -1,9 +0,0 @@
-wf := import("@platforma-sdk/workflow-tengo:workflow")
-numbers := import(":numbers")
-assets := import("@platforma-sdk/workflow-tengo:assets")
-
-wf.setPreRun(assets.importTemplate(":prerun"))
-
-wf.body(func(args) {
-	return numbers.getNumbers(args, wf.blockId().getDataAsJson())
-})
diff --git a/etc/blocks/enter-numbers-v3/workflow/src/numbers.lib.tengo b/etc/blocks/enter-numbers-v3/workflow/src/numbers.lib.tengo
deleted file mode 100644
index bae5dec382..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/src/numbers.lib.tengo
+++ /dev/null
@@ -1,67 +0,0 @@
-smart := import("@platforma-sdk/workflow-tengo:smart")
-pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
-
-json := import("json")
-
-mapToPValueData := func(map) {
-	data := {}
-	for key, value in map {
-		data[json.encode([key])] = value
-	}
-	result := {
-		keyLength: 1,
-		data: data
-	}
-	return result
-}
-
-
-createJsonPColumnData := func(data) {
-	return smart.createValueResource(pConstants.RTYPE_P_COLUMN_DATA_JSON, data)
-}
-
-body := func(args, blockId) {
-	numbersMap := {}
-	numbers := []
-
-	for i, v in args.numbers {
-		numbersMap[string(i)] = v
-		numbers = append(numbers, v)
-	}
-
-	return {
-		outputs: {
-			numbers: smart.createJsonResource(numbers)
-		},
-		exports: {
-			numbers: {
-				spec: {
-					kind: "PColumn",
-					name: "pl7.app/test/numbers",
-					valueType: "Double",
-					annotations: {
-						"pl7.app/label": "Numbers"
-					},
-					domain: {
-						"pl7.app/blockId": blockId
-					},
-					axesSpec: [{
-						type: "String",
-						name: "pl7.app/test/numberIndex",
-						annotations: {
-							"pl7.app/label": "Index"
-						},
-						domain: {
-							"pl7.app/blockId": blockId
-						}
-					}]
-				},
-				data: createJsonPColumnData(json.encode(mapToPValueData(numbersMap)))
-			}
-		}
-	}
-}
-
-export {
-	getNumbers: body
-}
diff --git a/etc/blocks/enter-numbers-v3/workflow/src/prerun.tpl.tengo b/etc/blocks/enter-numbers-v3/workflow/src/prerun.tpl.tengo
deleted file mode 100644
index 6e82c2716b..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/src/prerun.tpl.tengo
+++ /dev/null
@@ -1,20 +0,0 @@
-wf := import("@platforma-sdk/workflow-tengo:workflow")
-smart := import("@platforma-sdk/workflow-tengo:smart")
-
-wf.body(func(args) {
-	// Count the number of even numbers
-	numbersCount := 0
-	if !is_undefined(args.evenNumbers) {
-		numbersCount = len(args.evenNumbers)
-	}
-
-	return {
-		outputs: {
-			numbersCount: smart.createJsonResource(numbersCount),
-			evenNumbers: smart.createJsonResource(args.evenNumbers),
-			// Store args directly as object, not as JSON string
-			prerunArgsJson: smart.createJsonResource(args)
-		},
-		exports: {}
-	}
-})
diff --git a/etc/blocks/enter-numbers-v3/workflow/tsconfig.json b/etc/blocks/enter-numbers-v3/workflow/tsconfig.json
deleted file mode 100644
index 4593cbadcd..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2022",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "sourceMap": true,
-    "declaration": true
-  },
-  "types": [],
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
diff --git a/etc/blocks/enter-numbers-v3/workflow/vitest.config.mts b/etc/blocks/enter-numbers-v3/workflow/vitest.config.mts
deleted file mode 100644
index 981029233d..0000000000
--- a/etc/blocks/enter-numbers-v3/workflow/vitest.config.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    watch: false,
-    maxConcurrency: 3,
-    testTimeout: 5000,
-  },
-});
diff --git a/etc/blocks/enter-numbers/.structure b/etc/blocks/enter-numbers/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/enter-numbers/.structure
+++ b/etc/blocks/enter-numbers/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/enter-numbers/block/CHANGELOG.md b/etc/blocks/enter-numbers/block/CHANGELOG.md
index 95ef01979e..37c7a4991d 100644
--- a/etc/blocks/enter-numbers/block/CHANGELOG.md
+++ b/etc/blocks/enter-numbers/block/CHANGELOG.md
@@ -1,1737 +1 @@
 # @milaboratories/milaboratories.test-enter-numbers
-
-## 1.1.1
-
-### Patch Changes
-
-- 27600c3: Escape including label columns for non primary columns
-
-## 1.1.0
-
-### Minor Changes
-
-- 238ea03: Publish the new-shape facades for two in-monorepo test blocks so a real
-  published version (carrying `BlockPointer` / `from-pack-v2`, slim deps) exists on
-  the registry. `test-enter-numbers` had `private: true` removed so it can publish
-  for the first time; `ui-examples` was already public but its latest published
-  tarball still ships the pre-facade boilerplate shape, so this republishes it in
-  the new shape.
-
-  This enables the testing-framework self-verification route to pnpm-alias an older
-  published version of these blocks beside the workspace version.
-
-## 1.0.249
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/model@1.28.4
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.64
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.18
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.239
-
-## 1.0.248
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.238
-
-## 1.0.247
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.17
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.237
-
-## 1.0.246
-
-### Patch Changes
-
-- Updated dependencies [69bd963]
-  - @platforma-sdk/model@1.28.1
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.63
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.236
-
-## 1.0.245
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/model@1.28.0
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.16
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.62
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.235
-
-## 1.0.244
-
-### Patch Changes
-
-- Updated dependencies [11f6e3e]
-  - @platforma-sdk/model@1.27.17
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.61
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.234
-
-## 1.0.243
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.15
-
-## 1.0.242
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.233
-
-## 1.0.241
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.14
-
-## 1.0.240
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.13
-
-## 1.0.239
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.232
-
-## 1.0.238
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.231
-- @platforma-sdk/model@1.27.10
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.60
-
-## 1.0.237
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.8
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.59
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.230
-
-## 1.0.236
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.6
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.58
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.229
-
-## 1.0.235
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.228
-
-## 1.0.234
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.12
-
-## 1.0.233
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.227
-
-## 1.0.232
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.226
-
-## 1.0.231
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.225
-
-## 1.0.230
-
-### Patch Changes
-
-- Updated dependencies [c57f609]
-  - @platforma-sdk/model@1.26.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.57
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.224
-
-## 1.0.229
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.223
-
-## 1.0.228
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.11
-
-## 1.0.227
-
-### Patch Changes
-
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/model@1.25.0
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.10
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.56
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.222
-
-## 1.0.226
-
-### Patch Changes
-
-- @platforma-sdk/model@1.24.11
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.55
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.221
-
-## 1.0.225
-
-### Patch Changes
-
-- Updated dependencies [4812a12]
-  - @platforma-sdk/model@1.24.10
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.54
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.9
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.220
-
-## 1.0.224
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-  - @platforma-sdk/model@1.24.9
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.219
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.53
-
-## 1.0.223
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.9
-
-## 1.0.222
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.8
-
-## 1.0.221
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/model@1.24.5
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.52
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.218
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.7
-
-## 1.0.220
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.217
-
-## 1.0.219
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.7
-
-## 1.0.218
-
-### Patch Changes
-
-- Updated dependencies [b084260]
-  - @platforma-sdk/model@1.24.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.51
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.216
-
-## 1.0.217
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.6
-
-## 1.0.216
-
-### Patch Changes
-
-- Updated dependencies [133e962]
-  - @platforma-sdk/model@1.23.4
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.50
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.215
-
-## 1.0.215
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.5
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.49
-
-## 1.0.214
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.214
-
-## 1.0.213
-
-### Patch Changes
-
-- Updated dependencies [1016b99]
-  - @platforma-sdk/model@1.23.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.49
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.213
-
-## 1.0.212
-
-### Patch Changes
-
-- Updated dependencies [63c66c8]
-  - @platforma-sdk/model@1.22.97
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.48
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.212
-
-## 1.0.211
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.211
-
-## 1.0.210
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.210
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.47
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-
-## 1.0.209
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-- @platforma-sdk/model@1.22.59
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.209
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.47
-
-## 1.0.208
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.208
-
-## 1.0.207
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.207
-
-## 1.0.206
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.206
-
-## 1.0.205
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.205
-
-## 1.0.204
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.204
-
-## 1.0.203
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.203
-
-## 1.0.202
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.202
-
-## 1.0.201
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.201
-
-## 1.0.200
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.200
-
-## 1.0.199
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.199
-
-## 1.0.198
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.198
-
-## 1.0.197
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.197
-
-## 1.0.196
-
-### Patch Changes
-
-- Updated dependencies [388c9d2]
-  - @platforma-sdk/model@1.22.18
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.46
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.196
-
-## 1.0.195
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.195
-
-## 1.0.194
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.194
-
-## 1.0.193
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.193
-
-## 1.0.192
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.192
-
-## 1.0.191
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.191
-
-## 1.0.190
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.190
-
-## 1.0.189
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.189
-
-## 1.0.188
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.188
-
-## 1.0.187
-
-### Patch Changes
-
-- Updated dependencies [ce558f9]
-- Updated dependencies [b41709a]
-  - @platforma-sdk/model@1.22.2
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.45
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.187
-
-## 1.0.186
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.186
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.44
-
-## 1.0.185
-
-### Patch Changes
-
-- Updated dependencies [c0d5856]
-  - @platforma-sdk/model@1.22.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.44
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.185
-
-## 1.0.184
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.184
-
-## 1.0.183
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.183
-
-## 1.0.182
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.182
-
-## 1.0.181
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.181
-
-## 1.0.180
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.180
-
-## 1.0.179
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.179
-
-## 1.0.178
-
-### Patch Changes
-
-- @platforma-sdk/model@1.21.20
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.178
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.43
-
-## 1.0.177
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.177
-
-## 1.0.176
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.176
-
-## 1.0.175
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.175
-
-## 1.0.174
-
-### Patch Changes
-
-- Updated dependencies [9d8f87b]
-  - @platforma-sdk/model@1.21.10
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.42
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.174
-
-## 1.0.173
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.173
-
-## 1.0.172
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.172
-
-## 1.0.171
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.171
-
-## 1.0.170
-
-### Patch Changes
-
-- Updated dependencies [05c8c1c]
-  - @platforma-sdk/model@1.21.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.41
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.170
-
-## 1.0.169
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.169
-
-## 1.0.168
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.168
-
-## 1.0.167
-
-### Patch Changes
-
-- Updated dependencies [079f50e]
-  - @platforma-sdk/model@1.20.27
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.40
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.167
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-
-## 1.0.166
-
-### Patch Changes
-
-- Updated dependencies [8043f5d]
-  - @platforma-sdk/model@1.20.24
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.39
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.166
-
-## 1.0.165
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.165
-
-## 1.0.164
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.164
-
-## 1.0.163
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.163
-
-## 1.0.162
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.162
-
-## 1.0.161
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.161
-
-## 1.0.160
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.160
-
-## 1.0.159
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.159
-
-## 1.0.158
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.158
-
-## 1.0.157
-
-### Patch Changes
-
-- Updated dependencies [ead0e68]
-  - @platforma-sdk/model@1.20.11
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.38
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.157
-
-## 1.0.156
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.156
-
-## 1.0.155
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.155
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.37
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-
-## 1.0.154
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.154
-
-## 1.0.153
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/model@1.20.6
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.37
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.153
-
-## 1.0.152
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.152
-
-## 1.0.151
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.151
-
-## 1.0.150
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.150
-
-## 1.0.149
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/model@1.20.0
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.149
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.36
-
-## 1.0.148
-
-### Patch Changes
-
-- Updated dependencies [4d9885b]
-  - @platforma-sdk/model@1.19.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.35
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.148
-
-## 1.0.147
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.147
-
-## 1.0.146
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.146
-
-## 1.0.145
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.145
-
-## 1.0.144
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.144
-
-## 1.0.143
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.143
-
-## 1.0.142
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.142
-
-## 1.0.141
-
-### Patch Changes
-
-- @platforma-sdk/model@1.18.0
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.141
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.34
-
-## 1.0.140
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.140
-
-## 1.0.139
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.139
-
-## 1.0.138
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.138
-
-## 1.0.137
-
-### Patch Changes
-
-- Updated dependencies [b1a3abc]
-  - @platforma-sdk/model@1.17.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.33
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.137
-
-## 1.0.136
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.136
-
-## 1.0.135
-
-### Patch Changes
-
-- @platforma-sdk/model@1.15.4
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.32
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.135
-
-## 1.0.134
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.134
-
-## 1.0.133
-
-### Patch Changes
-
-- Updated dependencies [b4081fc]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.133
-
-## 1.0.132
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.132
-
-## 1.0.131
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.131
-
-## 1.0.130
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.130
-
-## 1.0.129
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.129
-
-## 1.0.128
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.128
-
-## 1.0.127
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.127
-
-## 1.0.126
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.126
-
-## 1.0.125
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.125
-
-## 1.0.124
-
-### Patch Changes
-
-- 8644e62: move from block-components -> blocks for nicer structure
-- Updated dependencies [8644e62]
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.4
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.31
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.124
-
-## 1.0.123
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.123
-
-## 1.0.122
-
-### Patch Changes
-
-- Updated dependencies [3dd3a5c]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.30
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.122
-
-## 1.0.121
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.121
-
-## 1.0.120
-
-### Patch Changes
-
-- Updated dependencies [a886400]
-  - @platforma-sdk/model@1.14.1
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.120
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.29
-
-## 1.0.119
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-- @platforma-sdk/model@1.14.0
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.119
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.28
-
-## 1.0.118
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.118
-
-## 1.0.117
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.117
-
-## 1.0.116
-
-### Patch Changes
-
-- @platforma-sdk/model@1.13.15
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.27
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.116
-
-## 1.0.115
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.115
-
-## 1.0.114
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.114
-
-## 1.0.113
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.113
-
-## 1.0.112
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.112
-
-## 1.0.111
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.111
-
-## 1.0.110
-
-### Patch Changes
-
-- Updated dependencies [a071779]
-- Updated dependencies [6208826]
-  - @platforma-sdk/model@1.13.5
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.26
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.110
-
-## 1.0.109
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.109
-
-## 1.0.108
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.108
-
-## 1.0.107
-
-### Patch Changes
-
-- @platforma-sdk/model@1.13.2
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.25
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.107
-
-## 1.0.106
-
-### Patch Changes
-
-- Updated dependencies [3157ecd]
-  - @platforma-sdk/model@1.13.0
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.106
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.24
-
-## 1.0.105
-
-### Patch Changes
-
-- Updated dependencies [b207f86]
-  - @platforma-sdk/model@1.12.0
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.23
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.105
-
-## 1.0.104
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.104
-
-## 1.0.103
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.103
-
-## 1.0.102
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.102
-
-## 1.0.101
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.101
-
-## 1.0.100
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.100
-
-## 1.0.99
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.99
-
-## 1.0.98
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.98
-
-## 1.0.97
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.97
-
-## 1.0.96
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.96
-
-## 1.0.95
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.95
-
-## 1.0.94
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.94
-
-## 1.0.93
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.93
-
-## 1.0.92
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.92
-
-## 1.0.91
-
-### Patch Changes
-
-- Updated dependencies [ade3acf]
-  - @platforma-sdk/model@1.10.12
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.91
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.22
-
-## 1.0.90
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.90
-
-## 1.0.89
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.89
-
-## 1.0.88
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.88
-
-## 1.0.87
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.87
-
-## 1.0.86
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.86
-
-## 1.0.85
-
-### Patch Changes
-
-- Updated dependencies [8187ba2]
-  - @platforma-sdk/model@1.10.2
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.85
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.21
-
-## 1.0.84
-
-### Patch Changes
-
-- Updated dependencies [b089273]
-  - @platforma-sdk/model@1.10.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.20
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.84
-
-## 1.0.83
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.83
-
-## 1.0.82
-
-### Patch Changes
-
-- Updated dependencies [b04a78a]
-  - @platforma-sdk/model@1.9.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.19
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.82
-
-## 1.0.81
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.81
-
-## 1.0.80
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.80
-
-## 1.0.79
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.79
-
-## 1.0.78
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.78
-
-## 1.0.77
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.77
-
-## 1.0.76
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.76
-
-## 1.0.75
-
-### Patch Changes
-
-- Updated dependencies [8f916f2]
-  - @platforma-sdk/model@1.8.19
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.75
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.18
-
-## 1.0.74
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.74
-
-## 1.0.73
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.73
-
-## 1.0.72
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.72
-
-## 1.0.71
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.71
-
-## 1.0.70
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.70
-
-## 1.0.69
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.69
-
-## 1.0.68
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.68
-
-## 1.0.67
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.67
-
-## 1.0.66
-
-### Patch Changes
-
-- Updated dependencies [a5af4f2]
-  - @platforma-sdk/model@1.8.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.17
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.66
-
-## 1.0.65
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.53
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.16
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.65
-
-## 1.0.64
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.64
-
-## 1.0.63
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.63
-
-## 1.0.62
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.62
-
-## 1.0.61
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.61
-
-## 1.0.60
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.60
-
-## 1.0.59
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.59
-
-## 1.0.58
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.58
-
-## 1.0.57
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.57
-
-## 1.0.56
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.56
-
-## 1.0.55
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.55
-
-## 1.0.54
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.54
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.15
-
-## 1.0.53
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.53
-
-## 1.0.52
-
-### Patch Changes
-
-- Updated dependencies [eddcfed]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.52
-
-## 1.0.51
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.51
-
-## 1.0.50
-
-### Patch Changes
-
-- a0854a3: Small common ui fixes
-- Updated dependencies [a0854a3]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.50
-
-## 1.0.49
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.49
-
-## 1.0.48
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.48
-
-## 1.0.47
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.47
-
-## 1.0.46
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.46
-
-## 1.0.45
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.45
-
-## 1.0.44
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.44
-
-## 1.0.43
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.43
-
-## 1.0.42
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.42
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-- @platforma-sdk/model@1.7.20
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.15
-
-## 1.0.41
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.41
-
-## 1.0.40
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.40
-
-## 1.0.39
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.16
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.14
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.39
-
-## 1.0.38
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.38
-
-## 1.0.37
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.37
-
-## 1.0.36
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.9
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.36
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.13
-
-## 1.0.35
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.35
-
-## 1.0.34
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.34
-
-## 1.0.33
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.33
-
-## 1.0.32
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.32
-
-## 1.0.31
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.31
-
-## 1.0.30
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.30
-
-## 1.0.29
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.0
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.12
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.29
-
-## 1.0.28
-
-### Patch Changes
-
-- Updated dependencies [eb079e9]
-  - @platforma-sdk/model@1.6.0
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.28
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.11
-
-## 1.0.27
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.27
-
-## 1.0.26
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.26
-
-## 1.0.25
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.25
-
-## 1.0.24
-
-### Patch Changes
-
-- Updated dependencies [13013ee]
-  - @platforma-sdk/model@1.5.40
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.24
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.10
-
-## 1.0.23
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.23
-
-## 1.0.22
-
-### Patch Changes
-
-- Updated dependencies [bc6d116]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.22
-
-## 1.0.21
-
-### Patch Changes
-
-- Updated dependencies [cfb6385]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.21
-
-## 1.0.20
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.20
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.9
-
-## 1.0.19
-
-### Patch Changes
-
-- Updated dependencies [892ef23]
-  - @platforma-sdk/model@1.2.32
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.9
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.19
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [7812ae6]
-  - @platforma-sdk/model@1.2.31
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.8
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.18
-
-## 1.0.17
-
-### Patch Changes
-
-- Updated dependencies [7a12b39]
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.3
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.7
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.17
-
-## 1.0.16
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.16
-
-## 1.0.15
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.15
-
-## 1.0.14
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.14
-
-## 1.0.13
-
-### Patch Changes
-
-- Updated dependencies [3c85025]
-  - @platforma-sdk/model@1.2.30
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.13
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.6
-
-## 1.0.12
-
-### Patch Changes
-
-- Updated dependencies [6495dcc]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.12
-
-## 1.0.11
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.11
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [c549960]
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.2
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.5
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.10
-
-## 1.0.9
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.1
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.4
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.9
-
-## 1.0.8
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.ui@1.0.8
-
-## 1.0.7
-
-### Patch Changes
-
-- Updated dependencies [60223f4]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.7
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [aff132f]
-- Updated dependencies [583c929]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.6
-
-## 1.0.5
-
-### Patch Changes
-
-- Updated dependencies [156a72d]
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.5
-
-## 1.0.4
-
-### Patch Changes
-
-- 6d7f739: restructuring of test block folders
-- Updated dependencies [4fe1674]
-- Updated dependencies [164fc89]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.4
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.4
-  - @platforma-sdk/model@1.2.29
-
-## 1.0.3
-
-### Patch Changes
-
-- Updated dependencies [838493b]
-  - @platforma-sdk/model@1.2.28
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.3
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.1
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.3
-
-## 1.0.2
-
-### Patch Changes
-
-- fa6d0f2: V2 Registry API
-- Updated dependencies [fa6d0f2]
-- Updated dependencies [5eb6127]
-- Updated dependencies [5f95b40]
-  - @platforma-sdk/model@1.2.27
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.2
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.2
-
-## 1.0.1
-
-### Patch Changes
-
-- 81aa0c7: initial commit of first test block transferred to monorepo
-- Updated dependencies [81aa0c7]
-  - @milaboratories/milaboratories.test-enter-numbers.workflow@1.0.1
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.1
-  - @milaboratories/milaboratories.test-enter-numbers.ui@1.0.1
diff --git a/etc/blocks/enter-numbers/block/package.json b/etc/blocks/enter-numbers/block/package.json
index bf269190ec..813f68556b 100644
--- a/etc/blocks/enter-numbers/block/package.json
+++ b/etc/blocks/enter-numbers/block/package.json
@@ -1,6 +1,7 @@
 {
   "name": "@milaboratories/milaboratories.test-enter-numbers",
-  "version": "1.1.1",
+  "version": "1.0.0",
+  "private": true,
   "files": [
     "dist",
     "block-pack"
@@ -24,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-enter-numbers.kind": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers.model": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers.ui": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers.workflow": "workspace:*",
@@ -41,8 +43,8 @@
       "ui": "@milaboratories/milaboratories.test-enter-numbers.ui/dist"
     },
     "meta": {
-      "title": "Enter Numbers (old api)",
-      "description": "Enter Numbers (old api)",
+      "title": "Enter Numbers (new api)",
+      "description": "Enter Numbers",
       "logo": "file:logos/block-logo.png",
       "organization": {
         "name": "MiLaboratories Inc",
diff --git a/etc/blocks/enter-numbers/kind/.oxfmtrc.json b/etc/blocks/enter-numbers/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/enter-numbers/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/enter-numbers-v3/model/.oxlintrc.json b/etc/blocks/enter-numbers/kind/.oxlintrc.json
similarity index 69%
rename from etc/blocks/enter-numbers-v3/model/.oxlintrc.json
rename to etc/blocks/enter-numbers/kind/.oxlintrc.json
index 70ab6b8dc2..b1a139038f 100644
--- a/etc/blocks/enter-numbers-v3/model/.oxlintrc.json
+++ b/etc/blocks/enter-numbers/kind/.oxlintrc.json
@@ -1,3 +1,3 @@
 {
-  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-block-model.json"]
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
 }
diff --git a/etc/blocks/enter-numbers/kind/package.json b/etc/blocks/enter-numbers/kind/package.json
new file mode 100644
index 0000000000..b2fc176d53
--- /dev/null
+++ b/etc/blocks/enter-numbers/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-enter-numbers.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the enter-numbers block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/enter-numbers/kind/src/index.ts b/etc/blocks/enter-numbers/kind/src/index.ts
new file mode 100644
index 0000000000..54a3c5f6e8
--- /dev/null
+++ b/etc/blocks/enter-numbers/kind/src/index.ts
@@ -0,0 +1,33 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the enter-numbers block — what a creator or a project
+ * template supplies to seed a new instance. A subset of the model's `BlockData`:
+ * `numbers` is the block's author-supplied input, while `labels` and
+ * `description` exist only for the v1→v2→v3 migration chain to populate, and
+ * always default. Optional, because a block may be created without a template.
+ */
+export type BlockParams = { numbers?: number[] };
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is most of the reason to write this at all. Without it, a file saying
+ * `number: [1, 2, 3]` — singular — passes every check: the key is ignored, the block
+ * initializes empty, and the only complaint arrives later from the block's own
+ * `args()`, saying "Numbers are required!" and naming nothing about the typo. With it,
+ * the entry is rejected and the unrecognized key is named.
+ *
+ * The type argument to `defineBlockKind` keeps the two in step: this schema has to
+ * produce `BlockParams`, so dropping a field it declares is a compile error.
+ */
+const Params = z.object({ numbers: z.array(z.number()).optional() }).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/enter-numbers/kind/tsconfig.json b/etc/blocks/enter-numbers/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/enter-numbers/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/enter-numbers/model/CHANGELOG.md b/etc/blocks/enter-numbers/model/CHANGELOG.md
index 38da1c7840..7e130aeaab 100644
--- a/etc/blocks/enter-numbers/model/CHANGELOG.md
+++ b/etc/blocks/enter-numbers/model/CHANGELOG.md
@@ -1,433 +1 @@
 # @milaboratories/milaboratories.test-enter-numbers.model
-
-## 1.0.64
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/model@1.28.4
-
-## 1.0.63
-
-### Patch Changes
-
-- Updated dependencies [69bd963]
-  - @platforma-sdk/model@1.28.1
-
-## 1.0.62
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/model@1.28.0
-
-## 1.0.61
-
-### Patch Changes
-
-- Updated dependencies [11f6e3e]
-  - @platforma-sdk/model@1.27.17
-
-## 1.0.60
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.10
-
-## 1.0.59
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.8
-
-## 1.0.58
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.6
-
-## 1.0.57
-
-### Patch Changes
-
-- Updated dependencies [c57f609]
-  - @platforma-sdk/model@1.26.0
-
-## 1.0.56
-
-### Patch Changes
-
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/model@1.25.0
-
-## 1.0.55
-
-### Patch Changes
-
-- @platforma-sdk/model@1.24.11
-
-## 1.0.54
-
-### Patch Changes
-
-- Updated dependencies [4812a12]
-  - @platforma-sdk/model@1.24.10
-
-## 1.0.53
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-  - @platforma-sdk/model@1.24.9
-
-## 1.0.52
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/model@1.24.5
-
-## 1.0.51
-
-### Patch Changes
-
-- Updated dependencies [b084260]
-  - @platforma-sdk/model@1.24.0
-
-## 1.0.50
-
-### Patch Changes
-
-- Updated dependencies [133e962]
-  - @platforma-sdk/model@1.23.4
-
-## 1.0.49
-
-### Patch Changes
-
-- Updated dependencies [1016b99]
-  - @platforma-sdk/model@1.23.0
-
-## 1.0.48
-
-### Patch Changes
-
-- Updated dependencies [63c66c8]
-  - @platforma-sdk/model@1.22.97
-
-## 1.0.47
-
-### Patch Changes
-
-- @platforma-sdk/model@1.22.59
-
-## 1.0.46
-
-### Patch Changes
-
-- Updated dependencies [388c9d2]
-  - @platforma-sdk/model@1.22.18
-
-## 1.0.45
-
-### Patch Changes
-
-- Updated dependencies [ce558f9]
-- Updated dependencies [b41709a]
-  - @platforma-sdk/model@1.22.2
-
-## 1.0.44
-
-### Patch Changes
-
-- Updated dependencies [c0d5856]
-  - @platforma-sdk/model@1.22.0
-
-## 1.0.43
-
-### Patch Changes
-
-- @platforma-sdk/model@1.21.20
-
-## 1.0.42
-
-### Patch Changes
-
-- Updated dependencies [9d8f87b]
-  - @platforma-sdk/model@1.21.10
-
-## 1.0.41
-
-### Patch Changes
-
-- Updated dependencies [05c8c1c]
-  - @platforma-sdk/model@1.21.0
-
-## 1.0.40
-
-### Patch Changes
-
-- Updated dependencies [079f50e]
-  - @platforma-sdk/model@1.20.27
-
-## 1.0.39
-
-### Patch Changes
-
-- Updated dependencies [8043f5d]
-  - @platforma-sdk/model@1.20.24
-
-## 1.0.38
-
-### Patch Changes
-
-- Updated dependencies [ead0e68]
-  - @platforma-sdk/model@1.20.11
-
-## 1.0.37
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/model@1.20.6
-
-## 1.0.36
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/model@1.20.0
-
-## 1.0.35
-
-### Patch Changes
-
-- Updated dependencies [4d9885b]
-  - @platforma-sdk/model@1.19.0
-
-## 1.0.34
-
-### Patch Changes
-
-- @platforma-sdk/model@1.18.0
-
-## 1.0.33
-
-### Patch Changes
-
-- Updated dependencies [b1a3abc]
-  - @platforma-sdk/model@1.17.0
-
-## 1.0.32
-
-### Patch Changes
-
-- @platforma-sdk/model@1.15.4
-
-## 1.0.31
-
-### Patch Changes
-
-- 8644e62: move from block-components -> blocks for nicer structure
-
-## 1.0.30
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
-
-## 1.0.29
-
-### Patch Changes
-
-- Updated dependencies [a886400]
-  - @platforma-sdk/model@1.14.1
-
-## 1.0.28
-
-### Patch Changes
-
-- @platforma-sdk/model@1.14.0
-
-## 1.0.27
-
-### Patch Changes
-
-- @platforma-sdk/model@1.13.15
-
-## 1.0.26
-
-### Patch Changes
-
-- Updated dependencies [a071779]
-- Updated dependencies [6208826]
-  - @platforma-sdk/model@1.13.5
-
-## 1.0.25
-
-### Patch Changes
-
-- @platforma-sdk/model@1.13.2
-
-## 1.0.24
-
-### Patch Changes
-
-- Updated dependencies [3157ecd]
-  - @platforma-sdk/model@1.13.0
-
-## 1.0.23
-
-### Patch Changes
-
-- Updated dependencies [b207f86]
-  - @platforma-sdk/model@1.12.0
-
-## 1.0.22
-
-### Patch Changes
-
-- Updated dependencies [ade3acf]
-  - @platforma-sdk/model@1.10.12
-
-## 1.0.21
-
-### Patch Changes
-
-- Updated dependencies [8187ba2]
-  - @platforma-sdk/model@1.10.2
-
-## 1.0.20
-
-### Patch Changes
-
-- Updated dependencies [b089273]
-  - @platforma-sdk/model@1.10.0
-
-## 1.0.19
-
-### Patch Changes
-
-- Updated dependencies [b04a78a]
-  - @platforma-sdk/model@1.9.0
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [8f916f2]
-  - @platforma-sdk/model@1.8.19
-
-## 1.0.17
-
-### Patch Changes
-
-- Updated dependencies [a5af4f2]
-  - @platforma-sdk/model@1.8.0
-
-## 1.0.16
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.53
-
-## 1.0.15
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.20
-
-## 1.0.14
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.16
-
-## 1.0.13
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.9
-
-## 1.0.12
-
-### Patch Changes
-
-- @platforma-sdk/model@1.7.0
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [eb079e9]
-  - @platforma-sdk/model@1.6.0
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [13013ee]
-  - @platforma-sdk/model@1.5.40
-
-## 1.0.9
-
-### Patch Changes
-
-- Updated dependencies [892ef23]
-  - @platforma-sdk/model@1.2.32
-
-## 1.0.8
-
-### Patch Changes
-
-- Updated dependencies [7812ae6]
-  - @platforma-sdk/model@1.2.31
-
-## 1.0.7
-
-### Patch Changes
-
-- 7a12b39: Add useWatchFetch usable
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [3c85025]
-  - @platforma-sdk/model@1.2.30
-
-## 1.0.5
-
-### Patch Changes
-
-- c549960: fix test enter-numbers wf
-
-## 1.0.4
-
-### Patch Changes
-
-- 4fe1674: add basic ui to test-enter-numbers block
-- Updated dependencies [164fc89]
-  - @platforma-sdk/model@1.2.29
-
-## 1.0.3
-
-### Patch Changes
-
-- Updated dependencies [838493b]
-  - @platforma-sdk/model@1.2.28
-
-## 1.0.2
-
-### Patch Changes
-
-- Updated dependencies [fa6d0f2]
-- Updated dependencies [5eb6127]
-- Updated dependencies [5f95b40]
-  - @platforma-sdk/model@1.2.27
-
-## 1.0.1
-
-### Patch Changes
-
-- 81aa0c7: initial commit of first test block transferred to monorepo
diff --git a/etc/blocks/enter-numbers/model/package.json b/etc/blocks/enter-numbers/model/package.json
index 790cb0c08c..4cd759eb86 100644
--- a/etc/blocks/enter-numbers/model/package.json
+++ b/etc/blocks/enter-numbers/model/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-enter-numbers.model",
-  "version": "1.0.64",
+  "version": "1.0.0",
   "private": true,
   "description": "Block model",
   "type": "module",
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-enter-numbers.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/enter-numbers/model/src/index.ts b/etc/blocks/enter-numbers/model/src/index.ts
index de28b59b8c..be32aff95b 100644
--- a/etc/blocks/enter-numbers/model/src/index.ts
+++ b/etc/blocks/enter-numbers/model/src/index.ts
@@ -1,27 +1,94 @@
 import type { InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import { BlockModel } from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-enter-numbers.kind";
 import { z } from "zod";
 
-export const $BlockArgs = z.object({
+// Data version 1: just numbers
+type BlockDataV1 = {
+  numbers: number[];
+};
+
+// Data version 2: added labels
+type BlockDataV2 = {
+  numbers: number[];
+  labels: string[];
+};
+
+// Data version 3 (current): added description
+export const $BlockData = z.object({
   numbers: z.array(z.coerce.number()),
+  labels: z.array(z.string()),
+  description: z.string(),
 });
 
-export type BlockArgs = z.infer<typeof $BlockArgs>;
+export type BlockData = z.infer<typeof $BlockData>;
+
+// Define data model with migrations from v1 to current
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockDataV1>("v1")
+  // Migration v1 → v2: sort numbers and add labels
+  // Throws if numbers contain 666 (for testing migration failure recovery)
+  .migrate<BlockDataV2>("v2", (data) => {
+    if (data.numbers.includes(666)) {
+      throw new Error("Migration failed: number 666 is forbidden!");
+    }
+    return { numbers: data.numbers.toSorted(), labels: ["migrated-from-v1"] };
+  })
+  // Migration v2 → v3: add description
+  .migrate<BlockData>("v3", (data) => {
+    return { ...data, description: `Migrated: ${data.labels.join(", ")}` };
+  })
+  // `numbers` is the kind's only init param; `labels` / `description` are
+  // populated by the migrations above and always start empty. `params` is
+  // optional — a block may be created without a template — so it keeps a
+  // fallback default.
+  .init(({ params }) => ({ numbers: params?.numbers ?? [], labels: [], description: "" }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
-export const platforma = BlockModel.create("Heavy")
+  .args((data) => {
+    if (data.numbers.length === 0) {
+      throw new Error("Numbers are required!");
+    }
+    // Test sentinel: args() returns undefined (without throwing) to exercise the
+    // "derivation succeeds but value is undefined" contract used by real blocks
+    // (e.g. `if (!Valid.safeParse(data).success) return undefined`).
+    if (data.numbers.length === 1 && data.numbers[0] === 777) {
+      return undefined;
+    }
+    return { numbers: data.numbers.toSorted() };
+  })
 
-  .withArgs<BlockArgs>({ numbers: [] })
+  .prerunArgs((data) => {
+    return { evenNumbers: data.numbers.toSorted().filter((n) => n % 2 === 0) };
+  })
+
+  .templateParams((data) => {
+    return { numbers: data.numbers };
+  })
 
   .output("numbers", (ctx) => ctx.outputs?.resolve("numbers")?.getDataAsJson<number[]>())
 
+  .output("activeArgs", (ctx) => ctx.activeArgs)
+
+  .output(
+    "numbersCount",
+    (ctx) => ctx.prerun?.resolve("numbersCount")?.getDataAsJson<number>() ?? 0,
+  )
+
+  .output("prerunArgsJson", (ctx) =>
+    ctx.prerun?.resolve("prerunArgsJson")?.getDataAsJson<Record<string, unknown>>(),
+  )
+
   .output("errorIfNumberIs999", (ctx) => {
-    if (ctx.args.numbers.length === 1 && ctx.args.numbers[0] === 999) {
+    const numbers = ctx.args?.numbers;
+
+    if (numbers?.length === 1 && numbers[0] === 999) {
       return ctx.prerun?.resolve("numbers")?.getFileContentAsJson<number[]>();
     }
-    return ctx.args.numbers;
-  })
 
-  .output("activeArgs", (ctx) => ctx.activeArgs)
+    return numbers ?? [];
+  })
 
   .output("ctx", (ctx) => ctx)
 
@@ -31,15 +98,11 @@ export const platforma = BlockModel.create("Heavy")
 
   .output("ctx.data", (ctx) => ctx.data)
 
-  .output("ctx.uiState", (ctx) => ctx.uiState)
-
-  .argsValid((ctx) => ctx.args.numbers.length > 0)
-
   .sections((_ctx) => {
     return [{ type: "link", href: "/", label: "Main" }];
   })
 
-  .done(2); // ui api version 2
+  .done();
 
 export type BlockOutputs = InferOutputsType<typeof platforma>;
 export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/enter-numbers/ui/CHANGELOG.md b/etc/blocks/enter-numbers/ui/CHANGELOG.md
index 862653411c..4744509a80 100644
--- a/etc/blocks/enter-numbers/ui/CHANGELOG.md
+++ b/etc/blocks/enter-numbers/ui/CHANGELOG.md
@@ -1,1657 +1 @@
 # @milaboratories/milaboratories.test-enter-numbers.ui
-
-## 1.0.239
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.64
-- @platforma-sdk/ui-vue@1.28.4
-
-## 1.0.238
-
-### Patch Changes
-
-- Updated dependencies [168d2eb]
-  - @platforma-sdk/ui-vue@1.28.3
-
-## 1.0.237
-
-### Patch Changes
-
-- Updated dependencies [c021ce8]
-  - @platforma-sdk/ui-vue@1.28.2
-
-## 1.0.236
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.63
-- @platforma-sdk/ui-vue@1.28.1
-
-## 1.0.235
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.62
-- @platforma-sdk/ui-vue@1.28.0
-
-## 1.0.234
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.61
-- @platforma-sdk/ui-vue@1.27.17
-
-## 1.0.233
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.27.14
-
-## 1.0.232
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.27.11
-
-## 1.0.231
-
-### Patch Changes
-
-- Updated dependencies [22871ac]
-- Updated dependencies [4f5f7ec]
-  - @platforma-sdk/ui-vue@1.27.10
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.60
-
-## 1.0.230
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.59
-- @platforma-sdk/ui-vue@1.27.8
-
-## 1.0.229
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.58
-- @platforma-sdk/ui-vue@1.27.6
-
-## 1.0.228
-
-### Patch Changes
-
-- Updated dependencies [518ec02]
-  - @platforma-sdk/ui-vue@1.27.5
-
-## 1.0.227
-
-### Patch Changes
-
-- Updated dependencies [9633567]
-  - @platforma-sdk/ui-vue@1.27.2
-
-## 1.0.226
-
-### Patch Changes
-
-- Updated dependencies [da875e0]
-  - @platforma-sdk/ui-vue@1.27.0
-
-## 1.0.225
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.26.1
-
-## 1.0.224
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.57
-- @platforma-sdk/ui-vue@1.26.0
-
-## 1.0.223
-
-### Patch Changes
-
-- Updated dependencies [2c4b360]
-  - @platforma-sdk/ui-vue@1.25.2
-
-## 1.0.222
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.56
-- @platforma-sdk/ui-vue@1.25.0
-
-## 1.0.221
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.11
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.55
-
-## 1.0.220
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.10
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.54
-
-## 1.0.219
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-- Updated dependencies [907c694]
-  - @platforma-sdk/ui-vue@1.24.9
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.53
-
-## 1.0.218
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/ui-vue@1.24.5
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.52
-
-## 1.0.217
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.3
-
-## 1.0.216
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.51
-- @platforma-sdk/ui-vue@1.24.0
-
-## 1.0.215
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.50
-- @platforma-sdk/ui-vue@1.23.4
-
-## 1.0.214
-
-### Patch Changes
-
-- Updated dependencies [0a3ee03]
-  - @platforma-sdk/ui-vue@1.23.2
-
-## 1.0.213
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.49
-- @platforma-sdk/ui-vue@1.23.0
-
-## 1.0.212
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.48
-- @platforma-sdk/ui-vue@1.22.97
-
-## 1.0.211
-
-### Patch Changes
-
-- Updated dependencies [13e3124]
-  - @platforma-sdk/ui-vue@1.22.82
-
-## 1.0.210
-
-### Patch Changes
-
-- Updated dependencies [e06efcd]
-  - @platforma-sdk/ui-vue@1.22.64
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.47
-
-## 1.0.209
-
-### Patch Changes
-
-- Updated dependencies [819c13c]
-  - @platforma-sdk/ui-vue@1.22.59
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.47
-
-## 1.0.208
-
-### Patch Changes
-
-- Updated dependencies [26abb69]
-  - @platforma-sdk/ui-vue@1.22.56
-
-## 1.0.207
-
-### Patch Changes
-
-- Updated dependencies [fab0a91]
-  - @platforma-sdk/ui-vue@1.22.55
-
-## 1.0.206
-
-### Patch Changes
-
-- Updated dependencies [48f1820]
-  - @platforma-sdk/ui-vue@1.22.52
-
-## 1.0.205
-
-### Patch Changes
-
-- Updated dependencies [7ac5190]
-  - @platforma-sdk/ui-vue@1.22.51
-
-## 1.0.204
-
-### Patch Changes
-
-- Updated dependencies [2970f8d]
-  - @platforma-sdk/ui-vue@1.22.39
-
-## 1.0.203
-
-### Patch Changes
-
-- Updated dependencies [b752000]
-  - @platforma-sdk/ui-vue@1.22.34
-
-## 1.0.202
-
-### Patch Changes
-
-- Updated dependencies [c39eeee]
-  - @platforma-sdk/ui-vue@1.22.32
-
-## 1.0.201
-
-### Patch Changes
-
-- Updated dependencies [7dac3ce]
-  - @platforma-sdk/ui-vue@1.22.30
-
-## 1.0.200
-
-### Patch Changes
-
-- Updated dependencies [0c5753b]
-  - @platforma-sdk/ui-vue@1.22.29
-
-## 1.0.199
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.24
-
-## 1.0.198
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.23
-
-## 1.0.197
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.19
-
-## 1.0.196
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.46
-- @platforma-sdk/ui-vue@1.22.18
-
-## 1.0.195
-
-### Patch Changes
-
-- Updated dependencies [1a8b275]
-  - @platforma-sdk/ui-vue@1.22.16
-
-## 1.0.194
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.14
-
-## 1.0.193
-
-### Patch Changes
-
-- Updated dependencies [6d3d92d]
-  - @platforma-sdk/ui-vue@1.22.11
-
-## 1.0.192
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.10
-
-## 1.0.191
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.9
-
-## 1.0.190
-
-### Patch Changes
-
-- Updated dependencies [9bdc9d2]
-  - @platforma-sdk/ui-vue@1.22.8
-
-## 1.0.189
-
-### Patch Changes
-
-- Updated dependencies [698c647]
-  - @platforma-sdk/ui-vue@1.22.7
-
-## 1.0.188
-
-### Patch Changes
-
-- Updated dependencies [c5269a5]
-  - @platforma-sdk/ui-vue@1.22.4
-
-## 1.0.187
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.45
-- @platforma-sdk/ui-vue@1.22.2
-
-## 1.0.186
-
-### Patch Changes
-
-- Updated dependencies [02860e7]
-  - @platforma-sdk/ui-vue@1.22.1
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.44
-
-## 1.0.185
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.44
-- @platforma-sdk/ui-vue@1.22.0
-
-## 1.0.184
-
-### Patch Changes
-
-- Updated dependencies [56f7e84]
-  - @platforma-sdk/ui-vue@1.21.30
-
-## 1.0.183
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.29
-
-## 1.0.182
-
-### Patch Changes
-
-- Updated dependencies [3ff9dcd]
-  - @platforma-sdk/ui-vue@1.21.25
-
-## 1.0.181
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.24
-
-## 1.0.180
-
-### Patch Changes
-
-- Updated dependencies [9b5a692]
-  - @platforma-sdk/ui-vue@1.21.23
-
-## 1.0.179
-
-### Patch Changes
-
-- Updated dependencies [93b8d8d]
-  - @platforma-sdk/ui-vue@1.21.21
-
-## 1.0.178
-
-### Patch Changes
-
-- Updated dependencies [32966e6]
-  - @platforma-sdk/ui-vue@1.21.20
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.43
-
-## 1.0.177
-
-### Patch Changes
-
-- Updated dependencies [53e35de]
-  - @platforma-sdk/ui-vue@1.21.18
-
-## 1.0.176
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.17
-
-## 1.0.175
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.12
-
-## 1.0.174
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.42
-- @platforma-sdk/ui-vue@1.21.10
-
-## 1.0.173
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.8
-
-## 1.0.172
-
-### Patch Changes
-
-- Updated dependencies [16c729a]
-  - @platforma-sdk/ui-vue@1.21.5
-
-## 1.0.171
-
-### Patch Changes
-
-- Updated dependencies [2639fac]
-  - @platforma-sdk/ui-vue@1.21.3
-
-## 1.0.170
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.41
-- @platforma-sdk/ui-vue@1.21.0
-
-## 1.0.169
-
-### Patch Changes
-
-- Updated dependencies [78d049b]
-  - @platforma-sdk/ui-vue@1.20.30
-
-## 1.0.168
-
-### Patch Changes
-
-- Updated dependencies [7a235ba]
-  - @platforma-sdk/ui-vue@1.20.28
-
-## 1.0.167
-
-### Patch Changes
-
-- Updated dependencies [f48b25e]
-- Updated dependencies [354291e]
-  - @platforma-sdk/ui-vue@1.20.27
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.40
-
-## 1.0.166
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.39
-- @platforma-sdk/ui-vue@1.20.24
-
-## 1.0.165
-
-### Patch Changes
-
-- Updated dependencies [28b2b5c]
-- Updated dependencies [0cce397]
-  - @platforma-sdk/ui-vue@1.20.23
-
-## 1.0.164
-
-### Patch Changes
-
-- Updated dependencies [54cdf0f]
-  - @platforma-sdk/ui-vue@1.20.21
-
-## 1.0.163
-
-### Patch Changes
-
-- Updated dependencies [4208dcf]
-  - @platforma-sdk/ui-vue@1.20.19
-
-## 1.0.162
-
-### Patch Changes
-
-- Updated dependencies [e654872]
-  - @platforma-sdk/ui-vue@1.20.17
-
-## 1.0.161
-
-### Patch Changes
-
-- Updated dependencies [52b19cf]
-  - @platforma-sdk/ui-vue@1.20.16
-
-## 1.0.160
-
-### Patch Changes
-
-- Updated dependencies [7f72aa4]
-  - @platforma-sdk/ui-vue@1.20.15
-
-## 1.0.159
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.20.14
-
-## 1.0.158
-
-### Patch Changes
-
-- Updated dependencies [cc58398]
-  - @platforma-sdk/ui-vue@1.20.13
-
-## 1.0.157
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.38
-- @platforma-sdk/ui-vue@1.20.11
-
-## 1.0.156
-
-### Patch Changes
-
-- Updated dependencies [29c0b22]
-  - @platforma-sdk/ui-vue@1.20.10
-
-## 1.0.155
-
-### Patch Changes
-
-- Updated dependencies [69b15fe]
-  - @platforma-sdk/ui-vue@1.20.9
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.37
-
-## 1.0.154
-
-### Patch Changes
-
-- Updated dependencies [4360a85]
-  - @platforma-sdk/ui-vue@1.20.7
-
-## 1.0.153
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/ui-vue@1.20.6
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.37
-
-## 1.0.152
-
-### Patch Changes
-
-- Updated dependencies [c74f56a]
-  - @platforma-sdk/ui-vue@1.20.5
-
-## 1.0.151
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.20.4
-
-## 1.0.150
-
-### Patch Changes
-
-- Updated dependencies [b017f36]
-  - @platforma-sdk/ui-vue@1.20.2
-
-## 1.0.149
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/ui-vue@1.20.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.36
-
-## 1.0.148
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.35
-- @platforma-sdk/ui-vue@1.19.0
-
-## 1.0.147
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.7
-
-## 1.0.146
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.6
-
-## 1.0.145
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.5
-
-## 1.0.144
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.3
-
-## 1.0.143
-
-### Patch Changes
-
-- Updated dependencies [e1d8a3b]
-  - @platforma-sdk/ui-vue@1.18.2
-
-## 1.0.142
-
-### Patch Changes
-
-- Updated dependencies [8022606]
-  - @platforma-sdk/ui-vue@1.18.1
-
-## 1.0.141
-
-### Patch Changes
-
-- Updated dependencies [6efea3d]
-  - @platforma-sdk/ui-vue@1.18.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.34
-
-## 1.0.140
-
-### Patch Changes
-
-- Updated dependencies [994ea52]
-  - @platforma-sdk/ui-vue@1.17.5
-
-## 1.0.139
-
-### Patch Changes
-
-- Updated dependencies [ec69dca]
-  - @platforma-sdk/ui-vue@1.17.3
-
-## 1.0.138
-
-### Patch Changes
-
-- Updated dependencies [ec3bffe]
-  - @platforma-sdk/ui-vue@1.17.2
-
-## 1.0.137
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.33
-- @platforma-sdk/ui-vue@1.17.0
-
-## 1.0.136
-
-### Patch Changes
-
-- Updated dependencies [ca9bf5b]
-  - @platforma-sdk/ui-vue@1.16.0
-
-## 1.0.135
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.32
-- @platforma-sdk/ui-vue@1.15.4
-
-## 1.0.134
-
-### Patch Changes
-
-- Updated dependencies [f38f686]
-  - @platforma-sdk/ui-vue@1.15.1
-
-## 1.0.133
-
-### Patch Changes
-
-- b4081fc: [sdk/ui-vue] Deprecate everything that should be deprecated
-- Updated dependencies [b4081fc]
-  - @platforma-sdk/ui-vue@1.15.0
-
-## 1.0.132
-
-### Patch Changes
-
-- Updated dependencies [7eadcd3]
-  - @platforma-sdk/ui-vue@1.14.22
-
-## 1.0.131
-
-### Patch Changes
-
-- Updated dependencies [bc6141f]
-  - @platforma-sdk/ui-vue@1.14.21
-
-## 1.0.130
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.20
-
-## 1.0.129
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.19
-
-## 1.0.128
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.18
-
-## 1.0.127
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.15
-
-## 1.0.126
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.11
-
-## 1.0.125
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.8
-
-## 1.0.124
-
-### Patch Changes
-
-- 8644e62: move from block-components -> blocks for nicer structure
-- Updated dependencies [8644e62]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.31
-
-## 1.0.123
-
-### Patch Changes
-
-- Updated dependencies [0cfb225]
-  - @platforma-sdk/ui-vue@1.14.5
-
-## 1.0.122
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
-- Updated dependencies [3dd3a5c]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.30
-
-## 1.0.121
-
-### Patch Changes
-
-- Updated dependencies [5884403]
-  - @platforma-sdk/ui-vue@1.14.2
-
-## 1.0.120
-
-### Patch Changes
-
-- Updated dependencies [a886400]
-  - @platforma-sdk/ui-vue@1.14.1
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.29
-
-## 1.0.119
-
-### Patch Changes
-
-- Updated dependencies [dfad2d0]
-  - @platforma-sdk/ui-vue@1.14.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.28
-
-## 1.0.118
-
-### Patch Changes
-
-- Updated dependencies [a85e3f7]
-  - @platforma-sdk/ui-vue@1.13.18
-
-## 1.0.117
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.17
-
-## 1.0.116
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.27
-- @platforma-sdk/ui-vue@1.13.15
-
-## 1.0.115
-
-### Patch Changes
-
-- Updated dependencies [925afdd]
-  - @platforma-sdk/ui-vue@1.13.11
-
-## 1.0.114
-
-### Patch Changes
-
-- Updated dependencies [e3d4cd0]
-  - @platforma-sdk/ui-vue@1.13.10
-
-## 1.0.113
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.9
-
-## 1.0.112
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.8
-
-## 1.0.111
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.6
-
-## 1.0.110
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.26
-- @platforma-sdk/ui-vue@1.13.5
-
-## 1.0.109
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.4
-
-## 1.0.108
-
-### Patch Changes
-
-- Updated dependencies [0552637]
-  - @platforma-sdk/ui-vue@1.13.3
-
-## 1.0.107
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.13.2
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.25
-
-## 1.0.106
-
-### Patch Changes
-
-- Updated dependencies [3157ecd]
-  - @platforma-sdk/ui-vue@1.13.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.24
-
-## 1.0.105
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.23
-- @platforma-sdk/ui-vue@1.12.0
-
-## 1.0.104
-
-### Patch Changes
-
-- Updated dependencies [d60c614]
-  - @platforma-sdk/ui-vue@1.11.8
-
-## 1.0.103
-
-### Patch Changes
-
-- Updated dependencies [12c72ef]
-  - @platforma-sdk/ui-vue@1.11.7
-
-## 1.0.102
-
-### Patch Changes
-
-- Updated dependencies [9cd0c99]
-  - @platforma-sdk/ui-vue@1.11.6
-
-## 1.0.101
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.11.5
-
-## 1.0.100
-
-### Patch Changes
-
-- Updated dependencies [5086e90]
-  - @platforma-sdk/ui-vue@1.11.4
-
-## 1.0.99
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.11.3
-
-## 1.0.98
-
-### Patch Changes
-
-- Updated dependencies [4783725]
-  - @platforma-sdk/ui-vue@1.11.2
-
-## 1.0.97
-
-### Patch Changes
-
-- Updated dependencies [961b8b1]
-  - @platforma-sdk/ui-vue@1.11.1
-
-## 1.0.96
-
-### Patch Changes
-
-- Updated dependencies [680e8b8]
-  - @platforma-sdk/ui-vue@1.11.0
-
-## 1.0.95
-
-### Patch Changes
-
-- Updated dependencies [166c161]
-  - @platforma-sdk/ui-vue@1.10.18
-
-## 1.0.94
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.10.17
-
-## 1.0.93
-
-### Patch Changes
-
-- Updated dependencies [40fe1d4]
-  - @platforma-sdk/ui-vue@1.10.15
-
-## 1.0.92
-
-### Patch Changes
-
-- Updated dependencies [449209f]
-  - @platforma-sdk/ui-vue@1.10.13
-
-## 1.0.91
-
-### Patch Changes
-
-- Updated dependencies [ade3acf]
-  - @platforma-sdk/ui-vue@1.10.12
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.22
-
-## 1.0.90
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.10.11
-
-## 1.0.89
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.10.9
-
-## 1.0.88
-
-### Patch Changes
-
-- Updated dependencies [54b4409]
-  - @platforma-sdk/ui-vue@1.10.8
-
-## 1.0.87
-
-### Patch Changes
-
-- Updated dependencies [097b3d9]
-  - @platforma-sdk/ui-vue@1.10.5
-
-## 1.0.86
-
-### Patch Changes
-
-- Updated dependencies [83caf43]
-  - @platforma-sdk/ui-vue@1.10.4
-
-## 1.0.85
-
-### Patch Changes
-
-- Updated dependencies [8187ba2]
-  - @platforma-sdk/ui-vue@1.10.2
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.21
-
-## 1.0.84
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.20
-- @platforma-sdk/ui-vue@1.10.0
-
-## 1.0.83
-
-### Patch Changes
-
-- Updated dependencies [1f12f1a]
-  - @platforma-sdk/ui-vue@1.9.3
-
-## 1.0.82
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.19
-- @platforma-sdk/ui-vue@1.9.0
-
-## 1.0.81
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.26
-
-## 1.0.80
-
-### Patch Changes
-
-- Updated dependencies [3c16beb]
-  - @platforma-sdk/ui-vue@1.8.25
-
-## 1.0.79
-
-### Patch Changes
-
-- Updated dependencies [d85c758]
-  - @platforma-sdk/ui-vue@1.8.24
-
-## 1.0.78
-
-### Patch Changes
-
-- Updated dependencies [0382abe]
-- Updated dependencies [0382abe]
-  - @platforma-sdk/ui-vue@1.8.23
-
-## 1.0.77
-
-### Patch Changes
-
-- Updated dependencies [6e54327]
-  - @platforma-sdk/ui-vue@1.8.21
-
-## 1.0.76
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.20
-
-## 1.0.75
-
-### Patch Changes
-
-- Updated dependencies [8f916f2]
-  - @platforma-sdk/ui-vue@1.8.19
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.18
-
-## 1.0.74
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.18
-
-## 1.0.73
-
-### Patch Changes
-
-- Updated dependencies [64f98c6]
-  - @platforma-sdk/ui-vue@1.8.17
-
-## 1.0.72
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.14
-
-## 1.0.71
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.11
-
-## 1.0.70
-
-### Patch Changes
-
-- Updated dependencies [f04b8da]
-  - @platforma-sdk/ui-vue@1.8.7
-
-## 1.0.69
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.6
-
-## 1.0.68
-
-### Patch Changes
-
-- Updated dependencies [5df9d1a]
-  - @platforma-sdk/ui-vue@1.8.2
-
-## 1.0.67
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.8.1
-
-## 1.0.66
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.17
-- @platforma-sdk/ui-vue@1.8.0
-
-## 1.0.65
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.16
-- @platforma-sdk/ui-vue@1.7.53
-
-## 1.0.64
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.51
-
-## 1.0.63
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.50
-
-## 1.0.62
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.49
-
-## 1.0.61
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.46
-
-## 1.0.60
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.45
-
-## 1.0.59
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.44
-
-## 1.0.58
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.42
-
-## 1.0.57
-
-### Patch Changes
-
-- Updated dependencies [1e896c8]
-  - @platforma-sdk/ui-vue@1.7.41
-
-## 1.0.56
-
-### Patch Changes
-
-- Updated dependencies [f341244]
-  - @platforma-sdk/ui-vue@1.7.40
-
-## 1.0.55
-
-### Patch Changes
-
-- Updated dependencies [d6909bf]
-  - @platforma-sdk/ui-vue@1.7.37
-
-## 1.0.54
-
-### Patch Changes
-
-- Updated dependencies [50f7459]
-  - @platforma-sdk/ui-vue@1.7.36
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.15
-
-## 1.0.53
-
-### Patch Changes
-
-- Updated dependencies [478dc27]
-  - @platforma-sdk/ui-vue@1.7.35
-
-## 1.0.52
-
-### Patch Changes
-
-- eddcfed: Add Errors page to ui-examples
-- Updated dependencies [eddcfed]
-  - @platforma-sdk/ui-vue@1.7.34
-
-## 1.0.51
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.32
-
-## 1.0.50
-
-### Patch Changes
-
-- a0854a3: Small common ui fixes
-- Updated dependencies [a0854a3]
-- Updated dependencies [e62ed59]
-  - @platforma-sdk/ui-vue@1.7.31
-
-## 1.0.49
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.30
-
-## 1.0.48
-
-### Patch Changes
-
-- Updated dependencies [812ba42]
-  - @platforma-sdk/ui-vue@1.7.27
-
-## 1.0.47
-
-### Patch Changes
-
-- Updated dependencies [bc5e60e]
-  - @platforma-sdk/ui-vue@1.7.26
-
-## 1.0.46
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.25
-
-## 1.0.45
-
-### Patch Changes
-
-- Updated dependencies [3276b87]
-  - @platforma-sdk/ui-vue@1.7.24
-
-## 1.0.44
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.22
-
-## 1.0.43
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.21
-
-## 1.0.42
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.20
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.15
-
-## 1.0.41
-
-### Patch Changes
-
-- Updated dependencies [072c49d]
-  - @platforma-sdk/ui-vue@1.7.18
-
-## 1.0.40
-
-### Patch Changes
-
-- Updated dependencies [8ae398f]
-  - @platforma-sdk/ui-vue@1.7.17
-
-## 1.0.39
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.14
-- @platforma-sdk/ui-vue@1.7.16
-
-## 1.0.38
-
-### Patch Changes
-
-- Updated dependencies [57c64c8]
-  - @platforma-sdk/ui-vue@1.7.13
-
-## 1.0.37
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.12
-
-## 1.0.36
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.9
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.13
-
-## 1.0.35
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.8
-
-## 1.0.34
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.7
-
-## 1.0.33
-
-### Patch Changes
-
-- Updated dependencies [a259c1d]
-- Updated dependencies [f782eea]
-  - @platforma-sdk/ui-vue@1.7.6
-
-## 1.0.32
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.7.3
-
-## 1.0.31
-
-### Patch Changes
-
-- Updated dependencies [8c34a07]
-  - @platforma-sdk/ui-vue@1.7.2
-
-## 1.0.30
-
-### Patch Changes
-
-- Updated dependencies [50245bd]
-  - @platforma-sdk/ui-vue@1.7.1
-
-## 1.0.29
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.12
-- @platforma-sdk/ui-vue@1.7.0
-
-## 1.0.28
-
-### Patch Changes
-
-- Updated dependencies [eb079e9]
-  - @platforma-sdk/ui-vue@1.6.0
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.11
-
-## 1.0.27
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.5.57
-
-## 1.0.26
-
-### Patch Changes
-
-- Updated dependencies [60e38dc]
-  - @platforma-sdk/ui-vue@1.5.56
-
-## 1.0.25
-
-### Patch Changes
-
-- Updated dependencies [4628369]
-  - @platforma-sdk/ui-vue@1.5.42
-
-## 1.0.24
-
-### Patch Changes
-
-- Updated dependencies [13013ee]
-  - @platforma-sdk/ui-vue@1.5.40
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.10
-
-## 1.0.23
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.5.38
-
-## 1.0.22
-
-### Patch Changes
-
-- bc6d116: app.model final version
-- Updated dependencies [bc6d116]
-  - @platforma-sdk/ui-vue@1.5.0
-
-## 1.0.21
-
-### Patch Changes
-
-- cfb6385: more effective createModel
-- Updated dependencies [cfb6385]
-- Updated dependencies [43efc40]
-  - @platforma-sdk/ui-vue@1.4.9
-
-## 1.0.20
-
-### Patch Changes
-
-- Updated dependencies [407e16c]
-  - @platforma-sdk/ui-vue@1.4.8
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.9
-
-## 1.0.19
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.9
-- @platforma-sdk/ui-vue@1.4.7
-
-## 1.0.18
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.8
-- @platforma-sdk/ui-vue@1.4.6
-
-## 1.0.17
-
-### Patch Changes
-
-- 7a12b39: Add useWatchFetch usable
-- Updated dependencies [7a12b39]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.7
-  - @platforma-sdk/ui-vue@1.4.5
-
-## 1.0.16
-
-### Patch Changes
-
-- Updated dependencies [9ea877e]
-  - @platforma-sdk/ui-vue@1.4.4
-
-## 1.0.15
-
-### Patch Changes
-
-- Updated dependencies [ae39723]
-  - @platforma-sdk/ui-vue@1.4.3
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [8db877c]
-  - @platforma-sdk/ui-vue@1.4.2
-
-## 1.0.13
-
-### Patch Changes
-
-- Updated dependencies [21a9b9c]
-- Updated dependencies [c9d051f]
-  - @platforma-sdk/ui-vue@1.4.1
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.6
-
-## 1.0.12
-
-### Patch Changes
-
-- 6495dcc: add default app model (initial version)
-- Updated dependencies [6495dcc]
-  - @platforma-sdk/ui-vue@1.4.0
-
-## 1.0.11
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.3.19
-
-## 1.0.10
-
-### Patch Changes
-
-- c549960: fix test enter-numbers wf
-- Updated dependencies [c549960]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.5
-
-## 1.0.9
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.4
-- @platforma-sdk/ui-vue@1.3.18
-
-## 1.0.8
-
-### Patch Changes
-
-- Updated dependencies [23aef61]
-  - @platforma-sdk/ui-vue@1.3.17
-
-## 1.0.7
-
-### Patch Changes
-
-- 60223f4: Update example blocks, fix h1-h6 colors in uikit
-  - @platforma-sdk/ui-vue@1.3.16
-
-## 1.0.6
-
-### Patch Changes
-
-- aff132f: Create ui-examples block, add PlSlideModal example
-- 583c929: add env injection example
-- Updated dependencies [583c929]
-  - @platforma-sdk/ui-vue@1.3.15
-
-## 1.0.5
-
-### Patch Changes
-
-- 156a72d: Add PlLogView component
-  - @platforma-sdk/ui-vue@1.3.14
-
-## 1.0.4
-
-### Patch Changes
-
-- 4fe1674: add basic ui to test-enter-numbers block
-- Updated dependencies [4fe1674]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.4
-  - @platforma-sdk/ui-vue@1.3.13
-
-## 1.0.3
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.3
-
-## 1.0.2
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-enter-numbers.model@1.0.2
-
-## 1.0.1
-
-### Patch Changes
-
-- 81aa0c7: initial commit of first test block transferred to monorepo
-- Updated dependencies [81aa0c7]
-  - @milaboratories/milaboratories.test-enter-numbers.model@1.0.1
diff --git a/etc/blocks/enter-numbers/ui/package.json b/etc/blocks/enter-numbers/ui/package.json
index 167ebc3c7e..c27b3115f3 100644
--- a/etc/blocks/enter-numbers/ui/package.json
+++ b/etc/blocks/enter-numbers/ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-enter-numbers.ui",
-  "version": "1.0.239",
+  "version": "1.0.0",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/etc/blocks/enter-numbers/ui/src/MainPage.vue b/etc/blocks/enter-numbers/ui/src/MainPage.vue
index 4485dd2386..2393653ce7 100644
--- a/etc/blocks/enter-numbers/ui/src/MainPage.vue
+++ b/etc/blocks/enter-numbers/ui/src/MainPage.vue
@@ -1,5 +1,11 @@
 <script setup lang="ts">
-import { PlAlert, PlBlockPage, PlTextField, useWatchFetch } from "@platforma-sdk/ui-vue";
+import {
+  PlAlert,
+  PlBlockPage,
+  PlTextField,
+  PlBtnPrimary,
+  useWatchFetch,
+} from "@platforma-sdk/ui-vue";
 import { useApp } from "./app";
 import { computed } from "vue";
 import { delay } from "@milaboratories/helpers";
@@ -8,12 +14,16 @@ const app = useApp();
 
 const numbers = computed({
   get() {
-    return app.model.args.numbers.join(",");
+    try {
+      return app.model.data.numbers.join(",");
+    } catch (error) {
+      return "error: " + error;
+    }
   },
   set(v) {
     const numbers = v.split(",").map(Number);
 
-    app.model.args.numbers = v
+    app.model.data.numbers = v
       .split(",")
       .map((v) => v.trim())
       .filter((v) => v !== "")
@@ -38,35 +48,38 @@ const resultRef = useWatchFetch(
     return fetchTestResult(sumNumbers(numbers));
   },
 );
+
+const helperText = computed(() => {
+  return `Even numbers count: ${app.model.outputs.numbersCount}`;
+});
 </script>
 
 <template>
   <PlBlockPage style="max-width: 100%">
-    <PlTextField v-model:model-value="numbers" label="Enter numbers (as comma-separated string)" />
+    <PlTextField
+      v-model:model-value="numbers"
+      label="Enter numbers (as comma-separated string)"
+      :helper="helperText"
+    />
     <PlAlert v-if="app.error" type="error">
       {{ app.error }}
     </PlAlert>
     <fieldset>
-      <legend>Args (app.snapshot.args)</legend>
-      {{ app.snapshot.args }}
-    </fieldset>
-    <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>app.model</legend>
+      {{ app.model }}
     </fieldset>
     <fieldset>
-      <legend>Args (app.snapshot.args deprecated)</legend>
-      ----
+      <legend>Block Storage (app.snapshot.blockStorage)</legend>
+      {{ app.snapshot.blockStorage }}
     </fieldset>
-    <h3>app.model</h3>
-    <code>{{ app.model }}</code>
     <h4>Result ref</h4>
     <code>{{ resultRef }}</code>
-    <PlAlert label="app.model.outputs!!!" type="info" white-space-pre monospace>{{
+    <PlAlert label="app.model.outputs" type="info" white-space-pre monospace>{{
       JSON.stringify(app.model.outputs, null, 2)
     }}</PlAlert>
     <PlAlert v-if="app.hasErrors" type="error">
       {{ app.model.outputErrors }}
     </PlAlert>
+    <PlBtnPrimary v-if="app.error" @click="app.revert">Revert changes</PlBtnPrimary>
   </PlBlockPage>
 </template>
diff --git a/etc/blocks/enter-numbers/ui/src/app.ts b/etc/blocks/enter-numbers/ui/src/app.ts
index 9de1cc9db6..4614fb9ea7 100644
--- a/etc/blocks/enter-numbers/ui/src/app.ts
+++ b/etc/blocks/enter-numbers/ui/src/app.ts
@@ -1,14 +1,13 @@
 import { platforma } from "@milaboratories/milaboratories.test-enter-numbers.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3, ensureError } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive, ref } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
-import { ensureError } from "@platforma-sdk/ui-vue";
 
-export const sdkPlugin = defineApp(
+export const sdkPlugin = defineAppV3(
   platforma,
-  (base) => {
+  () => {
     // Additional data
     const data = reactive({
       counter: 0,
@@ -20,15 +19,19 @@ export const sdkPlugin = defineApp(
       data.counter++;
     }
 
-    const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+    const stateAsJson = computed(() => "not implemented");
 
     return {
       data,
+      error,
       incrementCounter,
-      argsAsJson,
+      stateAsJson,
       setError(e: unknown) {
         error.value = ensureError(e).message;
       },
+      revert() {
+        alert("revert: not implemented");
+      },
       routes: {
         "/": () => MainPage,
       },
@@ -44,7 +47,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["stateAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/etc/blocks/enter-numbers/workflow/CHANGELOG.md b/etc/blocks/enter-numbers/workflow/CHANGELOG.md
index 652c157cf0..af9699abc1 100644
--- a/etc/blocks/enter-numbers/workflow/CHANGELOG.md
+++ b/etc/blocks/enter-numbers/workflow/CHANGELOG.md
@@ -1,124 +1 @@
 # @milaboratories/milaboratories.test-enter-numbers.workflow
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/workflow-tengo@4.0.4
-
-## 1.0.17
-
-### Patch Changes
-
-- Updated dependencies [c021ce8]
-  - @platforma-sdk/workflow-tengo@4.0.3
-
-## 1.0.16
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/workflow-tengo@4.0.2
-
-## 1.0.15
-
-### Patch Changes
-
-- Updated dependencies [1564354]
-  - @platforma-sdk/workflow-tengo@4.0.1
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [8b4a614]
-  - @platforma-sdk/workflow-tengo@4.0.0
-
-## 1.0.13
-
-### Patch Changes
-
-- Updated dependencies [68809d4]
-  - @platforma-sdk/workflow-tengo@3.3.0
-
-## 1.0.12
-
-### Patch Changes
-
-- Updated dependencies [d8a33ab]
-  - @platforma-sdk/workflow-tengo@3.2.1
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [cd57569]
-  - @platforma-sdk/workflow-tengo@3.2.0
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [f0f6a8b]
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/workflow-tengo@3.1.0
-
-## 1.0.9
-
-### Patch Changes
-
-- Updated dependencies [4a604e7]
-  - @platforma-sdk/workflow-tengo@3.0.3
-
-## 1.0.8
-
-### Patch Changes
-
-- Updated dependencies [4b04041]
-  - @platforma-sdk/workflow-tengo@3.0.2
-
-## 1.0.7
-
-### Patch Changes
-
-- Updated dependencies [fb5a9ff]
-  - @platforma-sdk/workflow-tengo@3.0.1
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [7034617]
-  - @platforma-sdk/workflow-tengo@3.0.0
-
-## 1.0.5
-
-### Patch Changes
-
-- Updated dependencies [af43efe]
-  - @platforma-sdk/workflow-tengo@2.16.1
-
-## 1.0.4
-
-### Patch Changes
-
-- 8644e62: move from block-components -> blocks for nicer structure
-
-## 1.0.3
-
-### Patch Changes
-
-- 7a12b39: Add useWatchFetch usable
-
-## 1.0.2
-
-### Patch Changes
-
-- c549960: fix test enter-numbers wf
-
-## 1.0.1
-
-### Patch Changes
-
-- 81aa0c7: initial commit of first test block transferred to monorepo
diff --git a/etc/blocks/enter-numbers/workflow/package.json b/etc/blocks/enter-numbers/workflow/package.json
index 7fd51fc014..88a6ed6bb2 100644
--- a/etc/blocks/enter-numbers/workflow/package.json
+++ b/etc/blocks/enter-numbers/workflow/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-enter-numbers.workflow",
-  "version": "1.0.18",
+  "version": "1.0.0",
   "private": true,
   "description": "Tengo-based template",
   "type": "module",
diff --git a/etc/blocks/enter-numbers/workflow/src/numbers.lib.tengo b/etc/blocks/enter-numbers/workflow/src/numbers.lib.tengo
index fd4dbb465c..bae5dec382 100644
--- a/etc/blocks/enter-numbers/workflow/src/numbers.lib.tengo
+++ b/etc/blocks/enter-numbers/workflow/src/numbers.lib.tengo
@@ -22,14 +22,10 @@ createJsonPColumnData := func(data) {
 
 body := func(args, blockId) {
 	numbersMap := {}
-
-	for i, v in args.numbers {
-		numbersMap[string(i)] = v
-	}
-
 	numbers := []
 
 	for i, v in args.numbers {
+		numbersMap[string(i)] = v
 		numbers = append(numbers, v)
 	}
 
diff --git a/etc/blocks/enter-numbers/workflow/src/prerun.tpl.tengo b/etc/blocks/enter-numbers/workflow/src/prerun.tpl.tengo
index f511cc809d..6e82c2716b 100644
--- a/etc/blocks/enter-numbers/workflow/src/prerun.tpl.tengo
+++ b/etc/blocks/enter-numbers/workflow/src/prerun.tpl.tengo
@@ -1,6 +1,20 @@
 wf := import("@platforma-sdk/workflow-tengo:workflow")
-numbers := import(":numbers")
+smart := import("@platforma-sdk/workflow-tengo:smart")
 
 wf.body(func(args) {
-	return numbers.getNumbers(args, wf.blockId().getDataAsJson())
+	// Count the number of even numbers
+	numbersCount := 0
+	if !is_undefined(args.evenNumbers) {
+		numbersCount = len(args.evenNumbers)
+	}
+
+	return {
+		outputs: {
+			numbersCount: smart.createJsonResource(numbersCount),
+			evenNumbers: smart.createJsonResource(args.evenNumbers),
+			// Store args directly as object, not as JSON string
+			prerunArgsJson: smart.createJsonResource(args)
+		},
+		exports: {}
+	}
 })
diff --git a/etc/blocks/filter-column-test/.structure b/etc/blocks/filter-column-test/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/filter-column-test/.structure
+++ b/etc/blocks/filter-column-test/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/filter-column-test/block/package.json b/etc/blocks/filter-column-test/block/package.json
index ce6d210d19..c4b1209921 100644
--- a/etc/blocks/filter-column-test/block/package.json
+++ b/etc/blocks/filter-column-test/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-filter-column.kind": "workspace:*",
     "@milaboratories/milaboratories.test-filter-column.model": "workspace:*",
     "@milaboratories/milaboratories.test-filter-column.ui": "workspace:*",
     "@milaboratories/milaboratories.test-filter-column.workflow": "workspace:*",
diff --git a/etc/blocks/filter-column-test/kind/.oxfmtrc.json b/etc/blocks/filter-column-test/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/filter-column-test/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/sum-numbers-v3/model/.oxlintrc.json b/etc/blocks/filter-column-test/kind/.oxlintrc.json
similarity index 69%
rename from etc/blocks/sum-numbers-v3/model/.oxlintrc.json
rename to etc/blocks/filter-column-test/kind/.oxlintrc.json
index 70ab6b8dc2..b1a139038f 100644
--- a/etc/blocks/sum-numbers-v3/model/.oxlintrc.json
+++ b/etc/blocks/filter-column-test/kind/.oxlintrc.json
@@ -1,3 +1,3 @@
 {
-  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-block-model.json"]
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
 }
diff --git a/etc/blocks/filter-column-test/kind/package.json b/etc/blocks/filter-column-test/kind/package.json
new file mode 100644
index 0000000000..729bf4e127
--- /dev/null
+++ b/etc/blocks/filter-column-test/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-filter-column.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the filter-column-test block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/filter-column-test/kind/src/index.ts b/etc/blocks/filter-column-test/kind/src/index.ts
new file mode 100644
index 0000000000..174e2a6df0
--- /dev/null
+++ b/etc/blocks/filter-column-test/kind/src/index.ts
@@ -0,0 +1,30 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the filter-column-test block — deliberately empty.
+ *
+ * The block's `BlockData` is a single field, `dataset`, and it is not
+ * author-supplied at creation: this fixture exists to exercise
+ * `PlDatasetSelector` + `PrimaryRef` + enrichment resolution end-to-end, so the
+ * selection is always made in the UI (or by a test driving `update-block-data`).
+ * Nothing a creator or a project template would seed, hence no init params.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/filter-column-test/kind/tsconfig.json b/etc/blocks/filter-column-test/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/filter-column-test/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/filter-column-test/model/package.json b/etc/blocks/filter-column-test/model/package.json
index 1d91d2c809..ef9db8dedf 100644
--- a/etc/blocks/filter-column-test/model/package.json
+++ b/etc/blocks/filter-column-test/model/package.json
@@ -25,6 +25,7 @@
     "fmt": "ts-builder format"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-filter-column.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/filter-column-test/model/src/index.ts b/etc/blocks/filter-column-test/model/src/index.ts
index 9b5e5d8d04..815940b3bf 100644
--- a/etc/blocks/filter-column-test/model/src/index.ts
+++ b/etc/blocks/filter-column-test/model/src/index.ts
@@ -7,6 +7,7 @@ import type {
   PrimaryRef,
 } from "@platforma-sdk/model";
 import { BlockModelV3, DataModelBuilder, buildDatasetOptions } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-filter-column.kind";
 import { z } from "zod";
 
 export const BlockData = z.object({
@@ -15,13 +16,15 @@ export const BlockData = z.object({
 
 export type BlockData = z.infer<typeof BlockData>;
 
-const dataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({}));
+// The kind declares no init params — `dataset` is always picked in the UI — so
+// `init` takes no `params` and a fresh block starts with an unset selection.
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(() => ({}));
 
 const PRIMARY_NAMES = new Set(["value", "description"]);
 const isPrimaryColumn = (spec: PObjectSpec): boolean =>
   spec.kind === "PColumn" && PRIMARY_NAMES.has(spec.name);
 
-export const platforma = BlockModelV3.create(dataModel)
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
   .args<{ dataset: PrimaryRef; enrichments: LabeledEnrichmentRefs }>((data) => {
     if (data.dataset === undefined) throw new Error("Select a dataset");
@@ -31,6 +34,10 @@ export const platforma = BlockModelV3.create(dataModel)
     };
   })
 
+  // Nothing to project: the kind takes no params. This fixture exists to exercise
+  // dataset selection end-to-end, so the selection is always made in the UI.
+  .templateParams(() => ({}))
+
   .output("datasetOptions", (ctx) =>
     buildDatasetOptions(ctx, { primary: isPrimaryColumn, withEnrichments: () => true }),
   )
diff --git a/etc/blocks/filter-column-test/test/package.json b/etc/blocks/filter-column-test/test/package.json
index ae155c830d..6381125c56 100644
--- a/etc/blocks/filter-column-test/test/package.json
+++ b/etc/blocks/filter-column-test/test/package.json
@@ -16,8 +16,8 @@
   },
   "dependencies": {
     "@milaboratories/milaboratories.test-block-table": "workspace:*",
-    "@milaboratories/milaboratories.test-enter-numbers-v3": "workspace:*",
-    "@milaboratories/milaboratories.test-enter-numbers-v3.model": "workspace:*",
+    "@milaboratories/milaboratories.test-enter-numbers": "workspace:*",
+    "@milaboratories/milaboratories.test-enter-numbers.model": "workspace:*",
     "@milaboratories/milaboratories.test-filter-column.model": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "this-block": "workspace:@milaboratories/milaboratories.test-filter-column@*"
diff --git a/etc/blocks/model-test/.structure b/etc/blocks/model-test/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/model-test/.structure
+++ b/etc/blocks/model-test/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/model-test/block/package.json b/etc/blocks/model-test/block/package.json
index 26b431d935..8bbe07c842 100644
--- a/etc/blocks/model-test/block/package.json
+++ b/etc/blocks/model-test/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-block-model.kind": "workspace:*",
     "@milaboratories/milaboratories.test-block-model.model": "workspace:*",
     "@milaboratories/milaboratories.test-block-model.ui": "workspace:*",
     "@milaboratories/milaboratories.test-block-model.workflow": "workspace:*",
diff --git a/etc/blocks/model-test/kind/.oxfmtrc.json b/etc/blocks/model-test/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/model-test/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/model-test/kind/.oxlintrc.json b/etc/blocks/model-test/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/model-test/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/model-test/kind/package.json b/etc/blocks/model-test/kind/package.json
new file mode 100644
index 0000000000..b30e0c5ab1
--- /dev/null
+++ b/etc/blocks/model-test/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-block-model.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the model-test block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/model-test/kind/src/index.ts b/etc/blocks/model-test/kind/src/index.ts
new file mode 100644
index 0000000000..abec41155f
--- /dev/null
+++ b/etc/blocks/model-test/kind/src/index.ts
@@ -0,0 +1,42 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the model-test block — what a creator or a project
+ * template supplies to seed a new instance. A subset of the model's `BlockData`:
+ * every author-supplied field is a param, while `tableState` is UI view state
+ * that always defaults. All optional, because a block may be created without a
+ * template.
+ */
+export type BlockParams = {
+  titleArg?: string;
+  subtitleArg?: string;
+  badgeArg?: string;
+  tagToWorkflow?: string;
+  tagArgs?: string[];
+};
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` matters most here, where five of the fields are near-synonyms: a file
+ * saying `titleArgs` or `tagArg` would otherwise be ignored key and all, the block would
+ * initialize blank, and nothing would say which of the five was misspelled.
+ */
+const Params = z
+  .object({
+    titleArg: z.string().optional(),
+    subtitleArg: z.string().optional(),
+    badgeArg: z.string().optional(),
+    tagToWorkflow: z.string().optional(),
+    tagArgs: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/model-test/kind/tsconfig.json b/etc/blocks/model-test/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/model-test/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/model-test/model/package.json b/etc/blocks/model-test/model/package.json
index 0fc687a91d..db527f11b3 100644
--- a/etc/blocks/model-test/model/package.json
+++ b/etc/blocks/model-test/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-block-model.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*"
   },
   "devDependencies": {
diff --git a/etc/blocks/model-test/model/src/index.ts b/etc/blocks/model-test/model/src/index.ts
index 5b97575c42..872c295b34 100644
--- a/etc/blocks/model-test/model/src/index.ts
+++ b/etc/blocks/model-test/model/src/index.ts
@@ -11,6 +11,7 @@ import {
   type InferOutputsType,
   type InferPluginNames,
 } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-block-model.kind";
 
 // =============================================================================
 // Block Data Model
@@ -25,12 +26,15 @@ export type BlockData = {
   tableState: PlDataTableStateV2;
 };
 
-const blockDataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({
-  titleArg: "The title",
-  subtitleArg: "The subtitle",
-  badgeArg: "The badge",
-  tagToWorkflow: "workflow-tag",
-  tagArgs: [],
+// Every field the kind declares as an init param is optional — a block may be
+// created without a template supplying them — so each keeps a fallback default.
+// `tableState` is UI view state: not a param, always freshly initialized.
+const blockDataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(({ params }) => ({
+  titleArg: params?.titleArg ?? "The title",
+  subtitleArg: params?.subtitleArg ?? "The subtitle",
+  badgeArg: params?.badgeArg ?? "The badge",
+  tagToWorkflow: params?.tagToWorkflow ?? "workflow-tag",
+  tagArgs: params?.tagArgs ?? [],
   tableState: createPlDataTableStateV2(),
 }));
 
@@ -99,9 +103,17 @@ export type CounterPlugin = typeof counterPlugin;
 
 const counter = counterPlugin.create({ pluginId: "counter", config: { defaultCount: 10 } });
 
-export const platforma = BlockModelV3.create(blockDataModel)
+export const platforma = BlockModelV3.create({ dataModel: blockDataModel, kind })
   .args<BlockArgs>((data) => data)
 
+  .templateParams((data) => ({
+    titleArg: data.titleArg,
+    subtitleArg: data.subtitleArg,
+    badgeArg: data.badgeArg,
+    tagToWorkflow: data.tagToWorkflow,
+    tagArgs: data.tagArgs,
+  }))
+
   .plugin(counter, {
     title: (ctx) => ctx.data.titleArg || "Test Counter",
   })
diff --git a/etc/blocks/monetization-test/.structure b/etc/blocks/monetization-test/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/monetization-test/.structure
+++ b/etc/blocks/monetization-test/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/monetization-test/block/package.json b/etc/blocks/monetization-test/block/package.json
index 5b36baa450..b372edf47b 100644
--- a/etc/blocks/monetization-test/block/package.json
+++ b/etc/blocks/monetization-test/block/package.json
@@ -24,6 +24,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.monetization-test.kind": "workspace:*",
     "@milaboratories/milaboratories.monetization-test.model": "workspace:*",
     "@milaboratories/milaboratories.monetization-test.ui": "workspace:*",
     "@milaboratories/milaboratories.monetization-test.workflow": "workspace:*",
diff --git a/etc/blocks/monetization-test/kind/.oxfmtrc.json b/etc/blocks/monetization-test/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/monetization-test/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/monetization-test/kind/.oxlintrc.json b/etc/blocks/monetization-test/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/monetization-test/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/monetization-test/kind/package.json b/etc/blocks/monetization-test/kind/package.json
new file mode 100644
index 0000000000..3ced0498c0
--- /dev/null
+++ b/etc/blocks/monetization-test/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.monetization-test.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the monetization-test block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/monetization-test/kind/src/index.ts b/etc/blocks/monetization-test/kind/src/index.ts
new file mode 100644
index 0000000000..891d521ace
--- /dev/null
+++ b/etc/blocks/monetization-test/kind/src/index.ts
@@ -0,0 +1,30 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the monetization-test block — deliberately empty.
+ * Nothing in this block's `BlockData` is meaningfully author-supplied at
+ * creation: `inputHandles` carries desktop-signed `ImportFileHandle`s that only
+ * a real OS file-dialog gesture can produce, `productKey` and
+ * `shouldAddRunPerFile` are fixture knobs the tester flips in the UI, and
+ * `__mnzDate` / `__mnzCanRun` are owned by the SDK's monetization plugin. So
+ * `init` ignores params and returns the fixture defaults.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/monetization-test/kind/tsconfig.json b/etc/blocks/monetization-test/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/monetization-test/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/monetization-test/model/package.json b/etc/blocks/monetization-test/model/package.json
index 1dbaa6a9ab..dbc6b4ee6d 100644
--- a/etc/blocks/monetization-test/model/package.json
+++ b/etc/blocks/monetization-test/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.monetization-test.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*"
   },
   "devDependencies": {
diff --git a/etc/blocks/monetization-test/model/src/index.ts b/etc/blocks/monetization-test/model/src/index.ts
index 7c7fc4ada9..110ac06aa6 100644
--- a/etc/blocks/monetization-test/model/src/index.ts
+++ b/etc/blocks/monetization-test/model/src/index.ts
@@ -1,5 +1,6 @@
-import type { ImportFileHandle, InferOutputsType } from "@platforma-sdk/model";
-import { BlockModel } from "@platforma-sdk/model";
+import type { ImportFileHandle, InferHrefType, InferOutputsType } from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.monetization-test.kind";
 
 export type Handle = {
   handle: ImportFileHandle | undefined;
@@ -8,28 +9,79 @@ export type Handle = {
   options: string[];
 };
 
-export type BlockArgs = {
+export type BlockData = {
   productKey: string;
   inputHandles: Handle[];
   shouldAddRunPerFile: boolean;
+  /**
+   * Both `__mnz*` fields are written by the SDK's monetization plugin
+   * (`sdk/ui-vue/src/plugins/Monetization/useInfo.ts`) straight into
+   * `app.model.data` by literal key, so they must stay top-level here.
+   *
+   * `__mnzDate` is re-stamped every 60s to refresh the monetization info, and
+   * `__mnzCanRun` mirrors the `canRun` verdict that info carries.
+   */
   __mnzDate: string;
   __mnzCanRun: boolean;
 };
 
-export const model = BlockModel.create()
-  .withArgs<BlockArgs>({
-    // a fake product key so our mnz client response with a fake response without changing prod db.
-    productKey: "PRODUCT:XTOKAYPLQDZWSPPUTFNHPAJQQZKKSPTCDOORHFJIOYICTRDA",
-    inputHandles: [],
-    shouldAddRunPerFile: false,
-    __mnzDate: new Date().toISOString(), // It's OK
-    __mnzCanRun: false,
-  })
+/** What the main workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  productKey: string;
+  inputHandles: Handle[];
+  shouldAddRunPerFile: boolean;
+};
+
+/** What the pre-run consumes: the same inputs plus the monetization timestamp. */
+export type BlockPrerunArgs = BlockArgs & {
+  __mnzDate: string;
+};
+
+// The kind declares no init params, so `init` ignores them and returns the
+// fixture defaults.
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(() => ({
+  // a fake product key so our mnz client response with a fake response without changing prod db.
+  productKey: "PRODUCT:XTOKAYPLQDZWSPPUTFNHPAJQQZKKSPTCDOORHFJIOYICTRDA",
+  inputHandles: [],
+  shouldAddRunPerFile: false,
+  __mnzDate: new Date().toISOString(), // It's OK
+  __mnzCanRun: false,
+}));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
-  .argsValid((ctx) => {
-    return ctx.args.__mnzCanRun;
+  // `__mnzCanRun` gates the run (it replaces V1's `.argsValid`) but is not itself
+  // a workflow input, so it is read here and dropped. `__mnzDate` is dropped too:
+  // the main template never reads it, and leaving it in args would stale the
+  // block every minute when the monetization plugin re-stamps it.
+  .args<BlockArgs>((data) => {
+    if (!data.__mnzCanRun) throw new Error("Monetization does not allow this block to run");
+    return {
+      productKey: data.productKey,
+      inputHandles: data.inputHandles,
+      shouldAddRunPerFile: data.shouldAddRunPerFile,
+    };
   })
 
+  // Nothing to project: the kind takes no params. `inputHandles` are signed,
+  // session-local references; `productKey` and `shouldAddRunPerFile` are fixture knobs
+  // flipped in the UI; and the `__mnz*` fields belong to the monetization plugin.
+  .templateParams(() => ({}))
+
+  // Declaring this is mandatory, not an optimization. The pre-run is what
+  // produces `__mnzInfo`, which is what flips `__mnzCanRun` to true — so it has
+  // to keep running while `.args` is still throwing. Without an explicit
+  // `prerunArgs`, the runtime falls back to the args lambda and the block
+  // deadlocks: no pre-run, no info, no `canRun`, forever.
+  .prerunArgs(
+    (data): BlockPrerunArgs => ({
+      productKey: data.productKey,
+      inputHandles: data.inputHandles,
+      shouldAddRunPerFile: data.shouldAddRunPerFile,
+      __mnzDate: data.__mnzDate,
+    }),
+  )
+
   .output("__mnzInfo", (ctx) => ctx.prerun?.resolve("info")?.getDataAsJson<unknown>())
 
   .output("tokens", (ctx) =>
@@ -56,10 +108,9 @@ export const model = BlockModel.create()
     return Object.fromEntries(progresses ?? []) as Record<string, unknown>;
   })
 
-  .sections((_) => [{ type: "link", href: "/", label: "Main" }])
-
-  .done(2);
+  .sections((_ctx) => [{ type: "link", href: "/", label: "Main" }])
 
-export const platforma = model;
+  .done();
 
-export type BlockOutputs = InferOutputsType<typeof model>;
+export type BlockOutputs = InferOutputsType<typeof platforma>;
+export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/monetization-test/ui/src/app.ts b/etc/blocks/monetization-test/ui/src/app.ts
index b790937d9e..347c79f3f4 100644
--- a/etc/blocks/monetization-test/ui/src/app.ts
+++ b/etc/blocks/monetization-test/ui/src/app.ts
@@ -1,8 +1,8 @@
-import { model } from "@milaboratories/milaboratories.monetization-test.model";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { platforma } from "@milaboratories/milaboratories.monetization-test.model";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import MainPage from "./pages/MainPage.vue";
 
-export const sdkPlugin = defineApp(model, () => {
+export const sdkPlugin = defineAppV3(platforma, () => {
   return {
     routes: {
       "/": () => MainPage,
diff --git a/etc/blocks/monetization-test/ui/src/pages/MainPage.vue b/etc/blocks/monetization-test/ui/src/pages/MainPage.vue
index 1d59b4739e..e04021dad5 100644
--- a/etc/blocks/monetization-test/ui/src/pages/MainPage.vue
+++ b/etc/blocks/monetization-test/ui/src/pages/MainPage.vue
@@ -31,7 +31,7 @@ function onProductKeyInput(key: string) {
     key.startsWith(PRODUCT_KEY_PREFIX) &&
     key.length === PRODUCT_KEY_PREFIX.length + PRODUCT_KEY_LENGTH
   ) {
-    app.model.args.productKey = key.slice(PRODUCT_KEY_PREFIX.length);
+    app.model.data.productKey = key.slice(PRODUCT_KEY_PREFIX.length);
   }
 }
 
@@ -65,14 +65,14 @@ const files = reactive<{
 
 const updateHandle = (v: ImportFileHandle | undefined, i: number) => {
   if (v) {
-    app.model.args.inputHandles[i].handle = v;
+    app.model.data.inputHandles[i].handle = v;
   } else {
-    app.model.args.inputHandles.splice(i, 1);
+    app.model.data.inputHandles.splice(i, 1);
   }
 };
 
 const onImport = (imported: ImportedFiles) => {
-  app.model.args.inputHandles = imported.files.map((h, i) => ({
+  app.model.data.inputHandles = imported.files.map((h, i) => ({
     handle: h,
     fileName: getFileNameFromHandle(h),
     argName: `arg_${i}`,
@@ -134,12 +134,12 @@ const productOptions = [
     <PlRow>
       <PlContainer width="400px">
         <PlDropdown
-          v-model="app.model.args.productKey"
+          v-model="app.model.data.productKey"
           label="Select product"
           :options="productOptions"
         />
         <PlTextField
-          :model-value="app.model.args.productKey"
+          :model-value="app.model.data.productKey"
           label="or enter product key"
           clearable
           :validate="validateProductKey"
@@ -148,7 +148,7 @@ const productOptions = [
       </PlContainer>
     </PlRow>
 
-    <PlCheckbox v-model="app.model.args.shouldAddRunPerFile"> Add run per file </PlCheckbox>
+    <PlCheckbox v-model="app.model.data.shouldAddRunPerFile"> Add run per file </PlCheckbox>
 
     <PlRow width="400px">
       <PlBtnPrimary @click="files.isMultiDialogFileOpen = true">
@@ -158,16 +158,16 @@ const productOptions = [
         Show mnz info
       </PlBtnPrimary>
     </PlRow>
-    <template v-for="({ handle }, i) of app.model.args.inputHandles" :key="i">
+    <template v-for="({ handle }, i) of app.model.data.inputHandles" :key="i">
       <PlRow>
-        <PlTextField v-model="app.model.args.inputHandles[i].fileName" label="Type file name" />
-        <PlTextField v-model="app.model.args.inputHandles[i].argName" label="Type argument name" />
+        <PlTextField v-model="app.model.data.inputHandles[i].fileName" label="Type file name" />
+        <PlTextField v-model="app.model.data.inputHandles[i].argName" label="Type argument name" />
         <PlFileInput
           :model-value="handle"
           @update:model-value="(v: ImportFileHandle | undefined) => updateHandle(v, i)"
         />
         <PlDropdownMulti
-          v-model="app.model.args.inputHandles[i].options"
+          v-model="app.model.data.inputHandles[i].options"
           label="Metrics to monetize"
           :options="dropdownOptions"
         />
diff --git a/etc/blocks/pool-explorer/.structure b/etc/blocks/pool-explorer/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/pool-explorer/.structure
+++ b/etc/blocks/pool-explorer/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/pool-explorer/block/package.json b/etc/blocks/pool-explorer/block/package.json
index a126d7c3cf..4e87aaf836 100644
--- a/etc/blocks/pool-explorer/block/package.json
+++ b/etc/blocks/pool-explorer/block/package.json
@@ -24,6 +24,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.pool-explorer.kind": "workspace:*",
     "@milaboratories/milaboratories.pool-explorer.model": "workspace:*",
     "@milaboratories/milaboratories.pool-explorer.ui": "workspace:*",
     "@milaboratories/milaboratories.pool-explorer.workflow": "workspace:*",
diff --git a/etc/blocks/pool-explorer/kind/.oxfmtrc.json b/etc/blocks/pool-explorer/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/pool-explorer/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/pool-explorer/kind/.oxlintrc.json b/etc/blocks/pool-explorer/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/pool-explorer/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/pool-explorer/kind/package.json b/etc/blocks/pool-explorer/kind/package.json
new file mode 100644
index 0000000000..ddbfb77279
--- /dev/null
+++ b/etc/blocks/pool-explorer/kind/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "@milaboratories/milaboratories.pool-explorer.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the pool-explorer block",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch",
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/pool-explorer/kind/src/index.ts b/etc/blocks/pool-explorer/kind/src/index.ts
new file mode 100644
index 0000000000..f6dc87a532
--- /dev/null
+++ b/etc/blocks/pool-explorer/kind/src/index.ts
@@ -0,0 +1,29 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the pool-explorer block — deliberately empty.
+ *
+ * Pool Explorer is a result-pool diagnostic: it renders every spec the pool
+ * exposes and keeps its filter state local to the Vue component. There is
+ * nothing a creator or a project template configures at creation time, so
+ * `BlockData` carries no author-supplied fields and `init` takes no params.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/pool-explorer/kind/tsconfig.json b/etc/blocks/pool-explorer/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/pool-explorer/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/pool-explorer/model/package.json b/etc/blocks/pool-explorer/model/package.json
index 99c8d47496..f67b6c0f46 100644
--- a/etc/blocks/pool-explorer/model/package.json
+++ b/etc/blocks/pool-explorer/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.pool-explorer.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*"
   },
   "devDependencies": {
diff --git a/etc/blocks/pool-explorer/model/src/index.ts b/etc/blocks/pool-explorer/model/src/index.ts
index 0b21458ff8..615971651c 100644
--- a/etc/blocks/pool-explorer/model/src/index.ts
+++ b/etc/blocks/pool-explorer/model/src/index.ts
@@ -4,22 +4,26 @@ import {
   type InferHrefType,
   type InferOutputsType,
 } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.pool-explorer.kind";
 
-export type BlockData = {
-  titleArgs: string;
-};
+/**
+ * Pool Explorer persists nothing: the page renders whatever the result pool
+ * currently exposes, and its filter controls are local Vue state. The kind's
+ * `BlockParams` is empty for the same reason, so `init` takes no params.
+ */
+export type BlockData = Record<string, never>;
 
 export type BlockArgs = BlockData;
 
-const dataModel = new DataModelBuilder()
-  .from<BlockData>("v1")
-  .init(() => ({ titleArgs: "The title" }));
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(() => ({}));
 
-export const platforma = BlockModelV3.create(dataModel)
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
-  .args<BlockArgs>((data) => {
-    return { titleArgs: data.titleArgs };
-  })
+  .args<BlockArgs>(() => ({}))
+
+  // Nothing to project: this block is a result-pool diagnostic with no configuration
+  // of its own — its filter state lives in the Vue component, not in block data.
+  .templateParams(() => ({}))
 
   .output("allSpecs", (ctx) => ctx.resultPool.getSpecs())
 
diff --git a/etc/blocks/read-logs/.structure b/etc/blocks/read-logs/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/read-logs/.structure
+++ b/etc/blocks/read-logs/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/read-logs/block/package.json b/etc/blocks/read-logs/block/package.json
index 10eaad60e3..b972c63048 100644
--- a/etc/blocks/read-logs/block/package.json
+++ b/etc/blocks/read-logs/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-read-logs.kind": "workspace:*",
     "@milaboratories/milaboratories.test-read-logs.model": "workspace:*",
     "@milaboratories/milaboratories.test-read-logs.ui": "workspace:*",
     "@milaboratories/milaboratories.test-read-logs.workflow": "workspace:*",
diff --git a/etc/blocks/read-logs/kind/.oxfmtrc.json b/etc/blocks/read-logs/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/read-logs/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/read-logs/kind/.oxlintrc.json b/etc/blocks/read-logs/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/read-logs/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/read-logs/kind/package.json b/etc/blocks/read-logs/kind/package.json
new file mode 100644
index 0000000000..51bc9a29aa
--- /dev/null
+++ b/etc/blocks/read-logs/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-read-logs.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the read-logs block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/read-logs/kind/src/index.ts b/etc/blocks/read-logs/kind/src/index.ts
new file mode 100644
index 0000000000..8435f0105b
--- /dev/null
+++ b/etc/blocks/read-logs/kind/src/index.ts
@@ -0,0 +1,32 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the read-logs block — deliberately empty.
+ *
+ * The block's `BlockData` is two fields, and neither is something a creator or a
+ * project template could seed. `inputHandle` is a desktop-signed
+ * `ImportFileHandle` — a machine- and session-local reference produced by a real
+ * OS file-dialog gesture (see the upload flow), not serializable ahead of time.
+ * `readFileWithSleepArgs` is a fixture knob for the log-emitting test tool
+ * (prefix / line count / sleep), always driven from the UI or by a test. So this
+ * block takes no init params and `init` always returns the defaults.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/read-logs/kind/tsconfig.json b/etc/blocks/read-logs/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/read-logs/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/read-logs/model/package.json b/etc/blocks/read-logs/model/package.json
index 7ebb78077b..3792548549 100644
--- a/etc/blocks/read-logs/model/package.json
+++ b/etc/blocks/read-logs/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-read-logs.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/read-logs/model/src/index.ts b/etc/blocks/read-logs/model/src/index.ts
index 72c7a26170..673718e3cb 100644
--- a/etc/blocks/read-logs/model/src/index.ts
+++ b/etc/blocks/read-logs/model/src/index.ts
@@ -1,14 +1,6 @@
 import type { ImportFileHandle, InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import {
-  BlockModel,
-  getImportProgress,
-  getLastLogs,
-  getLogHandle,
-  getProgressLog,
-  getProgressLogWithInfo,
-  getResourceField,
-  MainOutputs,
-} from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-read-logs.kind";
 import { z } from "zod";
 
 export const ImportFileHandleSchema = z
@@ -18,36 +10,55 @@ export const ImportFileHandleSchema = z
     ((_a) => true) as (arg: string | undefined) => arg is ImportFileHandle | undefined,
   );
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   inputHandle: ImportFileHandleSchema,
   readFileWithSleepArgs: z.string(),
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+/** What the workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  inputHandle: ImportFileHandle | undefined;
+  readFileWithSleepArgs: string;
+};
 
-  .withArgs({
-    inputHandle: undefined,
-    readFileWithSleepArgs: "PREFIX,5,1000",
-  })
+// This block takes no init params (its kind declares `Record<string, never>`):
+// `inputHandle` is a desktop-signed `ImportFileHandle` no template can pre-wire,
+// and `readFileWithSleepArgs` is a fixture knob. So `init` ignores params and
+// returns the defaults.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(() => ({ inputHandle: undefined, readFileWithSleepArgs: "PREFIX,5,1000" }));
 
-  .output("handle", getImportProgress(getResourceField(MainOutputs, "handle")))
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
-  .output("lastLogs", getLastLogs(getResourceField(MainOutputs, "log"), 10))
+  .args<BlockArgs>((data) => ({
+    inputHandle: data.inputHandle,
+    readFileWithSleepArgs: data.readFileWithSleepArgs,
+  }))
 
-  .output("progressLog", getProgressLog(getResourceField(MainOutputs, "log"), "PREFIX"))
+  // Nothing to project: the kind takes no params. `inputHandle` is a signed,
+  // session-local reference, and `readFileWithSleepArgs` is a fixture knob driven from
+  // the UI rather than something a template would pre-wire.
+  .templateParams(() => ({}))
 
-  .output(
-    "progressLogWithInfo",
-    getProgressLogWithInfo(getResourceField(MainOutputs, "log"), "PREFIX"),
-  )
+  .output("handle", (ctx) => ctx.outputs?.resolve("handle")?.getImportProgress())
+
+  .output("lastLogs", (ctx) => ctx.outputs?.resolve("log")?.getLastLogs(10))
+
+  .output("progressLog", (ctx) => ctx.outputs?.resolve("log")?.getProgressLog("PREFIX"))
 
-  .output("progressLogWithInfoCtx", (ctx) =>
+  // V1 declared this twice — once through the config-based
+  // `getProgressLogWithInfo(getResourceField(MainOutputs, "log"), …)` helper and
+  // once as a `ctx` lambda (`progressLogWithInfoCtx`), so the block covered both
+  // surfaces. `BlockModelV3.output()` takes render lambdas only, so the two
+  // collapse into this single output.
+  .output("progressLogWithInfo", (ctx) =>
     ctx.outputs?.resolve("log")?.getProgressLogWithInfo("PREFIX"),
   )
 
-  .output("logHandle", getLogHandle(getResourceField(MainOutputs, "log")))
+  .output("logHandle", (ctx) => ctx.outputs?.resolve("log")?.getLogHandle())
 
   .sections((_ctx) => {
     return [{ type: "link", href: "/", label: "Main" }];
diff --git a/etc/blocks/read-logs/ui/src/MainPage.vue b/etc/blocks/read-logs/ui/src/MainPage.vue
index 4c2ae69746..dc61e96c8f 100644
--- a/etc/blocks/read-logs/ui/src/MainPage.vue
+++ b/etc/blocks/read-logs/ui/src/MainPage.vue
@@ -19,13 +19,13 @@ const progress = computed(() => {
 <template>
   <PlBlockPage style="max-width: 100%">
     <PlFileInput
-      v-model="app.model.args.inputHandle"
+      v-model="app.model.data.inputHandle"
       label="Select file to import"
       :progress="progress"
     />
 
     <PlTextField
-      v-model="app.model.args.readFileWithSleepArgs"
+      v-model="app.model.data.readFileWithSleepArgs"
       label="Write arguments splitted by comma (no spaces)"
     />
 
@@ -40,13 +40,13 @@ const progress = computed(() => {
     </PlAlert>
 
     <fieldset>
-      <legend>Args (app.snapshot.args)</legend>
-      {{ app.snapshot.args }}
+      <legend>Block storage (app.snapshot.blockStorage)</legend>
+      {{ app.snapshot.blockStorage }}
     </fieldset>
 
     <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>Data (app.model.data)</legend>
+      {{ app.model.data }}
     </fieldset>
 
     <PlAlert label="app.model" type="info" monospace max-height="400px">
diff --git a/etc/blocks/read-logs/ui/src/app.ts b/etc/blocks/read-logs/ui/src/app.ts
index 1dd51da680..0158553884 100644
--- a/etc/blocks/read-logs/ui/src/app.ts
+++ b/etc/blocks/read-logs/ui/src/app.ts
@@ -1,11 +1,11 @@
 import { platforma } from "@milaboratories/milaboratories.test-read-logs.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
@@ -15,12 +15,12 @@ export const sdkPlugin = defineApp(platforma, (base) => {
     data.counter++;
   }
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
     incrementCounter,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -32,7 +32,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/etc/blocks/sum-numbers-v3/.structure b/etc/blocks/sum-numbers-v3/.structure
deleted file mode 100644
index 491d734467..0000000000
--- a/etc/blocks/sum-numbers-v3/.structure
+++ /dev/null
@@ -1 +0,0 @@
-{"version":1}
\ No newline at end of file
diff --git a/etc/blocks/sum-numbers-v3/block/CHANGELOG.md b/etc/blocks/sum-numbers-v3/block/CHANGELOG.md
deleted file mode 100644
index ed05bfe100..0000000000
--- a/etc/blocks/sum-numbers-v3/block/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-sum-numbers-v3
diff --git a/etc/blocks/sum-numbers-v3/block/logos/block-logo.png b/etc/blocks/sum-numbers-v3/block/logos/block-logo.png
deleted file mode 100644
index e03221e11f..0000000000
Binary files a/etc/blocks/sum-numbers-v3/block/logos/block-logo.png and /dev/null differ
diff --git a/etc/blocks/sum-numbers-v3/block/logos/organization-logo.png b/etc/blocks/sum-numbers-v3/block/logos/organization-logo.png
deleted file mode 100644
index e03221e11f..0000000000
Binary files a/etc/blocks/sum-numbers-v3/block/logos/organization-logo.png and /dev/null differ
diff --git a/etc/blocks/sum-numbers-v3/block/package.json b/etc/blocks/sum-numbers-v3/block/package.json
deleted file mode 100644
index 0caae0f7c8..0000000000
--- a/etc/blocks/sum-numbers-v3/block/package.json
+++ /dev/null
@@ -1,55 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-sum-numbers-v3",
-  "version": "1.0.0",
-  "private": true,
-  "files": [
-    "dist",
-    "block-pack"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "sources": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "ts-builder build --target block-facade && block-tools pack",
-    "prepublishOnly": "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",
-    "do-pack": "shx rm -f package.tgz && pnpm pack && shx mv *.tgz package.tgz",
-    "check": "ts-builder type-check --target block-facade"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@milaboratories/milaboratories.test-sum-numbers-v3.model": "workspace:*",
-    "@milaboratories/milaboratories.test-sum-numbers-v3.ui": "workspace:*",
-    "@milaboratories/milaboratories.test-sum-numbers-v3.workflow": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "@platforma-sdk/block-tools": "workspace:*",
-    "@platforma-sdk/model": "workspace:*",
-    "shx": "catalog:",
-    "typescript": "catalog:"
-  },
-  "block": {
-    "components": {
-      "workflow": "@milaboratories/milaboratories.test-sum-numbers-v3.workflow/dist/tengo/tpl/main.plj.gz",
-      "model": "@milaboratories/milaboratories.test-sum-numbers-v3.model/dist/model.json",
-      "ui": "@milaboratories/milaboratories.test-sum-numbers-v3.ui/dist"
-    },
-    "meta": {
-      "title": "Sum Numbers (new api)",
-      "description": "Sum Numbers",
-      "logo": "file:logos/block-logo.png",
-      "organization": {
-        "name": "MiLaboratories Inc",
-        "url": "https://milaboratories.com/",
-        "logo": "file:logos/organization-logo.png"
-      }
-    }
-  }
-}
diff --git a/etc/blocks/sum-numbers-v3/block/src/AGENTS.ts b/etc/blocks/sum-numbers-v3/block/src/AGENTS.ts
deleted file mode 100644
index 5cf2589c3b..0000000000
--- a/etc/blocks/sum-numbers-v3/block/src/AGENTS.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// This file is managed by `block-tools structure`. Do not edit by hand.
-// Narrow MCP / AI surface.
-
-export type { BlockContract, BlockOutputs, BlockData } from "./index";
-export * from "./agents-extra";
diff --git a/etc/blocks/sum-numbers-v3/block/src/agents-extra.ts b/etc/blocks/sum-numbers-v3/block/src/agents-extra.ts
deleted file mode 100644
index 228811f462..0000000000
--- a/etc/blocks/sum-numbers-v3/block/src/agents-extra.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// Author-owned. `block-tools structure` does not modify this file.
-// MCP / AI extension surface. Add types and functions the agent
-// surface should expose.
-//
-// In the future this file will host JS functions the MCP runtime
-// can execute. The `.d.ts` declarations stay visible to the agent;
-// the JS bodies execute in the MCP code-execution context (the
-// agent sees the types but not the implementation).
diff --git a/etc/blocks/sum-numbers-v3/block/src/block-extra.ts b/etc/blocks/sum-numbers-v3/block/src/block-extra.ts
deleted file mode 100644
index fc00cdd4b3..0000000000
--- a/etc/blocks/sum-numbers-v3/block/src/block-extra.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// Author-owned. `block-tools structure` does not modify this file.
-// Add block-specific helper types or values the consumer surface
-// should expose. Anything you `export` here flows out via the
-// main entry (./index re-exports this file).
-//
-// Do NOT redefine: BlockContract, BlockOutputs, BlockData,
-// BlockPointer, platforma, or the block-named <PascalName>Block*
-// aliases — those names come from ./index and `export *` from this
-// file would shadow them.
diff --git a/etc/blocks/sum-numbers-v3/block/src/index.ts b/etc/blocks/sum-numbers-v3/block/src/index.ts
deleted file mode 100644
index 528aa1e698..0000000000
--- a/etc/blocks/sum-numbers-v3/block/src/index.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-// This file is managed by `block-tools structure`. Do not edit by hand.
-// Author content lives in ./block-extra.ts.
-
-import { platforma } from "@milaboratories/milaboratories.test-sum-numbers-v3.model";
-import {
-  InferOutputsType,
-  InferDataType,
-  InferHrefType,
-} from "@platforma-sdk/model";
-
-export { platforma };
-
-export type BlockContract = {
-  outputs: InferOutputsType<typeof platforma>;
-  data:    InferDataType<typeof platforma>;
-  href:    InferHrefType<typeof platforma>;
-};
-
-export type BlockOutputs = BlockContract["outputs"];
-export type BlockData    = BlockContract["data"];
-
-// import.meta.url is a file: URL (always forward-slash, even on Windows:
-// file:///C:/…). We expose URLs, NOT paths — the facade stays dependency-free
-// and loadable in minimal engines (e.g. QuickJS), and each consumer converts
-// at its own edge with the right tool (fileURLToPath in Node), where Windows
-// drive letters / %-encoding / UNC are handled correctly. The bundled entry
-// sits one dir under the package root (dist/index.js, or src/index.ts in dev),
-// so the root is two URL segments up. The structurer owns this layout —
-// consumers read these URLs, they never reconstruct <root>/block-pack.
-//
-// TypeScript ships `ImportMeta.url` only in the `dom`/`webworker` libs; the
-// facade tsconfig is lib-minimal (no `dom`, no `@types/node`) by design. We
-// type the one ESM-standard member we use with a local cast rather than a
-// `declare global` — a global augmentation would leak into the published
-// `dist/index.d.ts` and clash with `@types/node`'s `ImportMeta` in full-Node
-// consumers (test packages, the Middle Layer).
-const selfUrl = (import.meta as ImportMeta & { url: string }).url;
-const dirUrl  = selfUrl.slice(0, selfUrl.lastIndexOf("/"));
-const rootUrl = dirUrl.slice(0, dirUrl.lastIndexOf("/"));
-
-export const BlockPointer = {
-  type: "from-pack-v2" as const,
-  packUrl: rootUrl + "/block-pack",
-  rootUrl,
-} as const;
-
-// Block-named aliases for readable cross-block imports in tests and
-// consumer code. Same types / same runtime value as the universal
-// names above; the aliases avoid `as`-renames at the import site.
-export type TestSumNumbersV3BlockContract = BlockContract;
-export type TestSumNumbersV3BlockOutputs  = BlockOutputs;
-export type TestSumNumbersV3BlockData     = BlockData;
-export const TestSumNumbersV3BlockPointer = BlockPointer;
-
-export * from "./block-extra";
diff --git a/etc/blocks/sum-numbers-v3/block/tsconfig.json b/etc/blocks/sum-numbers-v3/block/tsconfig.json
deleted file mode 100644
index 8b5ec69745..0000000000
--- a/etc/blocks/sum-numbers-v3/block/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/facade",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/sum-numbers-v3/model/CHANGELOG.md b/etc/blocks/sum-numbers-v3/model/CHANGELOG.md
deleted file mode 100644
index cfc89d6e0a..0000000000
--- a/etc/blocks/sum-numbers-v3/model/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-sum-numbers-v3.model
diff --git a/etc/blocks/sum-numbers-v3/model/package.json b/etc/blocks/sum-numbers-v3/model/package.json
deleted file mode 100644
index 71bdd6dd57..0000000000
--- a/etc/blocks/sum-numbers-v3/model/package.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-sum-numbers-v3.model",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Block model",
-  "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "sources": "./src/index.ts",
-      "import": "./dist/index.js"
-    },
-    "./dist/*": "./dist/*"
-  },
-  "scripts": {
-    "build": "ts-builder build --target block-model && block-tools build-model",
-    "check": "ts-builder check --target block-model",
-    "formatter:check": "ts-builder formatter --check",
-    "linter:check": "ts-builder linter --check",
-    "types:check": "ts-builder type-check --target block-model",
-    "fmt": "ts-builder format",
-    "watch": "ts-builder build --target block-model --watch"
-  },
-  "dependencies": {
-    "@platforma-sdk/model": "workspace:*",
-    "zod": "catalog:"
-  },
-  "devDependencies": {
-    "@milaboratories/build-configs": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "@platforma-sdk/block-tools": "workspace:*",
-    "vitest": "catalog:"
-  },
-  "peerDependencies": {
-    "@types/node": "*",
-    "typescript": "*"
-  }
-}
diff --git a/etc/blocks/sum-numbers-v3/model/src/index.ts b/etc/blocks/sum-numbers-v3/model/src/index.ts
deleted file mode 100644
index c2f3d47f60..0000000000
--- a/etc/blocks/sum-numbers-v3/model/src/index.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import type { InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import {
-  Annotation,
-  BlockModelV3,
-  DataModelBuilder,
-  PlRef,
-  readAnnotation,
-} from "@platforma-sdk/model";
-import { z } from "zod";
-
-export const BlockData = z.object({
-  sources: z.array(PlRef).optional(),
-});
-
-export type BlockData = z.infer<typeof BlockData>;
-
-const dataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({ sources: undefined }));
-
-export const platforma = BlockModelV3.create(dataModel)
-
-  .args<BlockData>((data) => {
-    if (data.sources === undefined || data.sources.length === 0) {
-      throw new Error("Sources are required");
-    }
-    return { sources: data.sources };
-  })
-
-  .prerunArgs((data) => {
-    return { sources: data.sources ?? [] };
-  })
-
-  .output("opts", (ctx) =>
-    ctx.resultPool
-      .getSpecs()
-      .entries.filter((spec) => {
-        if (spec.obj.annotations === undefined) return false;
-        return readAnnotation(spec.obj, Annotation.Label) == "Numbers";
-      })
-      .map((opt, i) => ({
-        label: `numbers_${i}`,
-        value: opt.ref,
-      })),
-  )
-
-  .output("optsWithEnrichments", (ctx) =>
-    ctx.resultPool
-      .getSpecs()
-      .entries.filter((spec) => {
-        if (spec.obj.annotations === undefined) return false;
-        return readAnnotation(spec.obj, Annotation.Label) == "Numbers";
-      })
-      .map((opt, i) => ({
-        label: `numbers_${i}`,
-        value: { ...opt.ref, requireEnrichment: true },
-      })),
-  )
-
-  .output("sum", (ctx) => ctx.outputs?.resolve("sum")?.getDataAsJson<number>())
-
-  .output("prerunArgsJson", (ctx) =>
-    ctx.prerun?.resolve("prerunArgsJson")?.getDataAsJson<Record<string, unknown>>(),
-  )
-
-  .enriches((args) =>
-    args.sources !== undefined && args.sources.length > 0 ? [args.sources[0]] : [],
-  )
-
-  .sections((_ctx) => {
-    return [{ type: "link", href: "/", label: "Main" }];
-  })
-
-  .done();
-
-export type BlockOutputs = InferOutputsType<typeof platforma>;
-export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/sum-numbers-v3/model/tsconfig.json b/etc/blocks/sum-numbers-v3/model/tsconfig.json
deleted file mode 100644
index ccde31405f..0000000000
--- a/etc/blocks/sum-numbers-v3/model/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/model",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/sum-numbers-v3/ui/.oxfmtrc.json b/etc/blocks/sum-numbers-v3/ui/.oxfmtrc.json
deleted file mode 100644
index ba9bb8f00d..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/.oxfmtrc.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "ignorePatterns": ["dist", "CHANGELOG.md"]
-}
diff --git a/etc/blocks/sum-numbers-v3/ui/CHANGELOG.md b/etc/blocks/sum-numbers-v3/ui/CHANGELOG.md
deleted file mode 100644
index cfc68731b0..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-sum-numbers-v3.ui
diff --git a/etc/blocks/sum-numbers-v3/ui/index.html b/etc/blocks/sum-numbers-v3/ui/index.html
deleted file mode 100644
index c604936261..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta http-equiv="Content-Security-Policy" content="script-src 'self' blob:" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>
diff --git a/etc/blocks/sum-numbers-v3/ui/package.json b/etc/blocks/sum-numbers-v3/ui/package.json
deleted file mode 100644
index db3c812dd1..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/package.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-sum-numbers-v3.ui",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "ts-builder serve --target block-ui",
-    "watch": "ts-builder build --target block-ui --watch",
-    "check": "ts-builder check --target block-ui",
-    "formatter:check": "ts-builder formatter --check",
-    "linter:check": "ts-builder linter --check",
-    "types:check": "ts-builder type-check --target block-ui",
-    "build": "ts-builder build --target block-ui",
-    "fmt": "ts-builder format"
-  },
-  "dependencies": {
-    "@milaboratories/milaboratories.test-sum-numbers-v3.model": "workspace:*",
-    "@platforma-sdk/ui-vue": "workspace:*",
-    "vue": "catalog:"
-  },
-  "devDependencies": {
-    "@faker-js/faker": "catalog:",
-    "@milaboratories/build-configs": "workspace:*",
-    "@milaboratories/helpers": "workspace:*",
-    "@milaboratories/ts-builder": "workspace:*",
-    "@milaboratories/ts-configs": "workspace:*",
-    "vitest": "catalog:",
-    "zod": "catalog:"
-  },
-  "peerDependencies": {
-    "@types/node": "*",
-    "typescript": "*"
-  }
-}
diff --git a/etc/blocks/sum-numbers-v3/ui/src/MainPage.vue b/etc/blocks/sum-numbers-v3/ui/src/MainPage.vue
deleted file mode 100644
index 4ad7de8b17..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/src/MainPage.vue
+++ /dev/null
@@ -1,52 +0,0 @@
-<script setup lang="ts">
-import { PlAlert, PlBlockPage, PlDropdownMulti } from "@platforma-sdk/ui-vue";
-import { useApp } from "./app";
-import { computed } from "vue";
-
-const app = useApp();
-
-const sources = computed({
-  get() {
-    return app.model.data.sources ?? [];
-  },
-  set(newValue) {
-    app.model.data.sources = newValue;
-  },
-});
-</script>
-
-<template>
-  <PlBlockPage style="max-width: 100%">
-    <PlDropdownMulti
-      v-model="sources"
-      :options="app.model.outputs.opts ?? []"
-      label="Select numbers"
-    />
-
-    <PlAlert type="success">
-      Sum:
-      {{ app.model.outputs.sum }}
-    </PlAlert>
-
-    <PlAlert v-if="app.error" type="error">
-      {{ app.error }}
-    </PlAlert>
-    <fieldset>
-      <legend>Block Storage (app.snapshot.blockStorage)</legend>
-      {{ app.snapshot.blockStorage }}
-    </fieldset>
-    <h3>app.model</h3>
-    <code>{{ app.model }}</code>
-    <PlAlert type="info" monospace>
-      outputValues:
-      {{ app.model.outputs }}
-    </PlAlert>
-    <PlAlert type="info" monospace>
-      outputs:
-      {{ app.model.outputs }}
-    </PlAlert>
-    <PlAlert v-if="app.hasErrors" type="error">
-      {{ app.model.outputErrors }}
-    </PlAlert>
-  </PlBlockPage>
-</template>
diff --git a/etc/blocks/sum-numbers-v3/ui/src/app.ts b/etc/blocks/sum-numbers-v3/ui/src/app.ts
deleted file mode 100644
index 19839edf76..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/src/app.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { platforma } from "@milaboratories/milaboratories.test-sum-numbers-v3.model";
-import MainPage from "./MainPage.vue";
-import { defineAppV3 } from "@platforma-sdk/ui-vue";
-import type { Component } from "vue";
-import { computed, reactive } from "vue";
-import type { Equal, Expect } from "@milaboratories/helpers";
-
-export const sdkPlugin = defineAppV3(platforma, (base) => {
-  // Additional data
-  const data = reactive({
-    counter: 0,
-  });
-
-  function incrementCounter() {
-    data.counter++;
-  }
-
-  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
-
-  return {
-    data,
-    incrementCounter,
-    dataAsJson,
-    routes: {
-      "/": () => MainPage,
-    },
-  };
-});
-
-type App = ReturnType<typeof sdkPlugin.useApp>;
-
-type __cases = [
-  Expect<Equal<App["incrementCounter"], () => void>>,
-  Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["dataAsJson"], string>>,
-  Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
-];
-
-export const useApp = sdkPlugin.useApp;
diff --git a/etc/blocks/sum-numbers-v3/ui/src/main.ts b/etc/blocks/sum-numbers-v3/ui/src/main.ts
deleted file mode 100644
index cef5df0ab4..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/src/main.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createApp } from "vue";
-import { sdkPlugin } from "./app";
-import { BlockLayout } from "@platforma-sdk/ui-vue";
-
-createApp(BlockLayout).use(sdkPlugin).mount("#app");
diff --git a/etc/blocks/sum-numbers-v3/ui/tsconfig.json b/etc/blocks/sum-numbers-v3/ui/tsconfig.json
deleted file mode 100644
index bf561dd728..0000000000
--- a/etc/blocks/sum-numbers-v3/ui/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "@milaboratories/ts-configs/block/ui",
-  "include": ["src/**/*"]
-}
diff --git a/etc/blocks/sum-numbers-v3/workflow/CHANGELOG.md b/etc/blocks/sum-numbers-v3/workflow/CHANGELOG.md
deleted file mode 100644
index 0c9a8b2cd8..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/CHANGELOG.md
+++ /dev/null
@@ -1 +0,0 @@
-# @milaboratories/milaboratories.test-sum-numbers-v3.workflow
diff --git a/etc/blocks/sum-numbers-v3/workflow/format.el b/etc/blocks/sum-numbers-v3/workflow/format.el
deleted file mode 100644
index dff4aa786d..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/format.el
+++ /dev/null
@@ -1,42 +0,0 @@
-;; This program formats all files inside src directory. Usage: emacs --script ./format.el
-
-(defun install-go-mode ()
-  "Installs go-mode"
-  (require 'package)
-  (add-to-list 'package-archives
-               '("melpa-stable" . "https://stable.melpa.org/packages/"))
-  (package-initialize)
-  (unless package-archive-contents
-    (package-refresh-contents))
-
-  (package-install 'go-mode t)
-  (require 'go-mode))
-
-;; spaces -> tabs only at the beginning of lines
-(setq tabify-regexp "^\t* [ \t]+")
-
-(defun format-file (file)
-  "Formats a file according to slightly changed Go rules"
-  (message "Format %s" file)
-  (save-excursion
-    (find-file file)
-    (delete-trailing-whitespace)            ;; deletes whitespaces
-    (go-mode)                               ;; sets golang rules for indentation
-    (tabify (point-min) (point-max))        ;; spaces -> tabs in the whole file
-    (indent-region (point-min) (point-max)) ;; indentation in the whole file
-    (save-buffer)))                         ;; save file
-
-(install-go-mode)
-
-;; change syntax of a standard go-mode a bit
-(advice-add
- 'go--in-composite-literal-p
- :filter-return
- (lambda (&rest r) t))
-
-;; find all files in src
-(setq files (directory-files-recursively "src" "\\.tengo\\'"))
-
-;; call format on every file.
-(dolist (file files)
-  (format-file file))
diff --git a/etc/blocks/sum-numbers-v3/workflow/package.json b/etc/blocks/sum-numbers-v3/workflow/package.json
deleted file mode 100644
index 4550ab366b..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "name": "@milaboratories/milaboratories.test-sum-numbers-v3.workflow",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Tengo-based template",
-  "type": "module",
-  "scripts": {
-    "build": "shx rm -rf dist && pl-tengo build",
-    "check": "pl-tengo check",
-    "format": "/usr/bin/env emacs --script ./format.el || echo 'No emacs.'"
-  },
-  "dependencies": {
-    "@platforma-sdk/workflow-tengo": "workspace:*"
-  },
-  "devDependencies": {
-    "@platforma-sdk/tengo-builder": "workspace:*",
-    "@platforma-sdk/test": "workspace:*",
-    "shx": "catalog:",
-    "vitest": "catalog:"
-  }
-}
diff --git a/etc/blocks/sum-numbers-v3/workflow/src/main.tpl.tengo b/etc/blocks/sum-numbers-v3/workflow/src/main.tpl.tengo
deleted file mode 100644
index 62298a8ba2..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/src/main.tpl.tengo
+++ /dev/null
@@ -1,89 +0,0 @@
-wf := import("@platforma-sdk/workflow-tengo:workflow")
-ll := import("@platforma-sdk/workflow-tengo:ll")
-text := import("text")
-slices := import("@platforma-sdk/workflow-tengo:slices")
-json := import("json")
-smart := import("@platforma-sdk/workflow-tengo:smart")
-pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
-assets := import("@platforma-sdk/workflow-tengo:assets")
-
-wf.setPreRun(assets.importTemplate(":prerun"))
-
-mapToPValueData := func(map) {
-	data := {}
-	for key, value in map {
-		data[json.encode([key])] = value
-	}
-	result := {
-		keyLength: 1,
-		data: data
-	}
-	return result
-}
-
-
-createJsonPColumnData := func(data) {
-	return smart.createValueResource(pConstants.RTYPE_P_COLUMN_DATA_JSON, data)
-}
-
-wf.prepare(func(args) {
-	if is_undefined(args.sources) {
-		return {}
-	}
-
-	numbers := {}
-
-	ll.assert(slices.length(args.sources) > 0, "At least 1 data source must be set. It's needed in 'block error test'")
-
-	for i, ref in args.sources {
-		numbers["number"+string(i)] = wf.resolve(ref, { errIfMissing: true })
-	}
-
-	return numbers
-})
-
-wf.body(func(args) {
-	sum := 0
-	for k, numbers in args {
-		if text.has_prefix(k, "number") {
-			numsMap := numbers.data.getDataAsJson().data
-			for _, n in numsMap {
-				sum += n
-			}
-		}
-	}
-
-	blockId := wf.blockId().getDataAsJson()
-
-	return {
-		outputs: {
-			sum: sum
-		},
-		exports: {
-			sum: {
-				spec: {
-					kind: "PColumn",
-					name: "pl7.app/test/numbers",
-					valueType: "Double",
-					annotations: {
-						"pl7.app/label": "Sum"
-					},
-					domain: {
-						"pl7.app/blockId": blockId
-					},
-					axesSpec: [{
-						type: "String",
-						name: "pl7.app/test/numberIndex",
-						annotations: {
-							"pl7.app/label": "Index"
-						},
-						domain: {
-							"pl7.app/blockId": blockId
-						}
-					}]
-				},
-				data: createJsonPColumnData(json.encode(mapToPValueData({ "0": sum })))
-			}
-		}
-	}
-})
diff --git a/etc/blocks/sum-numbers-v3/workflow/tsconfig.json b/etc/blocks/sum-numbers-v3/workflow/tsconfig.json
deleted file mode 100644
index 4593cbadcd..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2022",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "sourceMap": true,
-    "declaration": true
-  },
-  "types": [],
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
diff --git a/etc/blocks/sum-numbers-v3/workflow/vitest.config.mts b/etc/blocks/sum-numbers-v3/workflow/vitest.config.mts
deleted file mode 100644
index 981029233d..0000000000
--- a/etc/blocks/sum-numbers-v3/workflow/vitest.config.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    watch: false,
-    maxConcurrency: 3,
-    testTimeout: 5000,
-  },
-});
diff --git a/etc/blocks/sum-numbers/.structure b/etc/blocks/sum-numbers/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/sum-numbers/.structure
+++ b/etc/blocks/sum-numbers/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/sum-numbers/block/CHANGELOG.md b/etc/blocks/sum-numbers/block/CHANGELOG.md
index 4e535618c7..faddc3d866 100644
--- a/etc/blocks/sum-numbers/block/CHANGELOG.md
+++ b/etc/blocks/sum-numbers/block/CHANGELOG.md
@@ -1,875 +1 @@
 # @milaboratories/milaboratories.test-sum-numbers
-
-## 1.0.127
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/model@1.28.4
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.34
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.18
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.117
-
-## 1.0.126
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.116
-
-## 1.0.125
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.17
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.115
-
-## 1.0.124
-
-### Patch Changes
-
-- Updated dependencies [69bd963]
-  - @platforma-sdk/model@1.28.1
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.33
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.114
-
-## 1.0.123
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/model@1.28.0
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.16
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.32
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.113
-
-## 1.0.122
-
-### Patch Changes
-
-- Updated dependencies [11f6e3e]
-  - @platforma-sdk/model@1.27.17
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.31
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.112
-
-## 1.0.121
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.15
-
-## 1.0.120
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.111
-
-## 1.0.119
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.14
-
-## 1.0.118
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.13
-
-## 1.0.117
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.110
-
-## 1.0.116
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.109
-- @platforma-sdk/model@1.27.10
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.30
-
-## 1.0.115
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.8
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.29
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.108
-
-## 1.0.114
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.6
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.28
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.107
-
-## 1.0.113
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.106
-
-## 1.0.112
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.12
-
-## 1.0.111
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.105
-
-## 1.0.110
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.104
-
-## 1.0.109
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.103
-
-## 1.0.108
-
-### Patch Changes
-
-- Updated dependencies [c57f609]
-  - @platforma-sdk/model@1.26.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.27
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.102
-
-## 1.0.107
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.101
-
-## 1.0.106
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.11
-
-## 1.0.105
-
-### Patch Changes
-
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/model@1.25.0
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.10
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.26
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.100
-
-## 1.0.104
-
-### Patch Changes
-
-- @platforma-sdk/model@1.24.11
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.25
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.99
-
-## 1.0.103
-
-### Patch Changes
-
-- Updated dependencies [4812a12]
-  - @platforma-sdk/model@1.24.10
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.24
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.9
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.98
-
-## 1.0.102
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-  - @platforma-sdk/model@1.24.9
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.97
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.23
-
-## 1.0.101
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.9
-
-## 1.0.100
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.8
-
-## 1.0.99
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/model@1.24.5
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.22
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.96
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.7
-
-## 1.0.98
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.95
-
-## 1.0.97
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.7
-
-## 1.0.96
-
-### Patch Changes
-
-- Updated dependencies [b084260]
-  - @platforma-sdk/model@1.24.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.21
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.94
-
-## 1.0.95
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.6
-
-## 1.0.94
-
-### Patch Changes
-
-- Updated dependencies [133e962]
-  - @platforma-sdk/model@1.23.4
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.20
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.93
-
-## 1.0.93
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.5
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.19
-
-## 1.0.92
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.92
-
-## 1.0.91
-
-### Patch Changes
-
-- Updated dependencies [1016b99]
-  - @platforma-sdk/model@1.23.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.19
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.91
-
-## 1.0.90
-
-### Patch Changes
-
-- Updated dependencies [63c66c8]
-  - @platforma-sdk/model@1.22.97
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.18
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.90
-
-## 1.0.89
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.89
-
-## 1.0.88
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.88
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.17
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-
-## 1.0.87
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-- @platforma-sdk/model@1.22.59
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.87
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.17
-
-## 1.0.86
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.86
-
-## 1.0.85
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.85
-
-## 1.0.84
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.84
-
-## 1.0.83
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.83
-
-## 1.0.82
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.82
-
-## 1.0.81
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.81
-
-## 1.0.80
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.80
-
-## 1.0.79
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.79
-
-## 1.0.78
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.78
-
-## 1.0.77
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.77
-
-## 1.0.76
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.76
-
-## 1.0.75
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.75
-
-## 1.0.74
-
-### Patch Changes
-
-- Updated dependencies [388c9d2]
-  - @platforma-sdk/model@1.22.18
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.16
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.74
-
-## 1.0.73
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.73
-
-## 1.0.72
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.72
-
-## 1.0.71
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.71
-
-## 1.0.70
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.70
-
-## 1.0.69
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.69
-
-## 1.0.68
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.68
-
-## 1.0.67
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.67
-
-## 1.0.66
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.66
-
-## 1.0.65
-
-### Patch Changes
-
-- Updated dependencies [ce558f9]
-- Updated dependencies [b41709a]
-  - @platforma-sdk/model@1.22.2
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.15
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.65
-
-## 1.0.64
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.64
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.14
-
-## 1.0.63
-
-### Patch Changes
-
-- Updated dependencies [c0d5856]
-  - @platforma-sdk/model@1.22.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.14
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.63
-
-## 1.0.62
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.62
-
-## 1.0.61
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.61
-
-## 1.0.60
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.60
-
-## 1.0.59
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.59
-
-## 1.0.58
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.58
-
-## 1.0.57
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.57
-
-## 1.0.56
-
-### Patch Changes
-
-- @platforma-sdk/model@1.21.20
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.56
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.13
-
-## 1.0.55
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.55
-
-## 1.0.54
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.54
-
-## 1.0.53
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.53
-
-## 1.0.52
-
-### Patch Changes
-
-- Updated dependencies [9d8f87b]
-  - @platforma-sdk/model@1.21.10
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.12
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.52
-
-## 1.0.51
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.51
-
-## 1.0.50
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.50
-
-## 1.0.49
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.49
-
-## 1.0.48
-
-### Patch Changes
-
-- Updated dependencies [05c8c1c]
-  - @platforma-sdk/model@1.21.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.11
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.48
-
-## 1.0.47
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.47
-
-## 1.0.46
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.46
-
-## 1.0.45
-
-### Patch Changes
-
-- Updated dependencies [079f50e]
-  - @platforma-sdk/model@1.20.27
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.10
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.45
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-
-## 1.0.44
-
-### Patch Changes
-
-- Updated dependencies [8043f5d]
-  - @platforma-sdk/model@1.20.24
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.9
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.44
-
-## 1.0.43
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.43
-
-## 1.0.42
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.42
-
-## 1.0.41
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.41
-
-## 1.0.40
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.40
-
-## 1.0.39
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.39
-
-## 1.0.38
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.38
-
-## 1.0.37
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.37
-
-## 1.0.36
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.36
-
-## 1.0.35
-
-### Patch Changes
-
-- Updated dependencies [ead0e68]
-  - @platforma-sdk/model@1.20.11
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.8
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.35
-
-## 1.0.34
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.34
-
-## 1.0.33
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.33
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.7
-- @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-
-## 1.0.32
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.32
-
-## 1.0.31
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/model@1.20.6
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.7
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.31
-
-## 1.0.30
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.30
-
-## 1.0.29
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.29
-
-## 1.0.28
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.28
-
-## 1.0.27
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/model@1.20.0
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.27
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.6
-
-## 1.0.26
-
-### Patch Changes
-
-- Updated dependencies [4d9885b]
-  - @platforma-sdk/model@1.19.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.5
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.26
-
-## 1.0.25
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.25
-
-## 1.0.24
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.24
-
-## 1.0.23
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.23
-
-## 1.0.22
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.22
-
-## 1.0.21
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.21
-
-## 1.0.20
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.20
-
-## 1.0.19
-
-### Patch Changes
-
-- @platforma-sdk/model@1.18.0
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.19
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.4
-
-## 1.0.18
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.18
-
-## 1.0.17
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.17
-
-## 1.0.16
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.16
-
-## 1.0.15
-
-### Patch Changes
-
-- Updated dependencies [b1a3abc]
-  - @platforma-sdk/model@1.17.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.3
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.15
-
-## 1.0.14
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.14
-
-## 1.0.13
-
-### Patch Changes
-
-- @platforma-sdk/model@1.15.4
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.2
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.13
-
-## 1.0.12
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.12
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [b4081fc]
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.11
-
-## 1.0.10
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.10
-
-## 1.0.9
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.9
-
-## 1.0.8
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.8
-
-## 1.0.7
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.7
-
-## 1.0.6
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.6
-
-## 1.0.5
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.5
-
-## 1.0.4
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.4
-
-## 1.0.3
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.3
-
-## 1.0.2
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.ui@1.0.2
-
-## 1.0.1
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
-- Updated dependencies [3dd3a5c]
-  - @milaboratories/milaboratories.test-sum-numbers.workflow@1.0.4
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.1
-  - @milaboratories/milaboratories.test-sum-numbers.ui@1.0.1
diff --git a/etc/blocks/sum-numbers/block/package.json b/etc/blocks/sum-numbers/block/package.json
index b56e994692..8d681bfb8f 100644
--- a/etc/blocks/sum-numbers/block/package.json
+++ b/etc/blocks/sum-numbers/block/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-sum-numbers",
-  "version": "1.0.127",
+  "version": "1.0.0",
   "private": true,
   "files": [
     "dist",
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-sum-numbers.kind": "workspace:*",
     "@milaboratories/milaboratories.test-sum-numbers.model": "workspace:*",
     "@milaboratories/milaboratories.test-sum-numbers.ui": "workspace:*",
     "@milaboratories/milaboratories.test-sum-numbers.workflow": "workspace:*",
@@ -42,8 +43,8 @@
       "ui": "@milaboratories/milaboratories.test-sum-numbers.ui/dist"
     },
     "meta": {
-      "title": "Sum Numbers (old api)",
-      "description": "Sum Numbers (old api)",
+      "title": "Sum Numbers (new api)",
+      "description": "Sum Numbers",
       "logo": "file:logos/block-logo.png",
       "organization": {
         "name": "MiLaboratories Inc",
diff --git a/etc/blocks/sum-numbers/kind/.oxfmtrc.json b/etc/blocks/sum-numbers/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/sum-numbers/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/sum-numbers/kind/.oxlintrc.json b/etc/blocks/sum-numbers/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/sum-numbers/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/sum-numbers/kind/package.json b/etc/blocks/sum-numbers/kind/package.json
new file mode 100644
index 0000000000..0b1f5d9ae4
--- /dev/null
+++ b/etc/blocks/sum-numbers/kind/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "@milaboratories/milaboratories.test-sum-numbers.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the sum-numbers block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@milaboratories/pl-model-common": "workspace:*",
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/sum-numbers/kind/src/index.ts b/etc/blocks/sum-numbers/kind/src/index.ts
new file mode 100644
index 0000000000..aac54bc265
--- /dev/null
+++ b/etc/blocks/sum-numbers/kind/src/index.ts
@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { PlRef } from "@milaboratories/pl-model-common";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the sum-numbers block — what a creator or a
+ * project template supplies to seed a new instance. The block's `BlockData` is a
+ * single field, `sources`, and it is author-supplied at creation: a template can
+ * pre-wire which upstream number columns this block sums. Optional, because a
+ * block may also be created without a template, in which case `init` falls back
+ * to an unset input.
+ */
+export type BlockParams = { sources?: PlRef[] };
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * The reference shape is reused from `pl-model-common` rather than restated, so a
+ * hand-written entry is held to exactly what the rest of the system calls a reference
+ * — including the `__isRef: true` marker the block dependency tree is rebuilt from,
+ * whose absence would otherwise produce a block wired to nothing.
+ *
+ * `.strict()` rejects and names any key this contract does not declare, instead of
+ * dropping it and applying a block that looks configured and is not.
+ */
+const Params = z.object({ sources: z.array(PlRef).optional() }).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/sum-numbers/kind/tsconfig.json b/etc/blocks/sum-numbers/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/sum-numbers/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/sum-numbers/model/CHANGELOG.md b/etc/blocks/sum-numbers/model/CHANGELOG.md
index 2ce0ac4173..823d545fbd 100644
--- a/etc/blocks/sum-numbers/model/CHANGELOG.md
+++ b/etc/blocks/sum-numbers/model/CHANGELOG.md
@@ -1,231 +1 @@
 # @milaboratories/milaboratories.test-sum-numbers.model
-
-## 1.0.34
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/model@1.28.4
-
-## 1.0.33
-
-### Patch Changes
-
-- Updated dependencies [69bd963]
-  - @platforma-sdk/model@1.28.1
-
-## 1.0.32
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/model@1.28.0
-
-## 1.0.31
-
-### Patch Changes
-
-- Updated dependencies [11f6e3e]
-  - @platforma-sdk/model@1.27.17
-
-## 1.0.30
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.10
-
-## 1.0.29
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.8
-
-## 1.0.28
-
-### Patch Changes
-
-- @platforma-sdk/model@1.27.6
-
-## 1.0.27
-
-### Patch Changes
-
-- Updated dependencies [c57f609]
-  - @platforma-sdk/model@1.26.0
-
-## 1.0.26
-
-### Patch Changes
-
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/model@1.25.0
-
-## 1.0.25
-
-### Patch Changes
-
-- @platforma-sdk/model@1.24.11
-
-## 1.0.24
-
-### Patch Changes
-
-- Updated dependencies [4812a12]
-  - @platforma-sdk/model@1.24.10
-
-## 1.0.23
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-  - @platforma-sdk/model@1.24.9
-
-## 1.0.22
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/model@1.24.5
-
-## 1.0.21
-
-### Patch Changes
-
-- Updated dependencies [b084260]
-  - @platforma-sdk/model@1.24.0
-
-## 1.0.20
-
-### Patch Changes
-
-- Updated dependencies [133e962]
-  - @platforma-sdk/model@1.23.4
-
-## 1.0.19
-
-### Patch Changes
-
-- Updated dependencies [1016b99]
-  - @platforma-sdk/model@1.23.0
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [63c66c8]
-  - @platforma-sdk/model@1.22.97
-
-## 1.0.17
-
-### Patch Changes
-
-- @platforma-sdk/model@1.22.59
-
-## 1.0.16
-
-### Patch Changes
-
-- Updated dependencies [388c9d2]
-  - @platforma-sdk/model@1.22.18
-
-## 1.0.15
-
-### Patch Changes
-
-- Updated dependencies [ce558f9]
-- Updated dependencies [b41709a]
-  - @platforma-sdk/model@1.22.2
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [c0d5856]
-  - @platforma-sdk/model@1.22.0
-
-## 1.0.13
-
-### Patch Changes
-
-- @platforma-sdk/model@1.21.20
-
-## 1.0.12
-
-### Patch Changes
-
-- Updated dependencies [9d8f87b]
-  - @platforma-sdk/model@1.21.10
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [05c8c1c]
-  - @platforma-sdk/model@1.21.0
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [079f50e]
-  - @platforma-sdk/model@1.20.27
-
-## 1.0.9
-
-### Patch Changes
-
-- Updated dependencies [8043f5d]
-  - @platforma-sdk/model@1.20.24
-
-## 1.0.8
-
-### Patch Changes
-
-- Updated dependencies [ead0e68]
-  - @platforma-sdk/model@1.20.11
-
-## 1.0.7
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/model@1.20.6
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/model@1.20.0
-
-## 1.0.5
-
-### Patch Changes
-
-- Updated dependencies [4d9885b]
-  - @platforma-sdk/model@1.19.0
-
-## 1.0.4
-
-### Patch Changes
-
-- @platforma-sdk/model@1.18.0
-
-## 1.0.3
-
-### Patch Changes
-
-- Updated dependencies [b1a3abc]
-  - @platforma-sdk/model@1.17.0
-
-## 1.0.2
-
-### Patch Changes
-
-- @platforma-sdk/model@1.15.4
-
-## 1.0.1
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
diff --git a/etc/blocks/sum-numbers/model/package.json b/etc/blocks/sum-numbers/model/package.json
index 9cca2cbc8b..fd8ff60f89 100644
--- a/etc/blocks/sum-numbers/model/package.json
+++ b/etc/blocks/sum-numbers/model/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-sum-numbers.model",
-  "version": "1.0.34",
+  "version": "1.0.0",
   "private": true,
   "description": "Block model",
   "type": "module",
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-sum-numbers.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/sum-numbers/model/src/index.ts b/etc/blocks/sum-numbers/model/src/index.ts
index 7c507d84fe..c1c03a6351 100644
--- a/etc/blocks/sum-numbers/model/src/index.ts
+++ b/etc/blocks/sum-numbers/model/src/index.ts
@@ -1,19 +1,41 @@
 import type { InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import { Annotation, BlockModel, PlRef, readAnnotation } from "@platforma-sdk/model";
+import {
+  Annotation,
+  BlockModelV3,
+  DataModelBuilder,
+  PlRef,
+  readAnnotation,
+} from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-sum-numbers.kind";
 import { z } from "zod";
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   sources: z.array(PlRef).optional(),
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+// `params` is optional — a block may be created without a template supplying
+// them — so every kind-declared field keeps a fallback default.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(({ params }) => ({ sources: params?.sources ?? undefined }));
 
-  .withArgs<BlockArgs>({
-    sources: undefined,
+export const platforma = BlockModelV3.create({ dataModel, kind })
+
+  .args<BlockData>((data) => {
+    if (data.sources === undefined || data.sources.length === 0) {
+      throw new Error("Sources are required");
+    }
+    return { sources: data.sources };
+  })
+
+  .prerunArgs((data) => {
+    return { sources: data.sources ?? [] };
   })
 
+  .templateParams((data) => ({ sources: data.sources }))
+
   .output("opts", (ctx) =>
     ctx.resultPool
       .getSpecs()
@@ -42,9 +64,9 @@ export const platforma = BlockModel.create("Heavy")
 
   .output("sum", (ctx) => ctx.outputs?.resolve("sum")?.getDataAsJson<number>())
 
-  .output("uiState", (ctx) => ctx.uiState)
-
-  .argsValid((ctx) => ctx.args.sources !== undefined && ctx.args.sources.length > 0)
+  .output("prerunArgsJson", (ctx) =>
+    ctx.prerun?.resolve("prerunArgsJson")?.getDataAsJson<Record<string, unknown>>(),
+  )
 
   .enriches((args) =>
     args.sources !== undefined && args.sources.length > 0 ? [args.sources[0]] : [],
@@ -54,7 +76,7 @@ export const platforma = BlockModel.create("Heavy")
     return [{ type: "link", href: "/", label: "Main" }];
   })
 
-  .done(2); // ui api version 2
+  .done();
 
 export type BlockOutputs = InferOutputsType<typeof platforma>;
 export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/sum-numbers/ui/CHANGELOG.md b/etc/blocks/sum-numbers/ui/CHANGELOG.md
index 6ab0458c00..f40e61ce03 100644
--- a/etc/blocks/sum-numbers/ui/CHANGELOG.md
+++ b/etc/blocks/sum-numbers/ui/CHANGELOG.md
@@ -1,811 +1 @@
 # @milaboratories/milaboratories.test-sum-numbers.ui
-
-## 1.0.117
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.34
-- @platforma-sdk/ui-vue@1.28.4
-
-## 1.0.116
-
-### Patch Changes
-
-- Updated dependencies [168d2eb]
-  - @platforma-sdk/ui-vue@1.28.3
-
-## 1.0.115
-
-### Patch Changes
-
-- Updated dependencies [c021ce8]
-  - @platforma-sdk/ui-vue@1.28.2
-
-## 1.0.114
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.33
-- @platforma-sdk/ui-vue@1.28.1
-
-## 1.0.113
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.32
-- @platforma-sdk/ui-vue@1.28.0
-
-## 1.0.112
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.31
-- @platforma-sdk/ui-vue@1.27.17
-
-## 1.0.111
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.27.14
-
-## 1.0.110
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.27.11
-
-## 1.0.109
-
-### Patch Changes
-
-- Updated dependencies [22871ac]
-- Updated dependencies [4f5f7ec]
-  - @platforma-sdk/ui-vue@1.27.10
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.30
-
-## 1.0.108
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.29
-- @platforma-sdk/ui-vue@1.27.8
-
-## 1.0.107
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.28
-- @platforma-sdk/ui-vue@1.27.6
-
-## 1.0.106
-
-### Patch Changes
-
-- Updated dependencies [518ec02]
-  - @platforma-sdk/ui-vue@1.27.5
-
-## 1.0.105
-
-### Patch Changes
-
-- Updated dependencies [9633567]
-  - @platforma-sdk/ui-vue@1.27.2
-
-## 1.0.104
-
-### Patch Changes
-
-- Updated dependencies [da875e0]
-  - @platforma-sdk/ui-vue@1.27.0
-
-## 1.0.103
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.26.1
-
-## 1.0.102
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.27
-- @platforma-sdk/ui-vue@1.26.0
-
-## 1.0.101
-
-### Patch Changes
-
-- Updated dependencies [2c4b360]
-  - @platforma-sdk/ui-vue@1.25.2
-
-## 1.0.100
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.26
-- @platforma-sdk/ui-vue@1.25.0
-
-## 1.0.99
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.11
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.25
-
-## 1.0.98
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.10
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.24
-
-## 1.0.97
-
-### Patch Changes
-
-- Updated dependencies [5f0fb1d]
-- Updated dependencies [907c694]
-  - @platforma-sdk/ui-vue@1.24.9
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.23
-
-## 1.0.96
-
-### Patch Changes
-
-- Updated dependencies [a505bdb]
-  - @platforma-sdk/ui-vue@1.24.5
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.22
-
-## 1.0.95
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.24.3
-
-## 1.0.94
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.21
-- @platforma-sdk/ui-vue@1.24.0
-
-## 1.0.93
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.20
-- @platforma-sdk/ui-vue@1.23.4
-
-## 1.0.92
-
-### Patch Changes
-
-- Updated dependencies [0a3ee03]
-  - @platforma-sdk/ui-vue@1.23.2
-
-## 1.0.91
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.19
-- @platforma-sdk/ui-vue@1.23.0
-
-## 1.0.90
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.18
-- @platforma-sdk/ui-vue@1.22.97
-
-## 1.0.89
-
-### Patch Changes
-
-- Updated dependencies [13e3124]
-  - @platforma-sdk/ui-vue@1.22.82
-
-## 1.0.88
-
-### Patch Changes
-
-- Updated dependencies [e06efcd]
-  - @platforma-sdk/ui-vue@1.22.64
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.17
-
-## 1.0.87
-
-### Patch Changes
-
-- Updated dependencies [819c13c]
-  - @platforma-sdk/ui-vue@1.22.59
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.17
-
-## 1.0.86
-
-### Patch Changes
-
-- Updated dependencies [26abb69]
-  - @platforma-sdk/ui-vue@1.22.56
-
-## 1.0.85
-
-### Patch Changes
-
-- Updated dependencies [fab0a91]
-  - @platforma-sdk/ui-vue@1.22.55
-
-## 1.0.84
-
-### Patch Changes
-
-- Updated dependencies [48f1820]
-  - @platforma-sdk/ui-vue@1.22.52
-
-## 1.0.83
-
-### Patch Changes
-
-- Updated dependencies [7ac5190]
-  - @platforma-sdk/ui-vue@1.22.51
-
-## 1.0.82
-
-### Patch Changes
-
-- Updated dependencies [2970f8d]
-  - @platforma-sdk/ui-vue@1.22.39
-
-## 1.0.81
-
-### Patch Changes
-
-- Updated dependencies [b752000]
-  - @platforma-sdk/ui-vue@1.22.34
-
-## 1.0.80
-
-### Patch Changes
-
-- Updated dependencies [c39eeee]
-  - @platforma-sdk/ui-vue@1.22.32
-
-## 1.0.79
-
-### Patch Changes
-
-- Updated dependencies [7dac3ce]
-  - @platforma-sdk/ui-vue@1.22.30
-
-## 1.0.78
-
-### Patch Changes
-
-- Updated dependencies [0c5753b]
-  - @platforma-sdk/ui-vue@1.22.29
-
-## 1.0.77
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.24
-
-## 1.0.76
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.23
-
-## 1.0.75
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.19
-
-## 1.0.74
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.16
-- @platforma-sdk/ui-vue@1.22.18
-
-## 1.0.73
-
-### Patch Changes
-
-- Updated dependencies [1a8b275]
-  - @platforma-sdk/ui-vue@1.22.16
-
-## 1.0.72
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.14
-
-## 1.0.71
-
-### Patch Changes
-
-- Updated dependencies [6d3d92d]
-  - @platforma-sdk/ui-vue@1.22.11
-
-## 1.0.70
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.10
-
-## 1.0.69
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.22.9
-
-## 1.0.68
-
-### Patch Changes
-
-- Updated dependencies [9bdc9d2]
-  - @platforma-sdk/ui-vue@1.22.8
-
-## 1.0.67
-
-### Patch Changes
-
-- Updated dependencies [698c647]
-  - @platforma-sdk/ui-vue@1.22.7
-
-## 1.0.66
-
-### Patch Changes
-
-- Updated dependencies [c5269a5]
-  - @platforma-sdk/ui-vue@1.22.4
-
-## 1.0.65
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.15
-- @platforma-sdk/ui-vue@1.22.2
-
-## 1.0.64
-
-### Patch Changes
-
-- Updated dependencies [02860e7]
-  - @platforma-sdk/ui-vue@1.22.1
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.14
-
-## 1.0.63
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.14
-- @platforma-sdk/ui-vue@1.22.0
-
-## 1.0.62
-
-### Patch Changes
-
-- Updated dependencies [56f7e84]
-  - @platforma-sdk/ui-vue@1.21.30
-
-## 1.0.61
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.29
-
-## 1.0.60
-
-### Patch Changes
-
-- Updated dependencies [3ff9dcd]
-  - @platforma-sdk/ui-vue@1.21.25
-
-## 1.0.59
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.24
-
-## 1.0.58
-
-### Patch Changes
-
-- Updated dependencies [9b5a692]
-  - @platforma-sdk/ui-vue@1.21.23
-
-## 1.0.57
-
-### Patch Changes
-
-- Updated dependencies [93b8d8d]
-  - @platforma-sdk/ui-vue@1.21.21
-
-## 1.0.56
-
-### Patch Changes
-
-- Updated dependencies [32966e6]
-  - @platforma-sdk/ui-vue@1.21.20
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.13
-
-## 1.0.55
-
-### Patch Changes
-
-- Updated dependencies [53e35de]
-  - @platforma-sdk/ui-vue@1.21.18
-
-## 1.0.54
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.17
-
-## 1.0.53
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.12
-
-## 1.0.52
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.12
-- @platforma-sdk/ui-vue@1.21.10
-
-## 1.0.51
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.21.8
-
-## 1.0.50
-
-### Patch Changes
-
-- Updated dependencies [16c729a]
-  - @platforma-sdk/ui-vue@1.21.5
-
-## 1.0.49
-
-### Patch Changes
-
-- Updated dependencies [2639fac]
-  - @platforma-sdk/ui-vue@1.21.3
-
-## 1.0.48
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.11
-- @platforma-sdk/ui-vue@1.21.0
-
-## 1.0.47
-
-### Patch Changes
-
-- Updated dependencies [78d049b]
-  - @platforma-sdk/ui-vue@1.20.30
-
-## 1.0.46
-
-### Patch Changes
-
-- Updated dependencies [7a235ba]
-  - @platforma-sdk/ui-vue@1.20.28
-
-## 1.0.45
-
-### Patch Changes
-
-- Updated dependencies [f48b25e]
-- Updated dependencies [354291e]
-  - @platforma-sdk/ui-vue@1.20.27
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.10
-
-## 1.0.44
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.9
-- @platforma-sdk/ui-vue@1.20.24
-
-## 1.0.43
-
-### Patch Changes
-
-- Updated dependencies [28b2b5c]
-- Updated dependencies [0cce397]
-  - @platforma-sdk/ui-vue@1.20.23
-
-## 1.0.42
-
-### Patch Changes
-
-- Updated dependencies [54cdf0f]
-  - @platforma-sdk/ui-vue@1.20.21
-
-## 1.0.41
-
-### Patch Changes
-
-- Updated dependencies [4208dcf]
-  - @platforma-sdk/ui-vue@1.20.19
-
-## 1.0.40
-
-### Patch Changes
-
-- Updated dependencies [e654872]
-  - @platforma-sdk/ui-vue@1.20.17
-
-## 1.0.39
-
-### Patch Changes
-
-- Updated dependencies [52b19cf]
-  - @platforma-sdk/ui-vue@1.20.16
-
-## 1.0.38
-
-### Patch Changes
-
-- Updated dependencies [7f72aa4]
-  - @platforma-sdk/ui-vue@1.20.15
-
-## 1.0.37
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.20.14
-
-## 1.0.36
-
-### Patch Changes
-
-- Updated dependencies [cc58398]
-  - @platforma-sdk/ui-vue@1.20.13
-
-## 1.0.35
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.8
-- @platforma-sdk/ui-vue@1.20.11
-
-## 1.0.34
-
-### Patch Changes
-
-- Updated dependencies [29c0b22]
-  - @platforma-sdk/ui-vue@1.20.10
-
-## 1.0.33
-
-### Patch Changes
-
-- Updated dependencies [69b15fe]
-  - @platforma-sdk/ui-vue@1.20.9
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.7
-
-## 1.0.32
-
-### Patch Changes
-
-- Updated dependencies [4360a85]
-  - @platforma-sdk/ui-vue@1.20.7
-
-## 1.0.31
-
-### Patch Changes
-
-- Updated dependencies [8903a30]
-  - @platforma-sdk/ui-vue@1.20.6
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.7
-
-## 1.0.30
-
-### Patch Changes
-
-- Updated dependencies [c74f56a]
-  - @platforma-sdk/ui-vue@1.20.5
-
-## 1.0.29
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.20.4
-
-## 1.0.28
-
-### Patch Changes
-
-- Updated dependencies [b017f36]
-  - @platforma-sdk/ui-vue@1.20.2
-
-## 1.0.27
-
-### Patch Changes
-
-- Updated dependencies [1c8631b]
-  - @platforma-sdk/ui-vue@1.20.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.6
-
-## 1.0.26
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.5
-- @platforma-sdk/ui-vue@1.19.0
-
-## 1.0.25
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.7
-
-## 1.0.24
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.6
-
-## 1.0.23
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.5
-
-## 1.0.22
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.18.3
-
-## 1.0.21
-
-### Patch Changes
-
-- Updated dependencies [e1d8a3b]
-  - @platforma-sdk/ui-vue@1.18.2
-
-## 1.0.20
-
-### Patch Changes
-
-- Updated dependencies [8022606]
-  - @platforma-sdk/ui-vue@1.18.1
-
-## 1.0.19
-
-### Patch Changes
-
-- Updated dependencies [6efea3d]
-  - @platforma-sdk/ui-vue@1.18.0
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.4
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [994ea52]
-  - @platforma-sdk/ui-vue@1.17.5
-
-## 1.0.17
-
-### Patch Changes
-
-- Updated dependencies [ec69dca]
-  - @platforma-sdk/ui-vue@1.17.3
-
-## 1.0.16
-
-### Patch Changes
-
-- Updated dependencies [ec3bffe]
-  - @platforma-sdk/ui-vue@1.17.2
-
-## 1.0.15
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.3
-- @platforma-sdk/ui-vue@1.17.0
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [ca9bf5b]
-  - @platforma-sdk/ui-vue@1.16.0
-
-## 1.0.13
-
-### Patch Changes
-
-- @milaboratories/milaboratories.test-sum-numbers.model@1.0.2
-- @platforma-sdk/ui-vue@1.15.4
-
-## 1.0.12
-
-### Patch Changes
-
-- Updated dependencies [f38f686]
-  - @platforma-sdk/ui-vue@1.15.1
-
-## 1.0.11
-
-### Patch Changes
-
-- b4081fc: [sdk/ui-vue] Deprecate everything that should be deprecated
-- Updated dependencies [b4081fc]
-  - @platforma-sdk/ui-vue@1.15.0
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [7eadcd3]
-  - @platforma-sdk/ui-vue@1.14.22
-
-## 1.0.9
-
-### Patch Changes
-
-- Updated dependencies [bc6141f]
-  - @platforma-sdk/ui-vue@1.14.21
-
-## 1.0.8
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.20
-
-## 1.0.7
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.19
-
-## 1.0.6
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.18
-
-## 1.0.5
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.15
-
-## 1.0.4
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.11
-
-## 1.0.3
-
-### Patch Changes
-
-- @platforma-sdk/ui-vue@1.14.8
-
-## 1.0.2
-
-### Patch Changes
-
-- Updated dependencies [0cfb225]
-  - @platforma-sdk/ui-vue@1.14.5
-
-## 1.0.1
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
-- Updated dependencies [3dd3a5c]
-  - @milaboratories/milaboratories.test-sum-numbers.model@1.0.1
diff --git a/etc/blocks/sum-numbers/ui/package.json b/etc/blocks/sum-numbers/ui/package.json
index 8637732ab5..a1f8fbac28 100644
--- a/etc/blocks/sum-numbers/ui/package.json
+++ b/etc/blocks/sum-numbers/ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-sum-numbers.ui",
-  "version": "1.0.117",
+  "version": "1.0.0",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/etc/blocks/sum-numbers/ui/src/MainPage.vue b/etc/blocks/sum-numbers/ui/src/MainPage.vue
index c15060302b..4ad7de8b17 100644
--- a/etc/blocks/sum-numbers/ui/src/MainPage.vue
+++ b/etc/blocks/sum-numbers/ui/src/MainPage.vue
@@ -7,10 +7,10 @@ const app = useApp();
 
 const sources = computed({
   get() {
-    return app.model.args.sources ?? [];
+    return app.model.data.sources ?? [];
   },
   set(newValue) {
-    app.model.args.sources = newValue;
+    app.model.data.sources = newValue;
   },
 });
 </script>
@@ -32,12 +32,8 @@ const sources = computed({
       {{ app.error }}
     </PlAlert>
     <fieldset>
-      <legend>Args (app.snapshot.args)</legend>
-      {{ app.snapshot.args }}
-    </fieldset>
-    <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>Block Storage (app.snapshot.blockStorage)</legend>
+      {{ app.snapshot.blockStorage }}
     </fieldset>
     <h3>app.model</h3>
     <code>{{ app.model }}</code>
diff --git a/etc/blocks/sum-numbers/ui/src/app.ts b/etc/blocks/sum-numbers/ui/src/app.ts
index 54e072e664..d0d0b4a68a 100644
--- a/etc/blocks/sum-numbers/ui/src/app.ts
+++ b/etc/blocks/sum-numbers/ui/src/app.ts
@@ -1,11 +1,11 @@
 import { platforma } from "@milaboratories/milaboratories.test-sum-numbers.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
@@ -15,12 +15,12 @@ export const sdkPlugin = defineApp(platforma, (base) => {
     data.counter++;
   }
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
     incrementCounter,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -32,7 +32,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/etc/blocks/sum-numbers/workflow/CHANGELOG.md b/etc/blocks/sum-numbers/workflow/CHANGELOG.md
index 4b38e37c27..1b4783a0a1 100644
--- a/etc/blocks/sum-numbers/workflow/CHANGELOG.md
+++ b/etc/blocks/sum-numbers/workflow/CHANGELOG.md
@@ -1,106 +1 @@
 # @milaboratories/milaboratories.test-sum-numbers.workflow
-
-## 1.0.18
-
-### Patch Changes
-
-- Updated dependencies [8142f77]
-  - @platforma-sdk/workflow-tengo@4.0.4
-
-## 1.0.17
-
-### Patch Changes
-
-- Updated dependencies [c021ce8]
-  - @platforma-sdk/workflow-tengo@4.0.3
-
-## 1.0.16
-
-### Patch Changes
-
-- Updated dependencies [43e1c65]
-  - @platforma-sdk/workflow-tengo@4.0.2
-
-## 1.0.15
-
-### Patch Changes
-
-- Updated dependencies [1564354]
-  - @platforma-sdk/workflow-tengo@4.0.1
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [8b4a614]
-  - @platforma-sdk/workflow-tengo@4.0.0
-
-## 1.0.13
-
-### Patch Changes
-
-- Updated dependencies [68809d4]
-  - @platforma-sdk/workflow-tengo@3.3.0
-
-## 1.0.12
-
-### Patch Changes
-
-- Updated dependencies [d8a33ab]
-  - @platforma-sdk/workflow-tengo@3.2.1
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [cd57569]
-  - @platforma-sdk/workflow-tengo@3.2.0
-
-## 1.0.10
-
-### Patch Changes
-
-- Updated dependencies [f0f6a8b]
-- Updated dependencies [88cebeb]
-  - @platforma-sdk/workflow-tengo@3.1.0
-
-## 1.0.9
-
-### Patch Changes
-
-- Updated dependencies [4a604e7]
-  - @platforma-sdk/workflow-tengo@3.0.3
-
-## 1.0.8
-
-### Patch Changes
-
-- Updated dependencies [4b04041]
-  - @platforma-sdk/workflow-tengo@3.0.2
-
-## 1.0.7
-
-### Patch Changes
-
-- Updated dependencies [fb5a9ff]
-  - @platforma-sdk/workflow-tengo@3.0.1
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [7034617]
-  - @platforma-sdk/workflow-tengo@3.0.0
-
-## 1.0.5
-
-### Patch Changes
-
-- Updated dependencies [af43efe]
-  - @platforma-sdk/workflow-tengo@2.16.1
-
-## 1.0.4
-
-### Patch Changes
-
-- 3dd3a5c: add test blocks
diff --git a/etc/blocks/sum-numbers/workflow/package.json b/etc/blocks/sum-numbers/workflow/package.json
index 0ead2997e9..1e2657990c 100644
--- a/etc/blocks/sum-numbers/workflow/package.json
+++ b/etc/blocks/sum-numbers/workflow/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/milaboratories.test-sum-numbers.workflow",
-  "version": "1.0.18",
+  "version": "1.0.0",
   "private": true,
   "description": "Tengo-based template",
   "type": "module",
diff --git a/etc/blocks/sum-numbers/workflow/src/main.tpl.tengo b/etc/blocks/sum-numbers/workflow/src/main.tpl.tengo
index 864df8f66c..62298a8ba2 100644
--- a/etc/blocks/sum-numbers/workflow/src/main.tpl.tengo
+++ b/etc/blocks/sum-numbers/workflow/src/main.tpl.tengo
@@ -5,6 +5,9 @@ slices := import("@platforma-sdk/workflow-tengo:slices")
 json := import("json")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+
+wf.setPreRun(assets.importTemplate(":prerun"))
 
 mapToPValueData := func(map) {
 	data := {}
diff --git a/etc/blocks/sum-numbers-v3/workflow/src/prerun.tpl.tengo b/etc/blocks/sum-numbers/workflow/src/prerun.tpl.tengo
similarity index 100%
rename from etc/blocks/sum-numbers-v3/workflow/src/prerun.tpl.tengo
rename to etc/blocks/sum-numbers/workflow/src/prerun.tpl.tengo
diff --git a/etc/blocks/table-test/.structure b/etc/blocks/table-test/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/table-test/.structure
+++ b/etc/blocks/table-test/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/table-test/block/package.json b/etc/blocks/table-test/block/package.json
index 6af868e138..58e3645bdb 100644
--- a/etc/blocks/table-test/block/package.json
+++ b/etc/blocks/table-test/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-block-table.kind": "workspace:*",
     "@milaboratories/milaboratories.test-block-table.model": "workspace:*",
     "@milaboratories/milaboratories.test-block-table.ui": "workspace:*",
     "@milaboratories/milaboratories.test-block-table.workflow": "workspace:*",
diff --git a/etc/blocks/table-test/kind/.oxfmtrc.json b/etc/blocks/table-test/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/table-test/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/table-test/kind/.oxlintrc.json b/etc/blocks/table-test/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/table-test/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/table-test/kind/package.json b/etc/blocks/table-test/kind/package.json
new file mode 100644
index 0000000000..17dd98d774
--- /dev/null
+++ b/etc/blocks/table-test/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-block-table.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the table-test block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/table-test/kind/src/index.ts b/etc/blocks/table-test/kind/src/index.ts
new file mode 100644
index 0000000000..bcb2efb0b8
--- /dev/null
+++ b/etc/blocks/table-test/kind/src/index.ts
@@ -0,0 +1,28 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the table-test block — what a creator or a project
+ * template supplies to seed a new instance. A subset of the model's `BlockData`:
+ * `label` is author-supplied at creation, while `tableState` / `tableSplitState`
+ * are UI view state that always defaults.
+ */
+export type TableTestKindParams = { label: string };
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `label` is the one required field in the workspace fixtures, so this is where a
+ * missing key is caught: without the check an entry omitting it would initialize the
+ * block with `undefined` where a string is declared, and the mismatch would only show
+ * up wherever that label is rendered.
+ */
+const Params = z.object({ label: z.string() }).strict();
+
+export const kind = defineBlockKind<TableTestKindParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/table-test/kind/tsconfig.json b/etc/blocks/table-test/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/table-test/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/table-test/model/package.json b/etc/blocks/table-test/model/package.json
index 8fdf93d436..7629192e11 100644
--- a/etc/blocks/table-test/model/package.json
+++ b/etc/blocks/table-test/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-block-table.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*"
   },
   "devDependencies": {
diff --git a/etc/blocks/table-test/model/src/index.ts b/etc/blocks/table-test/model/src/index.ts
index 3c9cff470e..013edbb78c 100644
--- a/etc/blocks/table-test/model/src/index.ts
+++ b/etc/blocks/table-test/model/src/index.ts
@@ -13,6 +13,7 @@ import {
   type InferOutputsType,
   type PlDataTableStateV2,
 } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-block-table.kind";
 
 export type BlockData = {
   label: string;
@@ -20,17 +21,21 @@ export type BlockData = {
   tableSplitState: PlDataTableStateV2;
 };
 
-const blockDataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({
-  label: "Table Test",
+// `params` is optional — a block may be created without a template supplying
+// them — so every kind-declared field keeps a fallback default.
+const blockDataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(({ params }) => ({
+  label: params?.label ?? "Table Test",
   tableState: createPlDataTableStateV2(),
   tableSplitState: createPlDataTableStateV2(),
 }));
 
 export type BlockArgs = BlockData;
 
-export const platforma = BlockModelV3.create(blockDataModel)
+export const platforma = BlockModelV3.create({ dataModel: blockDataModel, kind })
   .args<BlockArgs>((data) => data)
 
+  .templateParams((data) => ({ label: data.label }))
+
   .sections(() => {
     return [
       {
diff --git a/etc/blocks/transfer-files/.structure b/etc/blocks/transfer-files/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/transfer-files/.structure
+++ b/etc/blocks/transfer-files/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/transfer-files/block/package.json b/etc/blocks/transfer-files/block/package.json
index 32c41bebf7..eabf721cab 100644
--- a/etc/blocks/transfer-files/block/package.json
+++ b/etc/blocks/transfer-files/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.transfer-files.kind": "workspace:*",
     "@milaboratories/milaboratories.transfer-files.model": "workspace:*",
     "@milaboratories/milaboratories.transfer-files.ui": "workspace:*",
     "@milaboratories/milaboratories.transfer-files.workflow": "workspace:*",
diff --git a/etc/blocks/transfer-files/kind/.oxfmtrc.json b/etc/blocks/transfer-files/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/transfer-files/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/transfer-files/kind/.oxlintrc.json b/etc/blocks/transfer-files/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/transfer-files/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/transfer-files/kind/package.json b/etc/blocks/transfer-files/kind/package.json
new file mode 100644
index 0000000000..95faa06194
--- /dev/null
+++ b/etc/blocks/transfer-files/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.transfer-files.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the transfer-files block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/transfer-files/kind/src/index.ts b/etc/blocks/transfer-files/kind/src/index.ts
new file mode 100644
index 0000000000..9af48910aa
--- /dev/null
+++ b/etc/blocks/transfer-files/kind/src/index.ts
@@ -0,0 +1,29 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the transfer-files block — deliberately empty. The
+ * block's `BlockData` is a single `inputHandles` list, and every entry is a
+ * signed path produced by a real OS file-dialog gesture on the desktop side: it
+ * cannot be authored ahead of time by a creator or a project template. So there
+ * is nothing meaningful to seed a fresh instance with, and `init` always returns
+ * the empty list.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/transfer-files/kind/tsconfig.json b/etc/blocks/transfer-files/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/transfer-files/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/transfer-files/model/package.json b/etc/blocks/transfer-files/model/package.json
index dadca6301c..1758bdee19 100644
--- a/etc/blocks/transfer-files/model/package.json
+++ b/etc/blocks/transfer-files/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.transfer-files.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/transfer-files/model/src/index.ts b/etc/blocks/transfer-files/model/src/index.ts
index 7378c1856b..2e83dcff2d 100644
--- a/etc/blocks/transfer-files/model/src/index.ts
+++ b/etc/blocks/transfer-files/model/src/index.ts
@@ -4,27 +4,45 @@ import type {
   InferOutputsType,
   RemoteBlobHandleAndSize,
 } from "@platforma-sdk/model";
-import { BlockModel } from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.transfer-files.kind";
 import { z } from "zod";
 
 export const ImportFileHandleSchema = z
   .string()
-  .optional()
-  .refine<ImportFileHandle | undefined>(
-    ((_a) => true) as (arg: string | undefined) => arg is ImportFileHandle | undefined,
-  );
+  .refine<ImportFileHandle>(((_a) => true) as (arg: string) => arg is ImportFileHandle);
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   inputHandles: z.array(ImportFileHandleSchema),
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+/** What the workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  inputHandles: ImportFileHandle[];
+};
 
-  .withArgs({
-    inputHandles: [] as ImportFileHandle[],
-  })
+// The kind declares no init params — every entry of `inputHandles` is a signed
+// path that can only come from a real desktop file-dialog gesture, so there is
+// nothing a creator or a template could seed them with. `init` always returns
+// the empty list.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(() => ({ inputHandles: [] }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
+
+  // The one field is workflow input in its entirety: no UI-only state to strip,
+  // and no prerun phase to project into (the workflow declares `wf.body` only).
+  // Handles pass through as-is — the workflow keys its import/export maps by
+  // handle, so it dedups on its own side.
+  .args<BlockArgs>((data) => ({ inputHandles: [...data.inputHandles] }))
+
+  // Nothing to project: the kind takes no params, because every entry of
+  // `inputHandles` is a signed path from an OS file-dialog gesture and would not
+  // resolve in the project a template is applied into.
+  .templateParams(() => ({}))
 
   // fileImports: smart.createMapResource(maps.mapValues(fileImports, func(im) {
   //   return im.handle
@@ -60,7 +78,7 @@ export const platforma = BlockModel.create("Heavy")
     return [{ type: "link", href: "/", label: "Main" }];
   })
 
-  .done(2);
+  .done();
 
 export type BlockOutputs = InferOutputsType<typeof platforma>;
 export type Href = InferHrefType<typeof platforma>;
diff --git a/etc/blocks/transfer-files/ui/src/MainPage.vue b/etc/blocks/transfer-files/ui/src/MainPage.vue
index 0dbd970da2..02b7b6f5e0 100644
--- a/etc/blocks/transfer-files/ui/src/MainPage.vue
+++ b/etc/blocks/transfer-files/ui/src/MainPage.vue
@@ -34,21 +34,21 @@ const fileExports = computed(() => {
 });
 
 const onImport = (imported: ImportedFiles) => {
-  app.model.args.inputHandles = imported.files;
+  app.model.data.inputHandles = imported.files;
 };
 
 // const extensions = ['.png', '.jpg', '.fastq.gz', '.fastq.gz'];
 
 const updateHandle = (v: ImportFileHandle | undefined, i: number) => {
   if (v) {
-    app.model.args.inputHandles[i] = v;
+    app.model.data.inputHandles[i] = v;
   } else {
-    app.model.args.inputHandles.splice(i, 1);
+    app.model.data.inputHandles.splice(i, 1);
   }
 };
 
 const handlesAndProgress = computed(() => {
-  return app.model.args.inputHandles.map((h) => ({
+  return app.model.data.inputHandles.map((h) => ({
     handle: h,
     progress: app.model.outputs.fileImports?.[h],
   }));
@@ -80,7 +80,7 @@ const handlesAndProgress = computed(() => {
     <PlRow v-if="false">
       <PlAlert type="success">
         Input file handles:
-        {{ app.model.args.inputHandles }}
+        {{ app.model.data.inputHandles }}
       </PlAlert>
     </PlRow>
     <PlRow>
diff --git a/etc/blocks/transfer-files/ui/src/app.ts b/etc/blocks/transfer-files/ui/src/app.ts
index 2fce38a07f..b890df1db1 100644
--- a/etc/blocks/transfer-files/ui/src/app.ts
+++ b/etc/blocks/transfer-files/ui/src/app.ts
@@ -1,11 +1,11 @@
 import { platforma } from "@milaboratories/milaboratories.transfer-files.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
@@ -15,12 +15,12 @@ export const sdkPlugin = defineApp(platforma, (base) => {
     data.counter++;
   }
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
     incrementCounter,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -32,7 +32,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/etc/blocks/ui-examples/.structure b/etc/blocks/ui-examples/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/ui-examples/.structure
+++ b/etc/blocks/ui-examples/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/ui-examples/block/package.json b/etc/blocks/ui-examples/block/package.json
index 1934124337..a35ff2a825 100644
--- a/etc/blocks/ui-examples/block/package.json
+++ b/etc/blocks/ui-examples/block/package.json
@@ -24,6 +24,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.ui-examples.kind": "workspace:*",
     "@milaboratories/milaboratories.ui-examples.model": "workspace:*",
     "@milaboratories/milaboratories.ui-examples.ui": "workspace:*",
     "@milaboratories/milaboratories.ui-examples.workflow": "workspace:*",
diff --git a/etc/blocks/ui-examples/kind/.oxfmtrc.json b/etc/blocks/ui-examples/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/ui-examples/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/ui-examples/kind/.oxlintrc.json b/etc/blocks/ui-examples/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/ui-examples/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/ui-examples/kind/package.json b/etc/blocks/ui-examples/kind/package.json
new file mode 100644
index 0000000000..b2f00ceb61
--- /dev/null
+++ b/etc/blocks/ui-examples/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.ui-examples.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the ui-examples block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/ui-examples/kind/src/index.ts b/etc/blocks/ui-examples/kind/src/index.ts
new file mode 100644
index 0000000000..c3e5daca60
--- /dev/null
+++ b/etc/blocks/ui-examples/kind/src/index.ts
@@ -0,0 +1,31 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the ui-examples block — deliberately empty. This
+ * block is a showcase of `ui-vue` components, not an analysis: every field of
+ * its `BlockData` is either demo state a page mutates by gesture
+ * (`dynamicSections`, `datasets`, `dataTableV2`) or a desktop-signed,
+ * session-local `ImportFileHandle` no template could serialize (`handles`).
+ * `numbers` does drive the workflow, but its value is a fixture for the
+ * arg/error-state demos rather than something a creator would pre-wire. So this
+ * block takes no init params and `init` always returns the showcase defaults.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/ui-examples/kind/tsconfig.json b/etc/blocks/ui-examples/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/ui-examples/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/ui-examples/model/package.json b/etc/blocks/ui-examples/model/package.json
index aed7546085..98c803f7ec 100644
--- a/etc/blocks/ui-examples/model/package.json
+++ b/etc/blocks/ui-examples/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.ui-examples.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/ui-examples/model/src/index.ts b/etc/blocks/ui-examples/model/src/index.ts
index 0ef06c5529..dc3fc1389b 100644
--- a/etc/blocks/ui-examples/model/src/index.ts
+++ b/etc/blocks/ui-examples/model/src/index.ts
@@ -18,6 +18,7 @@ import {
   stringifyJson,
   ValueType,
 } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.ui-examples.kind";
 
 /** Args that drive computation (workflow). Derived from the block data model. */
 export type BlockArgs = {
@@ -46,7 +47,11 @@ export type BlockData = BlockArgs & {
   }[];
 };
 
-const dataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({
+// This block takes no init params (its kind declares `Record<string, never>`):
+// every `BlockData` field is either gesture-driven demo state or a
+// desktop-signed `ImportFileHandle` no template can pre-wire. So `init` ignores
+// params and returns the showcase defaults.
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(() => ({
   numbers: [1, 2, 3, 4],
   handles: [],
   dataTableV2: {
@@ -58,7 +63,7 @@ const dataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({
   datasets: [],
 }));
 
-export const platforma = BlockModelV3.create(dataModel)
+export const platforma = BlockModelV3.create({ dataModel, kind })
 
   .args<BlockArgs>((data) => {
     if (data.numbers.length === 5) {
@@ -71,6 +76,11 @@ export const platforma = BlockModelV3.create(dataModel)
     return { numbers: data.numbers, handles: data.handles };
   })
 
+  // Nothing to project: the kind takes no params. Every field of this showcase's data
+  // is either demo state a page mutates by gesture or a signed, session-local handle,
+  // and `numbers` is a fixture for the arg/error-state demos rather than configuration.
+  .templateParams(() => ({}))
+
   .output("numbers", (ctx) => ctx.outputs?.resolve("numbers")?.getDataAsJson<number[]>())
 
   .output("progresses", (ctx) => {
diff --git a/etc/blocks/upload-file/.structure b/etc/blocks/upload-file/.structure
index 491d734467..218abba169 100644
--- a/etc/blocks/upload-file/.structure
+++ b/etc/blocks/upload-file/.structure
@@ -1 +1 @@
-{"version":1}
\ No newline at end of file
+{"version":2}
\ No newline at end of file
diff --git a/etc/blocks/upload-file/block/package.json b/etc/blocks/upload-file/block/package.json
index 7daa119129..9f6b71addb 100644
--- a/etc/blocks/upload-file/block/package.json
+++ b/etc/blocks/upload-file/block/package.json
@@ -25,6 +25,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@milaboratories/milaboratories.test-upload-file.kind": "workspace:*",
     "@milaboratories/milaboratories.test-upload-file.model": "workspace:*",
     "@milaboratories/milaboratories.test-upload-file.ui": "workspace:*",
     "@milaboratories/milaboratories.test-upload-file.workflow": "workspace:*",
diff --git a/etc/blocks/upload-file/kind/.oxfmtrc.json b/etc/blocks/upload-file/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/etc/blocks/upload-file/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/etc/blocks/upload-file/kind/.oxlintrc.json b/etc/blocks/upload-file/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/etc/blocks/upload-file/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/etc/blocks/upload-file/kind/package.json b/etc/blocks/upload-file/kind/package.json
new file mode 100644
index 0000000000..d8a67d2bd9
--- /dev/null
+++ b/etc/blocks/upload-file/kind/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@milaboratories/milaboratories.test-upload-file.kind",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Block kind for the upload-file block",
+  "files": [
+    "dist/**/*"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "sources": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target block-kind && block-tools build-kind-manifest",
+    "check": "ts-builder check --target block-kind",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target block-kind",
+    "fmt": "ts-builder format",
+    "watch": "ts-builder build --target block-kind --watch"
+  },
+  "dependencies": {
+    "@platforma-sdk/block-kind": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-tools": "workspace:*"
+  },
+  "peerDependencies": {
+    "@types/node": "*",
+    "typescript": "*"
+  }
+}
diff --git a/etc/blocks/upload-file/kind/src/index.ts b/etc/blocks/upload-file/kind/src/index.ts
new file mode 100644
index 0000000000..2eeb40e474
--- /dev/null
+++ b/etc/blocks/upload-file/kind/src/index.ts
@@ -0,0 +1,29 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * Init-params contract for the upload-file block — deliberately empty. The
+ * block's `BlockData` is a single `inputHandle`, and that handle is a signed
+ * path produced by a real OS file-dialog gesture on the desktop side: it cannot
+ * be authored ahead of time by a creator or a project template. So there is
+ * nothing meaningful to seed a fresh instance with, and `init` always returns
+ * the unset default.
+ */
+export type BlockParams = Record<string, never>;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather
+ * than from typed code.
+ *
+ * `.strict()` is the whole point for an empty contract: it turns a file that sets any
+ * key at all into a rejection naming that key, instead of ignoring it and applying a
+ * block that looks configured and is not.
+ */
+const Params = z.object({}).strict();
+
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/etc/blocks/upload-file/kind/tsconfig.json b/etc/blocks/upload-file/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/etc/blocks/upload-file/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/etc/blocks/upload-file/model/package.json b/etc/blocks/upload-file/model/package.json
index 73a5632789..e04c7745cc 100644
--- a/etc/blocks/upload-file/model/package.json
+++ b/etc/blocks/upload-file/model/package.json
@@ -25,6 +25,7 @@
     "watch": "ts-builder build --target block-model --watch"
   },
   "dependencies": {
+    "@milaboratories/milaboratories.test-upload-file.kind": "workspace:*",
     "@platforma-sdk/model": "workspace:*",
     "zod": "catalog:"
   },
diff --git a/etc/blocks/upload-file/model/src/index.ts b/etc/blocks/upload-file/model/src/index.ts
index 09d5d0ff0b..40b805c725 100644
--- a/etc/blocks/upload-file/model/src/index.ts
+++ b/etc/blocks/upload-file/model/src/index.ts
@@ -1,10 +1,6 @@
 import type { ImportFileHandle, InferHrefType, InferOutputsType } from "@platforma-sdk/model";
-import {
-  BlockModel,
-  getResourceField,
-  getResourceValueAsJson,
-  MainOutputs,
-} from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import { kind } from "@milaboratories/milaboratories.test-upload-file.kind";
 import { z } from "zod";
 
 export const ImportFileHandleSchema = z
@@ -14,19 +10,34 @@ export const ImportFileHandleSchema = z
     ((_a) => true) as (arg: string | undefined) => arg is ImportFileHandle | undefined,
   );
 
-export const BlockArgs = z.object({
+export const BlockData = z.object({
   inputHandle: ImportFileHandleSchema,
 });
 
-export type BlockArgs = z.infer<typeof BlockArgs>;
+export type BlockData = z.infer<typeof BlockData>;
 
-export const platforma = BlockModel.create("Heavy")
+/** What the workflow consumes — projected from {@link BlockData} by the args lambda. */
+export type BlockArgs = {
+  inputHandle: ImportFileHandle | undefined;
+};
 
-  .withArgs({
-    inputHandle: undefined,
-  })
+// The kind declares no init params — the signed path in `inputHandle` can only
+// come from a real desktop file-dialog gesture, so there is nothing a creator or
+// a template could seed it with. `init` always returns the unset default.
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(() => ({ inputHandle: undefined }));
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
+
+  .args<BlockArgs>((data) => ({ inputHandle: data.inputHandle }))
+
+  // Nothing to project: the kind takes no params, because a signed upload handle is
+  // machine- and session-local and would not resolve in the project a template is
+  // applied into. An exported entry re-creates this block ready for a fresh upload.
+  .templateParams(() => ({}))
 
-  .output("blob", getResourceValueAsJson()(getResourceField(MainOutputs, "blob")))
+  .output("blob", (ctx) => ctx.outputs?.resolve("blob")?.getDataAsJsonOrUndefined<unknown>())
 
   .output("handle", (ctx) => ctx.outputs?.resolve("handle")?.getImportProgress())
 
diff --git a/etc/blocks/upload-file/ui/src/MainPage.vue b/etc/blocks/upload-file/ui/src/MainPage.vue
index c14ca4eb77..e6f999be6d 100644
--- a/etc/blocks/upload-file/ui/src/MainPage.vue
+++ b/etc/blocks/upload-file/ui/src/MainPage.vue
@@ -19,7 +19,7 @@ const progress = computed(() => {
 <template>
   <PlBlockPage style="max-width: 100%">
     <PlFileInput
-      v-model="app.model.args.inputHandle"
+      v-model="app.model.data.inputHandle"
       label="Select file to import"
       :progress="progress"
     />
@@ -38,12 +38,12 @@ const progress = computed(() => {
       {{ app.error }}
     </PlAlert>
     <fieldset>
-      <legend>Args (app.snapshot.args)</legend>
-      {{ app.snapshot.args }}
+      <legend>Block storage (app.snapshot.blockStorage)</legend>
+      {{ app.snapshot.blockStorage }}
     </fieldset>
     <fieldset>
-      <legend>Args (app.model.args)</legend>
-      {{ app.model.args }}
+      <legend>Data (app.model.data)</legend>
+      {{ app.model.data }}
     </fieldset>
     <h3>app.model</h3>
     <code>{{ app.model }}</code>
diff --git a/etc/blocks/upload-file/ui/src/app.ts b/etc/blocks/upload-file/ui/src/app.ts
index 5358545b82..b6ab3f12e1 100644
--- a/etc/blocks/upload-file/ui/src/app.ts
+++ b/etc/blocks/upload-file/ui/src/app.ts
@@ -1,11 +1,11 @@
 import { platforma } from "@milaboratories/milaboratories.test-upload-file.model";
 import MainPage from "./MainPage.vue";
-import { defineApp } from "@platforma-sdk/ui-vue";
+import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import type { Component } from "vue";
 import { computed, reactive } from "vue";
 import type { Equal, Expect } from "@milaboratories/helpers";
 
-export const sdkPlugin = defineApp(platforma, (base) => {
+export const sdkPlugin = defineAppV3(platforma, (base) => {
   // Additional data
   const data = reactive({
     counter: 0,
@@ -15,12 +15,12 @@ export const sdkPlugin = defineApp(platforma, (base) => {
     data.counter++;
   }
 
-  const argsAsJson = computed(() => JSON.stringify(base.snapshot.args));
+  const dataAsJson = computed(() => JSON.stringify(base.snapshot.blockStorage));
 
   return {
     data,
     incrementCounter,
-    argsAsJson,
+    dataAsJson,
     routes: {
       "/": () => MainPage,
     },
@@ -32,7 +32,7 @@ type App = ReturnType<typeof sdkPlugin.useApp>;
 type __cases = [
   Expect<Equal<App["incrementCounter"], () => void>>,
   Expect<Equal<App["data"], { counter: number }>>,
-  Expect<Equal<App["argsAsJson"], string>>,
+  Expect<Equal<App["dataAsJson"], string>>,
   Expect<Equal<App["getRoute"], (href: "/") => Component | undefined>>,
 ];
 
diff --git a/lib/model/common/src/bmodel/block_kind_ref.ts b/lib/model/common/src/bmodel/block_kind_ref.ts
new file mode 100644
index 0000000000..d9a85e42bd
--- /dev/null
+++ b/lib/model/common/src/bmodel/block_kind_ref.ts
@@ -0,0 +1,59 @@
+import type { Branded } from "@milaboratories/helpers";
+
+/**
+ * On-wire reference to a block kind, canonically the string `{name}@{version}`.
+ *
+ * A branded string: readers overwhelmingly need identity equality ("does block
+ * X implement kind Y?"), for which an opaque canonical string is ideal. Any
+ * reader that needs the parts calls {@link parseKindRef}; any writer composes
+ * the reference through {@link formatKindRef}. Keeping composition in a single
+ * function localizes the one open decision — whether the name segment has to be
+ * org-qualified for global uniqueness — to one place.
+ */
+export type BlockKindReference = Branded<string, "BlockKindReference">;
+
+/**
+ * Compose a {@link BlockKindReference} from a kind's `name`/`version`.
+ *
+ * The single place that decides how the reference is assembled. If global
+ * uniqueness later requires the name segment to be org-qualified, this is the
+ * one line that changes.
+ */
+export const formatKindRef = (k: { name: string; version: string }): BlockKindReference =>
+  `${k.name}@${k.version}` as BlockKindReference;
+
+/**
+ * Split a `{name}@{version}` string on its version separator.
+ *
+ * The one place that decides where the name ends. Uses the LAST `@` so an
+ * org-qualified npm name that itself starts with `@` (e.g.
+ * `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator
+ * (`lastIndexOf("@") <= 0`) means the string carries no version segment —
+ * malformed — so this throws rather than returning a silently version-less
+ * result.
+ *
+ * Shared with the template layer, whose `{name}@{selector}` references use the
+ * same split and differ only in how the right half is interpreted (see
+ * `parseKindSelectorReference`). `what` names the thing being parsed so the
+ * error message stays specific to the caller's reference type.
+ */
+export const splitVersionedName = (
+  ref: string,
+  what = "block kind reference",
+  expected = "{name}@{version}",
+): { name: string; version: string } => {
+  const at = ref.lastIndexOf("@");
+  if (at <= 0) {
+    throw new Error(`Malformed ${what} (expected '${expected}'): ${ref}`);
+  }
+  return { name: ref.slice(0, at), version: ref.slice(at + 1) };
+};
+
+/**
+ * Split a {@link BlockKindReference} back into `{ name, version }`.
+ *
+ * Throws on a reference with no version segment — see
+ * {@link splitVersionedName}, which owns the split rule.
+ */
+export const parseKindRef = (ref: BlockKindReference): { name: string; version: string } =>
+  splitVersionedName(ref);
diff --git a/lib/model/common/src/bmodel/container.ts b/lib/model/common/src/bmodel/container.ts
index 860e3bba98..950b4af12c 100644
--- a/lib/model/common/src/bmodel/container.ts
+++ b/lib/model/common/src/bmodel/container.ts
@@ -1,4 +1,5 @@
 import type { BlockConfigV3Generic, BlockConfigV4Generic } from "./block_config";
+import type { BlockKindReference } from "./block_kind_ref";
 import type { Code } from "./code";
 import type { BlockRenderingMode } from "./types";
 
@@ -11,6 +12,14 @@ export type BlockConfigContainer = {
   /** Config code bundle. Actually is required, but we keep it optional for backward compatibility */
   readonly code?: Code;
 
+  /**
+   * Reference to the block kind this config implements, in `{name}@{version}`
+   * form. Version-independent block identity — lives at the container level
+   * beside {@link code}, orthogonal to which render envelope (`v3`/`v4`)
+   * applies. Optional for backward compatibility with kind-less blocks.
+   */
+  readonly kind?: BlockKindReference;
+
   //
   // Fields below are used to read previous config versions
   //
diff --git a/lib/model/common/src/bmodel/index.ts b/lib/model/common/src/bmodel/index.ts
index 5788dc6957..f8441d6e0a 100644
--- a/lib/model/common/src/bmodel/index.ts
+++ b/lib/model/common/src/bmodel/index.ts
@@ -2,4 +2,5 @@ export * from "./block_config";
 export * from "./code";
 export * from "./types";
 export * from "./container";
+export * from "./block_kind_ref";
 export * from "./normalization";
diff --git a/lib/model/common/src/drivers/pframe/spec/ids.test.ts b/lib/model/common/src/drivers/pframe/spec/ids.test.ts
new file mode 100644
index 0000000000..fbd74dd662
--- /dev/null
+++ b/lib/model/common/src/drivers/pframe/spec/ids.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, test } from "vitest";
+import { createGlobalPObjectId, createLocalPObjectId } from "../../../pool";
+import { createColumnDiscoveredId } from "./discovered_column";
+import { createColumnFilteredId } from "./filtered_column";
+import { peelJsonLayers, type ColumnUniversalId } from "./ids";
+
+/**
+ * The escape-layer peeler.
+ *
+ * It is the one definition of "how a value can be hiding inside a string", and the reference
+ * detector in `pl-middle-layer` (`inferAllReferencedBlocks`) is built on it — a block id can
+ * sit under any number of `JSON.stringify` passes, and a walk over object properties reaches
+ * none of them. It deliberately says nothing about which values count as identifiers; the
+ * cases below are identifiers only because that is what the callers care about.
+ */
+
+const leaf = (blockId: string, name: string) =>
+  createGlobalPObjectId(blockId, name) as ColumnUniversalId;
+
+describe("peelJsonLayers", () => {
+  test("a canonical id is layer zero — encoded once, and that once is the id itself", () => {
+    const id = leaf("samples", "reads");
+
+    expect(peelJsonLayers(id)).toEqual({
+      value: { __isRef: true, blockId: "samples", name: "reads" },
+      layers: 0,
+    });
+  });
+
+  test("each extra stringify pass is one more layer", () => {
+    const id = leaf("samples", "reads");
+
+    expect(peelJsonLayers(JSON.stringify(id))?.layers).toBe(1);
+    expect(peelJsonLayers(JSON.stringify(JSON.stringify(id)))?.layers).toBe(2);
+  });
+
+  test("the value at the bottom is the same however deep it was", () => {
+    const id = leaf("samples", "reads");
+    const bottom = { __isRef: true, blockId: "samples", name: "reads" };
+
+    expect(peelJsonLayers(JSON.stringify(JSON.stringify(id)))?.value).toEqual(bottom);
+  });
+
+  test("a nested identifier peels to its own outer key, not to the leaf", () => {
+    // Wrapper forms nest by *string*, so peeling reaches the outermost key and stops. Walking
+    // further in is the caller's business, and no caller does — which is the point.
+    const filtered = createColumnFilteredId({
+      source: createColumnDiscoveredId({ column: leaf("samples", "clonotypes") }),
+      axisFilters: [[0, "IGH"]],
+    });
+
+    const peeled = peelJsonLayers(filtered);
+
+    expect(peeled?.layers).toBe(0);
+    expect(peeled?.value).toMatchObject({ __isFiltered: true });
+  });
+
+  test("a local leaf peels too, though it carries no marker at all", () => {
+    // The gate must not demand `__isRef`: a filtered id whose innermost leaf is local has
+    // none, and a peeler that required one would miss the whole chain.
+    const id = createLocalPObjectId(["pf", "byChain"], "abundance");
+
+    expect(peelJsonLayers(id)?.value).toEqual({
+      resolvePath: ["pf", "byChain"],
+      name: "abundance",
+    });
+  });
+
+  test("an ordinary string is not JSON and stops at the first character", () => {
+    for (const value of ["samples", "", "not json", "1.0", "yes"]) {
+      expect(peelJsonLayers(value)).toBeUndefined();
+    }
+  });
+
+  test("a quoted string that only ever yields strings is refused", () => {
+    // `"\"abc\""` peels to `abc`, which is not JSON — there is no encoded value in there, so
+    // there is nothing for a caller to look at.
+    expect(peelJsonLayers(JSON.stringify("abc"))).toBeUndefined();
+  });
+
+  test("malformed JSON is refused rather than thrown", () => {
+    expect(peelJsonLayers('{"__isRef": true')).toBeUndefined();
+  });
+
+  test("a JSON array or scalar is a value like any other", () => {
+    // Nothing here is identifier-specific: the peeler answers "what was encoded", full stop.
+    expect(peelJsonLayers("[1,2]")).toBeUndefined();
+    expect(peelJsonLayers('{"a":1}')).toEqual({ value: { a: 1 }, layers: 0 });
+  });
+});
diff --git a/lib/model/common/src/drivers/pframe/spec/ids.ts b/lib/model/common/src/drivers/pframe/spec/ids.ts
index b96061e273..91545a768c 100644
--- a/lib/model/common/src/drivers/pframe/spec/ids.ts
+++ b/lib/model/common/src/drivers/pframe/spec/ids.ts
@@ -28,7 +28,7 @@ import {
   type ColumnOverriddenId,
   type ColumnOverriddenKey,
 } from "./overridden";
-import { canonicalizeJson } from "../../../json";
+import { canonicalizeJson, parseJsonSafely } from "../../../json";
 import { AxisSpec, PColumnSpec } from "./spec";
 import { isString } from "es-toolkit";
 
@@ -97,6 +97,71 @@ export function parseColumnIdSafely(
   }
 }
 
+/** Whether `value` is any of the five key forms a {@link ColumnUniversalId} serializes. */
+export function isColumnUniversalKey(value: unknown): value is ColumnUniversalKey {
+  return (
+    isPObjectKey(value) ||
+    isColumnFilteredKey(value) ||
+    isColumnDiscoveredKey(value) ||
+    isColumnOverriddenKey(value)
+  );
+}
+
+export function isColumnUniversalId(value: unknown): value is ColumnUniversalId {
+  const key = isString(value) ? parseJsonSafely(value, false) : false;
+  return key === false ? false : isColumnUniversalKey(key);
+}
+
+/**
+ * A JSON string with its escape padding taken off, and how many passes that took.
+ *
+ * `layers` counts the `JSON.stringify` passes *above* the encoded value: a canonical id
+ * is `layers: 0`, the same id run through `JSON.stringify` once more is `layers: 1`. Keep
+ * it to put the value back the way it was found.
+ */
+export type PeeledJsonLayers = {
+  readonly value: unknown;
+  readonly layers: number;
+};
+
+/**
+ * Take a value out of however many `JSON.stringify` passes wrapped it, or `undefined`
+ * when `s` is not JSON at all.
+ *
+ * The one definition of "how a value can be hiding inside a string" — a block id can sit
+ * under several layers of escaping, and a walk over object properties reaches none of
+ * them. Callers differ in what they do at the bottom (this deliberately says nothing
+ * about which values count as identifiers), but they must agree on the mechanics, or
+ * "what carries a block id" ends up with two answers that drift.
+ *
+ * The gate is cheap and does NOT require any marker in the body: a filtered id whose
+ * innermost leaf is a {@link LocalPObjectKey} carries no `__isRef`, so demanding one
+ * would miss it.
+ */
+export function peelJsonLayers(s: string): PeeledJsonLayers | undefined {
+  let current = s;
+  let layers = 0;
+  for (;;) {
+    const c0 = current.charCodeAt(0);
+    if (c0 !== 0x7b /* { */ && c0 !== 0x22 /* " */) return undefined;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return undefined;
+    }
+    // A pass that yielded another string was escape padding, so peel again. The string
+    // is strictly shorter each time, which is what bounds the loop.
+    if (isString(parsed)) {
+      if (parsed.length >= current.length) return undefined;
+      current = parsed;
+      layers++;
+      continue;
+    }
+    return { value: parsed, layers };
+  }
+}
+
 /**
  * Walk a rich column id down to its terminal leaf {@link PObjectId}.
  */
diff --git a/lib/model/common/src/index.ts b/lib/model/common/src/index.ts
index 9d33567ce2..2364d0806f 100644
--- a/lib/model/common/src/index.ts
+++ b/lib/model/common/src/index.ts
@@ -23,3 +23,4 @@ export * from "./services";
 export * from "./pool_entry";
 export * from "./project_id";
 export * from "./columns";
+export * from "./template";
diff --git a/lib/model/common/src/plid.ts b/lib/model/common/src/plid.ts
index cd6699011a..1f44d6be89 100644
--- a/lib/model/common/src/plid.ts
+++ b/lib/model/common/src/plid.ts
@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { base32Encode } from "./base32_encode";
+import { Branded } from "@milaboratories/helpers";
 
 /** Number of raw bytes in the PlId. */
 export const PlIdBytes = 15;
@@ -9,19 +10,18 @@ export const PlIdLength = 24; // = 15 bytes * 8 bits / 5 bits per char in base32
 export const PlId = z
   .string()
   .length(PlIdLength)
-  .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/) // RFC4648
-  .brand("PlId");
-export type PlId = z.infer<typeof PlId>;
+  .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/); // RFC4648
+export type PlId = Branded<z.infer<typeof PlId>, "PlId">;
 
 export function uniquePlId(): PlId {
   const data = new Uint8Array(PlIdBytes);
   crypto.getRandomValues(data);
-  return PlId.parse(base32Encode(data, "RFC4648"));
+  return PlId.parse(base32Encode(data, "RFC4648")) as PlId;
 }
 
 export function plId(bytes: Uint8Array): PlId {
   if (bytes.length !== PlIdBytes) throw new Error(`Wrong number of bytes: ${bytes.length}`);
-  return PlId.parse(base32Encode(bytes, "RFC4648"));
+  return PlId.parse(base32Encode(bytes, "RFC4648")) as PlId;
 }
 
 export async function digestPlId(data: string): Promise<PlId> {
diff --git a/lib/model/common/src/template/index.ts b/lib/model/common/src/template/index.ts
new file mode 100644
index 0000000000..5696854105
--- /dev/null
+++ b/lib/model/common/src/template/index.ts
@@ -0,0 +1,4 @@
+export * from "./kind_selector";
+export * from "./project_template_v1";
+export * from "./template_ref";
+export * from "./template_wrap";
diff --git a/lib/model/common/src/template/kind_selector.ts b/lib/model/common/src/template/kind_selector.ts
new file mode 100644
index 0000000000..c17f0c6395
--- /dev/null
+++ b/lib/model/common/src/template/kind_selector.ts
@@ -0,0 +1,126 @@
+import type { Branded } from "@milaboratories/helpers";
+import type { BlockKindReference } from "../bmodel/block_kind_ref";
+import { parseKindRef, splitVersionedName } from "../bmodel/block_kind_ref";
+
+/**
+ * Version-selection tier of a template entry's `kind` field.
+ *
+ * - `exact` — `X.Y.Z`: this version and no other.
+ * - `patch` — `~X.Y.Z`: patch floor, behavior frozen.
+ * - `minor` — `^X.Y.Z`: minor floor, behavior floats.
+ */
+export type KindSelectorOp = "exact" | "patch" | "minor";
+
+/** The version half of a `{name}@{selector}` kind reference, split into parts. */
+export type KindSelector = {
+  readonly op: KindSelectorOp;
+  readonly version: string;
+};
+
+/**
+ * On-wire reference to a *set* of block kind versions: `{name}@{selector}`, e.g.
+ * `@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0`.
+ *
+ * The template-file form of a kind reference, and the only form the
+ * `template-v1` schema accepts in an entry's `kind` field. It is the same string
+ * shape as {@link BlockKindReference} widened by the `~`/`^` tiers, but branded
+ * separately so a *resolved* kind reference is never silently passed where a
+ * selector is expected, or vice versa. Widen an exact reference explicitly with
+ * {@link kindReferenceToSelectorReference}.
+ */
+export type BlockKindSelectorReference = Branded<string, "BlockKindSelectorReference">;
+
+/** `X.Y.Z` with optional semver prerelease and build metadata. */
+const semVerRegex =
+  /^\d+\.\d+\.\d+(?:-[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?(?:\+[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?$/;
+
+/**
+ * Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.
+ *
+ * The version is validated as `X.Y.Z`, so a range that is legal npm but not part
+ * of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than
+ * reaching resolution. Note the deliberate divergence from
+ * `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading
+ * `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only
+ * come from a doubled separator, which is malformed.
+ *
+ * Mapping a selector onto a concrete version is resolution, not parsing, and
+ * lives with the resolver (`kind_resolver.selectorToRange`).
+ *
+ * @throws if the version part is not `X.Y.Z`
+ */
+export function parseKindSelector(raw: string): KindSelector {
+  const s = raw.trim();
+  const op: KindSelectorOp = s.startsWith("~") ? "patch" : s.startsWith("^") ? "minor" : "exact";
+  const version = op === "exact" ? s : s.slice(1);
+  if (!semVerRegex.test(version)) {
+    throw new Error(
+      `Malformed kind version selector (expected 'X.Y.Z', '~X.Y.Z' or '^X.Y.Z'): ${raw}`,
+    );
+  }
+  return { op, version };
+}
+
+/** Render a {@link KindSelector} back to its on-wire string. */
+export function formatKindSelector(sel: KindSelector): string {
+  switch (sel.op) {
+    case "exact":
+      return sel.version;
+    case "patch":
+      return `~${sel.version}`;
+    case "minor":
+      return `^${sel.version}`;
+  }
+}
+
+/**
+ * Split a {@link BlockKindSelectorReference} into `{ name, selector }`.
+ *
+ * @throws if the reference carries no version segment, or the selector is
+ *   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar
+ */
+export function parseKindSelectorReference(ref: BlockKindSelectorReference): {
+  name: string;
+  selector: KindSelector;
+} {
+  const { name, version } = splitVersionedName(ref, "kind selector reference", "{name}@{selector}");
+  return { name, selector: parseKindSelector(version) };
+}
+
+/**
+ * Compose a {@link BlockKindSelectorReference} from a name and selector.
+ *
+ * A formatter, not a validator — pass a selector that came from
+ * {@link parseKindSelector} or that you constructed from a known-good version.
+ */
+export function formatKindSelectorReference(k: {
+  name: string;
+  selector: KindSelector;
+}): BlockKindSelectorReference {
+  return `${k.name}@${formatKindSelector(k.selector)}` as BlockKindSelectorReference;
+}
+
+/**
+ * Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.
+ *
+ * The export direction: a block implements exactly one kind version, so export
+ * always emits `{name}@X.Y.Z`. Validates on the way through, so a
+ * malformed stored reference fails at the boundary rather than in the file.
+ */
+export function kindReferenceToSelectorReference(
+  ref: BlockKindReference,
+): BlockKindSelectorReference {
+  const { name, version } = parseKindRef(ref);
+  return formatKindSelectorReference({ name, selector: parseKindSelector(version) });
+}
+
+/** Whether `value` is a well-formed `{name}@{selector}` string. */
+export function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference {
+  if (typeof value !== "string") return false;
+  try {
+    parseKindSelectorReference(value as BlockKindSelectorReference);
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/lib/model/common/src/template/project_template_v1.test.ts b/lib/model/common/src/template/project_template_v1.test.ts
new file mode 100644
index 0000000000..197761ac1f
--- /dev/null
+++ b/lib/model/common/src/template/project_template_v1.test.ts
@@ -0,0 +1,432 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import type { BlockKindReference } from "../bmodel/block_kind_ref";
+import { formatKindRef } from "../bmodel/block_kind_ref";
+import {
+  formatKindSelector,
+  formatKindSelectorReference,
+  isBlockKindSelectorReference,
+  kindReferenceToSelectorReference,
+  parseKindSelector,
+  parseKindSelectorReference,
+  type BlockKindSelectorReference,
+} from "./kind_selector";
+import { isTemplateRef, referencedBlockIds, toTemplateRef } from "./template_ref";
+import {
+  parseBlockPackLocation,
+  parseBlockPackReference,
+  parseProjectTemplateV1,
+  ProjectTemplateV1Schema,
+  validateProjectTemplateV1References,
+  type BlockPackLocationReference,
+  type BlockPackReference,
+  type ProjectTemplateV1,
+} from "./project_template_v1";
+
+//
+// The reference example for the format, as the value a YAML reader hands back:
+//
+//   schema: template-v1
+//   blocks:
+//     - id: samples
+//       kind: "@platforma-open/milaboratories.samples-and-data.kind@^1.0.0"
+//       params:
+//         dataset: bulk-rna
+//     - id: mixcr
+//       kind: "@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0"
+//       params:
+//         input: { $ref: { __isRef: true, blockId: samples, name: reads } }
+//         species: human
+//         preset: milab-human-tcr-rna
+//     - id: browser
+//       kind: "@platforma-open/milaboratories.clonotype-browser.kind@1.0.0"
+//       block: "@platforma-open/milaboratories.clonotype-browser@2.4.1"
+//       params:
+//         clonotypes: { $ref: { __isRef: true, blockId: mixcr, name: clonotypes } }
+//
+// The YAML text <-> value step is not this package's job (no `yaml` dependency);
+// byte-level round-tripping belongs to the middle-layer serializer.
+//
+const referenceExample = {
+  schema: "template-v1",
+  blocks: [
+    {
+      id: "samples",
+      kind: "@platforma-open/milaboratories.samples-and-data.kind@^1.0.0",
+      params: { dataset: "bulk-rna" },
+    },
+    {
+      id: "mixcr",
+      kind: "@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0",
+      params: {
+        input: toTemplateRef({ __isRef: true, blockId: "samples", name: "reads" }),
+        species: "human",
+        preset: "milab-human-tcr-rna",
+      },
+    },
+    {
+      id: "browser",
+      kind: "@platforma-open/milaboratories.clonotype-browser.kind@1.0.0",
+      block: "@platforma-open/milaboratories.clonotype-browser@2.4.1",
+      params: {
+        clonotypes: toTemplateRef({ __isRef: true, blockId: "mixcr", name: "clonotypes" }),
+      },
+    },
+  ],
+};
+
+describe("kind selector grammar", () => {
+  test("the three tiers round-trip", () => {
+    expect(parseKindSelector("1.2.0")).toEqual({ op: "exact", version: "1.2.0" });
+    expect(parseKindSelector("~1.2.0")).toEqual({ op: "patch", version: "1.2.0" });
+    expect(parseKindSelector("^1.2.0")).toEqual({ op: "minor", version: "1.2.0" });
+
+    for (const raw of ["1.2.0", "~1.2.0", "^1.2.0"]) {
+      expect(formatKindSelector(parseKindSelector(raw))).toBe(raw);
+    }
+  });
+
+  test("prerelease and build metadata survive", () => {
+    expect(parseKindSelector("~1.2.0-rc.1")).toEqual({ op: "patch", version: "1.2.0-rc.1" });
+    expect(parseKindSelector("1.2.0+build.5")).toEqual({ op: "exact", version: "1.2.0+build.5" });
+  });
+
+  test("npm ranges outside the kind grammar are rejected", () => {
+    for (const raw of [">=1.0.0", "1.x", "1.2", "latest", "*", ""]) {
+      expect(() => parseKindSelector(raw)).toThrow(/Malformed kind version selector/);
+    }
+  });
+
+  test("a scoped npm name keeps its leading @", () => {
+    const ref = "@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0";
+    expect(parseKindSelectorReference(ref as BlockKindSelectorReference)).toEqual({
+      name: "@platforma-open/milaboratories.mixcr-clonotyping.kind",
+      selector: { op: "patch", version: "1.2.0" },
+    });
+    expect(
+      formatKindSelectorReference({
+        name: "@platforma-open/milaboratories.mixcr-clonotyping.kind",
+        selector: { op: "patch", version: "1.2.0" },
+      }),
+    ).toBe(ref);
+  });
+
+  test("a reference with no version segment is malformed", () => {
+    expect(() =>
+      parseKindSelectorReference("@platforma-open/foo.kind" as BlockKindSelectorReference),
+    ).toThrow(/Malformed kind selector reference/);
+    expect(isBlockKindSelectorReference("@platforma-open/foo.kind")).toBe(false);
+    expect(isBlockKindSelectorReference(42)).toBe(false);
+    expect(isBlockKindSelectorReference("@platforma-open/foo.kind@1.0.0")).toBe(true);
+  });
+
+  test("an exact kind reference widens to the exact selector tier", () => {
+    // The export direction: a block implements exactly one version.
+    const resolved: BlockKindReference = formatKindRef({
+      name: "@platforma-open/milaboratories.clonotype-browser.kind",
+      version: "1.0.0",
+    });
+    const selector = kindReferenceToSelectorReference(resolved);
+
+    expect(selector).toBe("@platforma-open/milaboratories.clonotype-browser.kind@1.0.0");
+    expect(parseKindSelectorReference(selector).selector.op).toBe("exact");
+  });
+});
+
+describe("block pack override", () => {
+  test("parses an exact reference", () => {
+    expect(
+      parseBlockPackReference(
+        "@platforma-open/milaboratories.clonotype-browser@2.4.1" as BlockPackReference,
+      ),
+    ).toEqual({
+      name: "@platforma-open/milaboratories.clonotype-browser",
+      version: "2.4.1",
+    });
+  });
+
+  test("rejects a range — an override must pin", () => {
+    expect(() =>
+      parseBlockPackReference("@platforma-open/foo@^2.4.1" as BlockPackReference),
+    ).toThrow(/must pin an exact version/);
+  });
+});
+
+describe("block pack location", () => {
+  const location = (raw: string) => parseBlockPackLocation(raw as BlockPackLocationReference);
+
+  test("reads the scheme, which is all this layer needs to know", () => {
+    // Everything past the scheme belongs to whoever can reach it: this layer cannot
+    // know which schemes a given environment serves, and must not decide for it.
+    expect(location("file:///Users/dev/blocks/enter-numbers/block")).toEqual({ scheme: "file" });
+    expect(location("https://blocks.internal/enter-numbers")).toEqual({ scheme: "https" });
+  });
+
+  test("the scheme is compared case-insensitively", () => {
+    expect(location("FILE:///Users/dev/blocks/x")).toEqual({ scheme: "file" });
+  });
+
+  test("a bare path is rejected, because it would be read against the wrong directory", () => {
+    // The whole point of a locator is removing the question "relative to what".
+    expect(() => location("/Users/dev/blocks/enter-numbers/block")).toThrow(
+      /absolute URI with a scheme/,
+    );
+    expect(() => location("./blocks/enter-numbers")).toThrow(/absolute URI with a scheme/);
+  });
+
+  test("a Windows path is rejected rather than read as a one-letter scheme", () => {
+    // `C:\blocks\x` satisfies the URI scheme grammar with scheme `c`, so without the
+    // two-character floor it would be accepted here and fail somewhere unrelated.
+    expect(() => location("C:\\blocks\\enter-numbers")).toThrow(/absolute URI with a scheme/);
+    expect(location("file:///C:/blocks/enter-numbers")).toEqual({ scheme: "file" });
+  });
+});
+
+describe("reference wrappers", () => {
+  test("recognized by the reserved $ref shape only", () => {
+    expect(isTemplateRef(toTemplateRef({ __isRef: true }))).toBe(true);
+    expect(isTemplateRef({ $ref: "anything at all" })).toBe(true);
+
+    // A second key, no `$ref`, an array, null: not a wrapper. The shape is reserved inside
+    // opaque params, so the narrowest recognizable one takes least away from kind authors.
+    expect(isTemplateRef({ $ref: 1, as: "id" })).toBe(false);
+    expect(isTemplateRef({ ref: 1 })).toBe(false);
+    expect(isTemplateRef([1])).toBe(false);
+    expect(isTemplateRef(null)).toBe(false);
+  });
+
+  test("an absent value is not wrapped", () => {
+    expect(toTemplateRef(undefined)).toBeUndefined();
+  });
+
+  test("the payload is whatever the block wrapped, untouched", () => {
+    const payload = [{ __isRef: true, blockId: "a", name: "x" }];
+
+    expect(toTemplateRef(payload).$ref).toBe(payload);
+  });
+
+  test("referenced ids are found in any payload, at any depth", () => {
+    const params = {
+      input: toTemplateRef({ __isRef: true, blockId: "samples", name: "reads" }),
+      nested: { list: [toTemplateRef('{"__isRef":true,"blockId":"mixcr","name":"clones"}')] },
+      species: "human",
+    };
+
+    expect(referencedBlockIds(params, ["samples", "mixcr", "absent"])).toEqual([
+      "samples",
+      "mixcr",
+    ]);
+  });
+
+  test("an id outside a wrapper is not a reference", () => {
+    // Wrapping is the whole signal. What sits outside one is data as far as this layer is
+    // concerned, and is rejected elsewhere — by the export guard and the import check.
+    const params = { loose: { __isRef: true, blockId: "samples", name: "reads" } };
+
+    expect(referencedBlockIds(params, ["samples"])).toEqual([]);
+  });
+
+  test("an id is matched as a whole JSON token, not as a substring", () => {
+    // `a` must not match the `a` inside `"reads"`, or a rewrite would corrupt the payload.
+    const params = { input: toTemplateRef({ __isRef: true, blockId: "b", name: "reads" }) };
+
+    expect(referencedBlockIds(params, ["a"])).toEqual([]);
+    expect(referencedBlockIds(params, ["b"])).toEqual(["b"]);
+  });
+});
+
+describe("parseProjectTemplateV1", () => {
+  test("parses the reference example unchanged", () => {
+    const doc = parseProjectTemplateV1(referenceExample);
+
+    expect(doc).toEqual(referenceExample);
+    expect(doc.blocks.map((b) => b.id)).toEqual(["samples", "mixcr", "browser"]);
+    expect(doc.blocks[2].block).toBe("@platforma-open/milaboratories.clonotype-browser@2.4.1");
+    expect(validateProjectTemplateV1References(doc)).toEqual([]);
+  });
+
+  test("params may be omitted in the file, and reads as `{}`", () => {
+    // The one field the parser fills in. Every reader past it gets a mapping, so none of
+    // them carries a `?? {}` that one of them would eventually forget.
+    const doc = parseProjectTemplateV1({
+      schema: "template-v1",
+      blocks: [{ id: "samples", kind: "@platforma-open/foo.kind@^1.0.0" }],
+    });
+
+    expect(doc.blocks[0].params).toEqual({});
+  });
+
+  test("kind is required — it carries the params contract", () => {
+    expect(() =>
+      parseProjectTemplateV1({
+        schema: "template-v1",
+        blocks: [{ id: "samples", params: { dataset: "bulk-rna" } }],
+      }),
+    ).toThrow(/kind/);
+  });
+
+  test("an entry may pin where its implementation comes from", () => {
+    const doc = parseProjectTemplateV1({
+      schema: "template-v1",
+      blocks: [
+        {
+          id: "9f3c",
+          kind: "@milaboratories/milaboratories.test-enter-numbers.kind@^1.0.0",
+          location: "file:///Users/dev/blocks/enter-numbers/block",
+          params: { numbers: [1, 2, 3] },
+        },
+      ],
+    });
+
+    expect(doc.blocks[0].location).toBe("file:///Users/dev/blocks/enter-numbers/block");
+    // The kind stays required alongside it: the locator says where to get the
+    // implementation, not what contract the params are written against.
+    expect(doc.blocks[0].kind).toBe(
+      "@milaboratories/milaboratories.test-enter-numbers.kind@^1.0.0",
+    );
+  });
+
+  test("an entry cannot pin both a version and a place", () => {
+    // Two different statements with nothing to reconcile them, so it is refused
+    // rather than settled by precedence.
+    const result = ProjectTemplateV1Schema.safeParse({
+      schema: "template-v1",
+      blocks: [
+        {
+          id: "a",
+          kind: "@o/a.kind@1.0.0",
+          block: "@o/a@1.0.0",
+          location: "file:///blocks/a",
+        },
+      ],
+    });
+
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error.issues[0].path).toEqual(["blocks", 0, "location"]);
+    expect(result.error.issues[0].message).toMatch(/cannot carry both 'block' and 'location'/);
+  });
+
+  test("a malformed location is reported on its own path", () => {
+    const result = ProjectTemplateV1Schema.safeParse({
+      schema: "template-v1",
+      blocks: [{ id: "a", kind: "@o/a.kind@1.0.0", location: "/blocks/a" }],
+    });
+
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error.issues[0].path).toEqual(["blocks", 0, "location"]);
+  });
+
+  test("the format marker is checked", () => {
+    expect(() => parseProjectTemplateV1({ schema: "template-v2", blocks: [] })).toThrow();
+    expect(() => parseProjectTemplateV1({ blocks: [] })).toThrow();
+  });
+
+  test("unknown fields are rejected at both levels", () => {
+    // No `label` field: a template does not name block instances for display.
+    expect(() =>
+      parseProjectTemplateV1({
+        schema: "template-v1",
+        blocks: [{ id: "a", kind: "@o/a.kind@1.0.0", label: "Samples" }],
+      }),
+    ).toThrow(/label/);
+
+    expect(() =>
+      parseProjectTemplateV1({ schema: "template-v1", blocks: [], metadata: {} }),
+    ).toThrow(/metadata/);
+  });
+
+  test("a malformed kind selector is reported on its own path", () => {
+    const result = ProjectTemplateV1Schema.safeParse({
+      schema: "template-v1",
+      blocks: [{ id: "a", kind: "@o/a.kind@>=1.0.0" }],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0].path).toEqual(["blocks", 0, "kind"]);
+      expect(result.error.issues[0].message).toMatch(/Malformed kind version selector/);
+    }
+  });
+
+  test("duplicate template-local ids are rejected", () => {
+    expect(() =>
+      parseProjectTemplateV1({
+        schema: "template-v1",
+        blocks: [
+          { id: "a", kind: "@o/a.kind@1.0.0" },
+          { id: "a", kind: "@o/b.kind@1.0.0" },
+        ],
+      }),
+    ).toThrow(/Duplicate template-local id: a/);
+  });
+});
+
+describe("validateProjectTemplateV1References", () => {
+  const docWith = (blocks: unknown[]) => parseProjectTemplateV1({ schema: "template-v1", blocks });
+
+  const reader = (id: string, referenced: string) => ({
+    id,
+    kind: "@o/m.kind@1.0.0",
+    params: { input: toTemplateRef({ __isRef: true, blockId: referenced, name: "reads" }) },
+  });
+
+  test("flags a reference to an entry declared later", () => {
+    const doc = docWith([reader("mixcr", "samples"), { id: "samples", kind: "@o/s.kind@1.0.0" }]);
+
+    expect(validateProjectTemplateV1References(doc)).toEqual([
+      "Entry 'mixcr' references entry 'samples', which is declared after it " +
+        "(blocks order is the instantiation order)",
+    ]);
+  });
+
+  test("flags a self-reference", () => {
+    const doc = docWith([reader("mixcr", "mixcr")]);
+
+    expect(validateProjectTemplateV1References(doc)).toEqual([
+      "Entry 'mixcr' references its own output",
+    ]);
+  });
+
+  test("says nothing about a reference to an id the file does not define", () => {
+    // The documented gap of an engine that does not parse payloads: it can only ask which of
+    // the ids this file defines appear in one, so an id naming no entry is indistinguishable
+    // from the rest of the payload's text. Pinned so the gap stays visible.
+    const doc = docWith([reader("mixcr", "ghost")]);
+
+    expect(validateProjectTemplateV1References(doc)).toEqual([]);
+  });
+
+  test("finds a block id however deeply it is buried in the payload", () => {
+    // The engine reads no structure, so depth, escaping and nesting cost it nothing.
+    const doc = docWith([
+      {
+        id: "browser",
+        kind: "@o/m.kind@1.0.0",
+        params: {
+          anchor: toTemplateRef(
+            JSON.stringify({
+              __isFiltered: true,
+              source: JSON.stringify({ __isRef: true, blockId: "samples", name: "c" }),
+            }),
+          ),
+        },
+      },
+      { id: "samples", kind: "@o/s.kind@1.0.0" },
+    ]);
+
+    expect(validateProjectTemplateV1References(doc)).toEqual([
+      "Entry 'browser' references entry 'samples', which is declared after it " +
+        "(blocks order is the instantiation order)",
+    ]);
+  });
+});
+
+test("the parser's output type is exactly ProjectTemplateV1", () => {
+  // `satisfies` only checks one direction — a parser narrower than the type
+  // still passes it — so pin exactness here. NOTE: vitest runs without
+  // `--typecheck` and tsconfig excludes *.test.ts, so this assertion is
+  // authoring-time only; it is verified by running tsc over this file.
+  expectTypeOf<ReturnType<typeof parseProjectTemplateV1>>().toEqualTypeOf<ProjectTemplateV1>();
+  expectTypeOf<typeof ProjectTemplateV1Schema._output>().toEqualTypeOf<ProjectTemplateV1>();
+});
diff --git a/lib/model/common/src/template/project_template_v1.ts b/lib/model/common/src/template/project_template_v1.ts
new file mode 100644
index 0000000000..b365bfaa49
--- /dev/null
+++ b/lib/model/common/src/template/project_template_v1.ts
@@ -0,0 +1,369 @@
+import { z } from "zod";
+import type { Branded } from "@milaboratories/helpers";
+import { splitVersionedName } from "../bmodel/block_kind_ref";
+import type { BlockKindSelectorReference } from "./kind_selector";
+import { parseKindSelector, parseKindSelectorReference } from "./kind_selector";
+import { referencedBlockIds } from "./template_ref";
+
+/**
+ * Value of a template file's `schema` field — the format marker every
+ * `template-v1` document opens with.
+ */
+export const PROJECT_TEMPLATE_SCHEMA_V1 = "template-v1";
+export type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
+
+/**
+ * On-wire reference to one exact block package version, `{name}@X.Y.Z`.
+ *
+ * The `block` override's value type. Exact only — the override exists to pin an
+ * implementation, so a range would defeat it. Mapping this to the structured
+ * `BlockPackId` (`{ organization, name, version }`) is import-side work; the
+ * organization lives inside the npm scope here, as it does for kind names.
+ */
+export type BlockPackReference = Branded<string, "BlockPackReference">;
+
+/**
+ * Split a {@link BlockPackReference} into `{ name, version }`.
+ *
+ * @throws if the reference carries no version segment or the version is not
+ *   exactly `X.Y.Z`
+ */
+export function parseBlockPackReference(ref: BlockPackReference): {
+  name: string;
+  version: string;
+} {
+  const { name, version } = splitVersionedName(ref, "block package reference", "{name}@X.Y.Z");
+  const selector = parseKindSelector(version);
+  if (selector.op !== "exact") {
+    throw new Error(
+      `A 'block' override must pin an exact version (expected '{name}@X.Y.Z'): ${ref}`,
+    );
+  }
+  return { name, version: selector.version };
+}
+
+/**
+ * On-wire locator naming WHERE one entry's block implementation comes from, as an
+ * absolute URI: `file:///abs/path/to/block`.
+ *
+ * The third way an entry can reach an implementation, and the only one that names a
+ * place rather than a name. It exists for a block that is built but not published —
+ * the implementation lives in a folder and no registry knows it, so neither `kind`
+ * resolution nor a `block` version pin can find it.
+ *
+ * A URI rather than a bare path because the question "where" is not limited to the
+ * filesystem, and because scheme dispatch is how the rest of the toolchain already
+ * answers it. Which schemes an environment can actually serve is that environment's
+ * business: this type fixes only the grammar, so a document remains readable by a
+ * consumer that cannot fetch every scheme.
+ */
+export type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
+
+/**
+ * Read the scheme off a {@link BlockPackLocationReference}, which is all the
+ * document layer knows about it — resolving the rest belongs to whoever can reach
+ * the scheme.
+ *
+ * A scheme is required. Accepting a bare path would mean reading it relative to
+ * whatever directory the application happens to have been started from, which is
+ * exactly the ambiguity a locator exists to remove.
+ *
+ * @throws if the value carries no scheme
+ */
+export function parseBlockPackLocation(ref: BlockPackLocationReference): { scheme: string } {
+  const match = LocationSchemePattern.exec(ref);
+  if (!match) {
+    throw new Error(
+      `A 'location' must be an absolute URI with a scheme (expected e.g. ` +
+        `'file:///path/to/block'), got: ${ref}`,
+    );
+  }
+  return { scheme: match.groups!.scheme.toLowerCase() };
+}
+
+/**
+ * Scheme grammar, with one deliberate narrowing: a scheme is at least TWO
+ * characters, while the URI grammar allows one.
+ *
+ * `C:\blocks\my-block` is a valid single-letter-scheme URI, so a Windows path
+ * pasted into the field would otherwise be accepted with scheme `c` and then fail
+ * far away from the mistake. Rejecting it here means the error names the actual
+ * problem, and the fix — `file:///C:/blocks/my-block` — is spelled out.
+ */
+const LocationSchemePattern = /^(?<scheme>[A-Za-z][A-Za-z0-9+.-]+):/;
+
+/**
+ * One block in a template file.
+ *
+ * `kind` is always required: it carries the params contract the entry is typed
+ * against, and it is checked against what the located implementation declares even
+ * when it did not do the locating. A file may omit `params`, which is terseness and not an
+ * escape from the contract: the parser reads the omission as `{}`, so an entry that leaves it
+ * out still fails for a kind whose contract has required fields. Past the parser there is
+ * only one spelling, and no reader has to normalize. There is no `label` field: a template
+ * does not name block instances for display.
+ *
+ * Two optional, mutually exclusive locator overrides answer different questions, and
+ * either one skips kind resolution:
+ *
+ * - `block` — WHICH VERSION, leaving the environment to decide which registry serves
+ *   it. Portable.
+ * - `location` — WHICH PLACE. Names a concrete, possibly unpublished implementation,
+ *   and is therefore only meaningful where that place exists.
+ *
+ * An entry carrying both states two different things with no way to reconcile them,
+ * so it is rejected rather than resolved by precedence.
+ */
+export type ProjectTemplateV1Entry = {
+  /**
+   * Template-local identifier, unique within the file. Names the entry for
+   * inter-block references; on export it is the block's project-local UUID,
+   * reused verbatim.
+   */
+  readonly id: string;
+  readonly kind: BlockKindSelectorReference;
+  /**
+   * The block's `BlockParams` instance, exactly as the block projected it — opaque here
+   * and typed by the kind. Always present: an entry whose file omitted it parses as `{}`.
+   *
+   * The document layer looks inside for one thing only: a `{ $ref: … }` wrapper, which the
+   * block puts around any value carrying block ids. Everything else travels verbatim,
+   * references included, because an engine that parsed identifiers would have to model the
+   * whole reference system to do it. See `TemplateRef`.
+   */
+  readonly params: Record<string, unknown>;
+} & BlockPackLocatorOverride;
+
+/**
+ * The locator override an entry may carry: a version pin, a place, or neither.
+ *
+ * Two arms rather than two optional fields, so "not both" is a property of the type and not
+ * only of the parser. Each arm forbids the other's field by typing it `never`, which is what
+ * makes `{ block, location }` match neither — and both arms leave their own field optional, so
+ * an entry that pins nothing satisfies either.
+ *
+ * Readers are unaffected: every arm declares both keys, so `entry.block` and `entry.location`
+ * stay directly readable without narrowing.
+ */
+export type BlockPackLocatorOverride =
+  | { readonly block?: BlockPackReference; readonly location?: never }
+  | { readonly block?: never; readonly location?: BlockPackLocationReference };
+
+/**
+ * A `template-v1` document — the primitive form of a template.
+ *
+ * `blocks` order is the instantiation order, so every entry must appear after
+ * the entries it references. This type is the shared contract for both
+ * directions of the round trip: export emits exactly this, import parses
+ * exactly this.
+ *
+ * Scope note: this package owns the *document*, i.e. the shape of the value a
+ * YAML (or JSON) reader hands back. The text layer stays out on purpose —
+ * pl-model-common is in every block-model and UI bundle and takes no `yaml`
+ * dependency; serializing to YAML bytes belongs with the caller that already
+ * has one (pl-middle-layer).
+ */
+export type ProjectTemplateV1 = {
+  readonly schema: ProjectTemplateSchemaV1;
+  readonly blocks: readonly ProjectTemplateV1Entry[];
+};
+
+//
+// Zod schemas — boundary validators only. The TS types above are the source of
+// truth; each schema is pegged to its type via `satisfies`.
+//
+// The peg is `BoundaryParser<T>` rather than the repo-standard `z.ZodType<T>`
+// because the branded string fields need a `.transform` to reach their branded
+// output type, and a transforming schema's *input* is a plain `string`, which
+// the two-parameter `z.ZodType<T>` (input defaults to output) rejects. Widening
+// the input to `unknown` is also the more honest signature for a parser whose
+// job is to accept whatever a file reader produced.
+//
+// `satisfies` only checks that the parser's output is assignable to the type —
+// a parser NARROWER than the type still passes — so the exactness guard is the
+// `expectTypeOf` assertion in the sibling test.
+//
+
+type BoundaryParser<T> = z.ZodType<T, z.ZodTypeDef, unknown>;
+
+const issue = (ctx: z.RefinementCtx, e: unknown) =>
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: e instanceof Error ? e.message : String(e),
+  });
+
+const kindSelectorReferenceSchema = z
+  .string()
+  .superRefine((value, ctx) => {
+    try {
+      parseKindSelectorReference(value as BlockKindSelectorReference);
+    } catch (e) {
+      issue(ctx, e);
+    }
+  })
+  .transform(
+    (value) => value as BlockKindSelectorReference,
+  ) satisfies BoundaryParser<BlockKindSelectorReference>;
+
+const blockPackReferenceSchema = z
+  .string()
+  .superRefine((value, ctx) => {
+    try {
+      parseBlockPackReference(value as BlockPackReference);
+    } catch (e) {
+      issue(ctx, e);
+    }
+  })
+  .transform((value) => value as BlockPackReference) satisfies BoundaryParser<BlockPackReference>;
+
+const blockPackLocationSchema = z
+  .string()
+  .superRefine((value, ctx) => {
+    try {
+      parseBlockPackLocation(value as BlockPackLocationReference);
+    } catch (e) {
+      issue(ctx, e);
+    }
+  })
+  .transform(
+    (value) => value as BlockPackLocationReference,
+  ) satisfies BoundaryParser<BlockPackLocationReference>;
+
+export const ProjectTemplateV1EntrySchema = z
+  .object({
+    id: z.string().min(1),
+    kind: kindSelectorReferenceSchema,
+    block: blockPackReferenceSchema.optional(),
+    location: blockPackLocationSchema.optional(),
+    // Omissible in the file, settled here: every reader downstream gets a mapping.
+    params: z.record(z.string(), z.unknown()).default({}),
+  })
+  .strict()
+  .superRefine((entry, ctx) => {
+    if (entry.block !== undefined && entry.location !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["location"],
+        message:
+          `An entry cannot carry both 'block' and 'location': the first pins which version ` +
+          `to install, the second pins where to install it from. Keep the one that is ` +
+          `actually meant.`,
+      });
+    }
+  })
+  .readonly()
+  // The refine above is what enforces the exclusion; this is what tells the type system it
+  // ran. A `z.union` of the two arms would carry the exclusion in the schema instead, at the
+  // cost of the error a reader gets: a union reports every arm's failure, so a misspelled
+  // `kind` would come back as two unrelated complaints about `block` and `location`.
+  .transform(
+    (entry) => entry as ProjectTemplateV1Entry,
+  ) satisfies BoundaryParser<ProjectTemplateV1Entry>;
+
+export const ProjectTemplateV1Schema = z
+  .object({
+    schema: z.literal(PROJECT_TEMPLATE_SCHEMA_V1),
+    blocks: z.array(ProjectTemplateV1EntrySchema).readonly(),
+  })
+  .strict()
+  .readonly()
+  .superRefine((doc, ctx) => {
+    const seen = new Set<string>();
+    doc.blocks.forEach((entry, i) => {
+      if (seen.has(entry.id)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["blocks", i, "id"],
+          message: `Duplicate template-local id: ${entry.id}`,
+        });
+      }
+      seen.add(entry.id);
+    });
+  }) satisfies BoundaryParser<ProjectTemplateV1>;
+
+/**
+ * Parse an already-decoded template document — the value a YAML or JSON reader
+ * returns — into a {@link ProjectTemplateV1}.
+ *
+ * Checks the format marker, every entry's shape, the reference grammars and id
+ * uniqueness. It does NOT check what an entry's params point at: params are opaque here,
+ * and the ordering rule they must satisfy is a statement about `blocks`, kept separate as
+ * {@link validateProjectTemplateV1References}.
+ *
+ * @throws {z.ZodError} on any of the above
+ */
+export function parseProjectTemplateV1(value: unknown): ProjectTemplateV1 {
+  return ProjectTemplateV1Schema.parse(value);
+}
+
+/** Why one reference is not usable, and which entry holds it. */
+export type TemplateReferenceProblem = {
+  /** The entry whose `params` hold the offending reference. */
+  readonly entryId: string;
+  /** The entry it references. */
+  readonly referencedId: string;
+  /**
+   * - `self` — the entry references an output of its own.
+   * - `forward` — the referenced entry is declared later, so it does not exist yet at the
+   *   point this entry is created.
+   */
+  readonly reason: "self" | "forward";
+  /** Human-readable form, suitable for showing to whoever triggered the export. */
+  readonly message: string;
+};
+
+/**
+ * Find every reference that does not name an entry declared EARLIER in `blocks`.
+ *
+ * The ordering rule — every block must appear after the blocks it references — checked
+ * across the whole document and reported per offending pair. Empty when the document is
+ * consistent.
+ *
+ * **A dangling reference is not among the findings, and cannot be.** The check asks which
+ * of the ids this document defines appear inside a reference payload (see
+ * {@link referencedBlockIds}), because the engine deliberately cannot read a payload's
+ * structure. An id naming no entry is therefore invisible — nothing separates it from the
+ * rest of the payload's text. That is part of the price of keeping the reference system out
+ * of the engine, and it is paid at apply time, where such a reference reaches its block
+ * unredirected.
+ */
+export function findProjectTemplateV1ReferenceProblems(
+  doc: ProjectTemplateV1,
+): TemplateReferenceProblem[] {
+  const problems: TemplateReferenceProblem[] = [];
+  const allIds = doc.blocks.map((e) => e.id);
+  const declaredBefore = new Set<string>();
+
+  for (const entry of doc.blocks) {
+    for (const referencedId of referencedBlockIds(entry.params, allIds)) {
+      if (referencedId === entry.id) {
+        problems.push({
+          entryId: entry.id,
+          referencedId,
+          reason: "self",
+          message: `Entry '${entry.id}' references its own output`,
+        });
+      } else if (!declaredBefore.has(referencedId)) {
+        problems.push({
+          entryId: entry.id,
+          referencedId,
+          reason: "forward",
+          message:
+            `Entry '${entry.id}' references entry '${referencedId}', which is declared after ` +
+            `it (blocks order is the instantiation order)`,
+        });
+      }
+    }
+    declaredBefore.add(entry.id);
+  }
+
+  return problems;
+}
+
+/**
+ * {@link findProjectTemplateV1ReferenceProblems} as human-readable lines, for a
+ * caller that only needs to show them.
+ */
+export function validateProjectTemplateV1References(doc: ProjectTemplateV1): string[] {
+  return findProjectTemplateV1ReferenceProblems(doc).map((p) => p.message);
+}
diff --git a/lib/model/common/src/template/template_ref.test.ts b/lib/model/common/src/template/template_ref.test.ts
new file mode 100644
index 0000000000..7b2f102de7
--- /dev/null
+++ b/lib/model/common/src/template/template_ref.test.ts
@@ -0,0 +1,157 @@
+import { describe, expect, test } from "vitest";
+import canonicalize from "canonicalize";
+import type { ColumnUniversalId } from "../drivers";
+import { createColumnFilteredId, createColumnDiscoveredId, stringifyColumnId } from "../drivers";
+import { createGlobalPObjectId } from "../pool";
+import { createPlRef } from "../ref";
+import { remapRefPayload, resolveTemplateRefs, toTemplateRef } from "./template_ref";
+
+/**
+ * The redirect, against identifiers that nest.
+ *
+ * These are the cases the engine is *not* supposed to know about — a filtered id over a
+ * discovered id over a leaf, escape padding, an id in a map key — asserted from the outside:
+ * whatever the reference system stacks up, redirecting a block id must leave a value the
+ * reference system still reads the same way.
+ */
+
+const leafId = (blockId: string, name: string) =>
+  createGlobalPObjectId(blockId, name) as ColumnUniversalId;
+
+const remap = <T>(payload: T, from: string, to: string): T =>
+  remapRefPayload(payload, new Map([[from, to]]));
+
+describe("nesting", () => {
+  test("a block id inside a wrapped identifier is redirected", () => {
+    const filtered = createColumnFilteredId({
+      source: leafId("old", "clonotypes"),
+      axisFilters: [[0, "IGH"]],
+    });
+
+    const remapped = remap(filtered, "old", "new");
+
+    expect(remapped).toBe(
+      createColumnFilteredId({ source: leafId("new", "clonotypes"), axisFilters: [[0, "IGH"]] }),
+    );
+  });
+
+  test("two levels of nesting are no different from one", () => {
+    // Filtered over discovered over a leaf: the block id is three JSON encodings deep.
+    const discovered = createColumnDiscoveredId({ column: leafId("old", "clonotypes") });
+    const filtered = createColumnFilteredId({
+      source: discovered as ColumnUniversalId,
+      axisFilters: [[0, "IGH"]],
+    });
+
+    const remapped = remap(filtered, "old", "new");
+
+    expect(remapped).toBe(
+      createColumnFilteredId({
+        source: createColumnDiscoveredId({
+          column: leafId("new", "clonotypes"),
+        }) as ColumnUniversalId,
+        axisFilters: [[0, "IGH"]],
+      }),
+    );
+  });
+
+  test("escape padding around the identifier is preserved exactly", () => {
+    // A value that was stringified again on the way into params: the id inside is reached, and
+    // the padding it was found in is put back.
+    const padded = JSON.stringify(leafId("old", "reads"));
+
+    expect(remap(padded, "old", "new")).toBe(JSON.stringify(leafId("new", "reads")));
+  });
+
+  test("the remapped identifier is still canonical", () => {
+    // Identity of an identifier IS its string, so a redirect that left it non-canonical would
+    // make two logically identical columns compare unequal everywhere downstream.
+    const filtered = createColumnFilteredId({
+      source: leafId("old", "clonotypes"),
+      axisFilters: [[0, "IGH"]],
+    });
+
+    const remapped = remap(filtered, "old", "new");
+
+    expect(remapped).toBe(canonicalize(JSON.parse(remapped)));
+  });
+
+  test("a mixed payload keeps its non-reference parts byte-for-byte", () => {
+    const payload = {
+      column: leafId("old", "reads"),
+      label: "old faithful",
+      threshold: 0.85,
+      note: null,
+    };
+
+    expect(remap(payload, "old", "new")).toEqual({
+      column: leafId("new", "reads"),
+      label: "old faithful",
+      threshold: 0.85,
+      note: null,
+    });
+  });
+
+  test("an identifier in a map KEY is redirected — but canonical order is not restored", () => {
+    // `ColumnDiscoveredKey.queriesQualifications` is the one place an identifier is a map key.
+    // Textual replacement reaches it like any other token, and that is the whole problem: the
+    // canonical form sorts keys, and a redirect changes what the sorted order should be. What
+    // comes out is valid JSON that is no longer canonical, so it is a different string from
+    // the identifier the same column would have in a fresh project.
+    // Two keys, so that sorted order is observable at all.
+    const discovered = createColumnDiscoveredId({
+      column: leafId("kept", "c"),
+      queriesQualifications: {
+        [leafId("zzz", "a")]: [],
+        [leafId("mmm", "b")]: [],
+      } as never,
+    });
+
+    const remapped = remap(discovered, "zzz", "aaa");
+
+    expect(remapped).toContain("aaa");
+    // The failure this pins: canonical form would sort the rewritten key differently.
+    expect(remapped).not.toBe(canonicalize(JSON.parse(remapped)));
+  });
+});
+
+describe("resolveTemplateRefs", () => {
+  test("wrappers come off and the payload keeps its own shape", () => {
+    const params = {
+      wire: toTemplateRef(createPlRef("old", "reads")),
+      anchor: toTemplateRef(leafId("old", "clonotypes")),
+      species: "hsa",
+    };
+
+    expect(resolveTemplateRefs(params, new Map([["old", "new"]]))).toEqual({
+      wire: createPlRef("new", "reads"),
+      anchor: leafId("new", "clonotypes"),
+      species: "hsa",
+    });
+  });
+
+  test("a key form wrapped as an object is redirected too", () => {
+    // Params hold key objects as well as canonical strings; neither is special here.
+    const key = { __isFiltered: true, source: leafId("old", "c"), axisFilters: [] };
+
+    expect(resolveTemplateRefs({ a: toTemplateRef(key) }, new Map([["old", "new"]]))).toEqual({
+      a: { __isFiltered: true, source: leafId("new", "c"), axisFilters: [] },
+    });
+  });
+
+  test("an empty map hands the payload back untouched, without a round trip", () => {
+    const payload = createPlRef("old", "reads");
+
+    expect(resolveTemplateRefs({ a: toTemplateRef(payload) }, new Map()).a).toBe(payload);
+  });
+
+  test("stringifyColumnId of a redirected key matches the redirected id", () => {
+    // The two directions agree: rewriting the string and rewriting the key then serializing
+    // it land on the same identifier.
+    const key = { __isRef: true, blockId: "old", name: "reads" };
+
+    expect(remap(stringifyColumnId(key), "old", "new")).toBe(
+      stringifyColumnId({ ...key, blockId: "new" }),
+    );
+  });
+});
diff --git a/lib/model/common/src/template/template_ref.ts b/lib/model/common/src/template/template_ref.ts
new file mode 100644
index 0000000000..3e32aa7b83
--- /dev/null
+++ b/lib/model/common/src/template/template_ref.ts
@@ -0,0 +1,153 @@
+/**
+ * The one thing a template engine knows about the data it carries.
+ *
+ * Everything a block projects into template params travels **as is**: the engine does not
+ * parse it, does not canonicalize it, and does not know a `PlRef` from a filtered column id
+ * from a linker path. The only structure it recognizes is this wrapper, and the block is who
+ * puts it there — see {@link toTemplateRef}.
+ *
+ * That is the whole point of the shape. A reference is the one thing a template cannot store
+ * verbatim, because the block ids inside it belong to the project that was exported, so the
+ * engine has to find those ids and redirect them. Making the block declare where they are
+ * means the engine needs no model of the reference system at all — and it stays correct when
+ * that system grows a sixth key form, a new nesting level, or a new place to hide an id.
+ *
+ * @typeParam T Whatever the block wrapped. The engine's view of it is `unknown`.
+ */
+export type TemplateRef<T = unknown> = { readonly $ref: T };
+
+/** {@link toTemplateRef}'s result: an absent value stays absent rather than wrapping nothing. */
+export type TemplateRefOf<T> = undefined extends T ? TemplateRef<T> | undefined : TemplateRef<T>;
+
+/**
+ * Mark a value in template params as carrying references the engine may redirect.
+ *
+ * Normally not called by a block: `wrapTemplateRefs` runs over whatever `templateParams()`
+ * returns and marks every column identifier in it, so wrapping is not something an author can
+ * forget. This is the escape hatch for the case that walk cannot recognize — a value that
+ * carries block ids without being an identifier, a foreign JSON document holding a reference
+ * — and a value already wrapped is left alone by the walk.
+ *
+ * `undefined` passes through unwrapped, so an optional field stays optional instead of
+ * becoming a wrapper around nothing.
+ */
+export function toTemplateRef<T>(value: T): TemplateRefOf<T> {
+  return (value === undefined ? undefined : { $ref: value }) as TemplateRefOf<T>;
+}
+
+/**
+ * Whether `value` is a {@link TemplateRef} — an object whose only key is `$ref`.
+ *
+ * Exact, because the shape is reserved anywhere inside opaque params. `$`-prefixed and
+ * single-key is about as narrow as a reserved shape gets, and it is the JSON-Schema spelling
+ * of the same idea, so it reads as a reference to someone who has never seen this format.
+ */
+export function isTemplateRef(value: unknown): value is TemplateRef {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 1 && keys[0] === "$ref";
+}
+
+/**
+ * Rewrite the block ids inside one reference payload, textually.
+ *
+ * The payload is serialized, every id in `blockIds` is replaced by the id it maps to, and the
+ * result is parsed back. No knowledge of the payload's shape is involved, which is the
+ * property that keeps the engine out of the reference system: an id nested under three
+ * wrapper layers, sitting in a map key, or escaped inside a string is reached the same way as
+ * one on a plain property.
+ *
+ * **Whole JSON string tokens only.** A block id always occupies a complete JSON string —
+ * as a value, or as a key where a map is keyed by identifier — so the pattern anchors on the
+ * quotes around it. Without that, an id like `a` would rewrite the `a` inside an unrelated
+ * `"reads"`. The quotes are allowed to carry escape backslashes, which is what reaches an id
+ * inside a payload that was stringified more than once, and they are put back as found.
+ *
+ * One pass with a single alternation, not a loop over the entries: replacing id by id would
+ * let a substitution rewrite a value some earlier substitution had just produced.
+ *
+ * An empty map returns the payload untouched, so a caller mapping ids to themselves gets its
+ * value back without a serialization round trip.
+ */
+export function remapRefPayload<T>(payload: T, blockIds: ReadonlyMap<string, string>): T {
+  if (blockIds.size === 0) return payload;
+  const serialized = JSON.stringify(payload);
+  if (serialized === undefined) return payload;
+  const rewritten = serialized.replace(
+    jsonTokenPattern([...blockIds.keys()]),
+    (_match, open: string, id: string, close: string) => `${open}${blockIds.get(id)!}${close}`,
+  );
+  return rewritten === serialized ? payload : (JSON.parse(rewritten) as T);
+}
+
+/**
+ * `ids` as whole JSON string tokens, with however many backslashes escape their quotes.
+ *
+ * `String.raw` so the pattern reads as the regex engine sees it: `\\*` is "any run of literal
+ * backslashes", and the run is what makes nesting depth irrelevant — one JSON encoding around
+ * the identifier means one backslash before its quotes, two means three, and so on. Written as
+ * an ordinary template literal the same pattern needs `\\\\*`, since the string literal eats
+ * one level of escaping before the engine sees anything.
+ */
+function jsonTokenPattern(ids: readonly string[]): RegExp {
+  const alternatives = ids.map(escapeForRegExp).join("|");
+  return new RegExp(String.raw`(\\*")(${alternatives})(\\*")`, "g");
+}
+
+const escapeForRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * Turn template params into live params: every reference payload has its block ids redirected
+ * and is then unwrapped, so what comes out is the shape the block projected.
+ *
+ * Unwrapping here rather than in the block is what lets a kind's params contract stay written
+ * in live terms — it never sees a wrapper, in the pre-flight check or at init.
+ *
+ * @param blockIds template-local entry id → project-local block id. Empty for the pre-flight
+ *   check, which runs before any block exists and only needs the params' shape.
+ */
+export function resolveTemplateRefs<T>(params: T, blockIds: ReadonlyMap<string, string>): T {
+  const walk = (node: unknown): unknown => {
+    if (isTemplateRef(node)) return remapRefPayload(node.$ref, blockIds);
+    if (Array.isArray(node)) return node.map(walk);
+    if (typeof node === "object" && node !== null) {
+      return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, walk(v)]));
+    }
+    return node;
+  };
+  return walk(params) as T;
+}
+
+/**
+ * Which of `candidates` one entry's params reference.
+ *
+ * Textual, for the same reason the rewrite is: the engine cannot look inside a payload, so it
+ * asks the opposite question — of the entry ids this document defines, which appear in there.
+ *
+ * Note what this cannot answer: it finds only ids it was given, so a reference to an id the
+ * document does NOT define is invisible here. Under the previous shape the engine parsed
+ * every identifier and could report that as a dangling reference before an apply began; it
+ * can no longer, and the price is that such a reference is discovered when the applied block
+ * turns out to be wired to nothing.
+ */
+export function referencedBlockIds(params: unknown, candidates: Iterable<string>): string[] {
+  const ids = [...candidates];
+  if (ids.length === 0) return [];
+
+  const payloads: string[] = [];
+  const collect = (node: unknown): void => {
+    if (isTemplateRef(node)) {
+      const serialized = JSON.stringify(node.$ref);
+      if (serialized !== undefined) payloads.push(serialized);
+      return;
+    }
+    if (Array.isArray(node)) {
+      node.forEach(collect);
+      return;
+    }
+    if (typeof node === "object" && node !== null) Object.values(node).forEach(collect);
+  };
+  collect(params);
+
+  return ids.filter((id) => payloads.some((payload) => jsonTokenPattern([id]).test(payload)));
+}
diff --git a/lib/model/common/src/template/template_wrap.test.ts b/lib/model/common/src/template/template_wrap.test.ts
new file mode 100644
index 0000000000..26bbdb4bf0
--- /dev/null
+++ b/lib/model/common/src/template/template_wrap.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, test } from "vitest";
+import type { ColumnUniversalId } from "../drivers";
+import { createColumnFilteredId } from "../drivers";
+import { createGlobalPObjectId, createLocalPObjectId } from "../pool";
+import { createPlRef } from "../ref";
+import { toTemplateRef } from "./template_ref";
+import { wrapTemplateRefs } from "./template_wrap";
+
+/**
+ * The half of the contract that knows the reference system.
+ *
+ * A block writes `templateParams()` in live terms and this finds the identifiers in what it
+ * returned. Everything downstream sees only `{ $ref: … }`, so what these tests pin is the one
+ * question the rest of the pipeline cannot answer for itself: which values are identifiers.
+ */
+
+const leafId = (blockId: string, name: string) =>
+  createGlobalPObjectId(blockId, name) as ColumnUniversalId;
+
+describe("wrapTemplateRefs", () => {
+  test("a PlRef is wrapped where it sits", () => {
+    const ref = createPlRef("samples", "reads");
+
+    expect(wrapTemplateRefs({ input: ref })).toEqual({ input: { $ref: ref } });
+  });
+
+  test("an identifier held as a canonical string is wrapped too", () => {
+    const id = leafId("samples", "reads");
+
+    expect(wrapTemplateRefs({ anchor: id })).toEqual({ anchor: { $ref: id } });
+  });
+
+  test("a wrapper form is wrapped as a whole, not descended into", () => {
+    // A filtered id nests another identifier inside its own string. Wrapping the outer one
+    // and stopping is what keeps the payload the value the block actually stored.
+    const filtered = createColumnFilteredId({
+      source: leafId("samples", "clonotypes"),
+      axisFilters: [[0, "IGH"]],
+    });
+
+    expect(wrapTemplateRefs({ anchor: filtered })).toEqual({ anchor: { $ref: filtered } });
+  });
+
+  test("a key object is wrapped as a whole rather than walked into", () => {
+    // Params hold key objects as well as canonical strings. Descending would wrap `source`
+    // separately and leave the key itself unmarked — the identifier would come apart.
+    const key = {
+      __isFiltered: true,
+      source: leafId("samples", "clonotypes"),
+      axisFilters: [[0, "IGH"]],
+    };
+
+    expect(wrapTemplateRefs({ anchor: key })).toEqual({ anchor: { $ref: key } });
+  });
+
+  test("identifiers are found at any depth, in objects and arrays alike", () => {
+    const a = createPlRef("samples", "reads");
+    const b = leafId("mixcr", "clones");
+
+    expect(
+      wrapTemplateRefs({ sources: [a], nested: { deeper: { anchor: b } }, species: "hsa" }),
+    ).toEqual({
+      sources: [{ $ref: a }],
+      nested: { deeper: { anchor: { $ref: b } } },
+      species: "hsa",
+    });
+  });
+
+  test("a local leaf is an identifier as well, though it carries no block id", () => {
+    // It has nothing to redirect, but marking it keeps the rule one sentence long: an
+    // identifier is wrapped, full stop.
+    const id = createLocalPObjectId(["pf", "byChain"], "abundance");
+
+    expect(wrapTemplateRefs({ column: id })).toEqual({ column: { $ref: id } });
+  });
+
+  test("an identifier under escape padding is recognized and stored as found", () => {
+    const padded = JSON.stringify(leafId("samples", "reads"));
+
+    expect(wrapTemplateRefs({ hit: padded })).toEqual({ hit: { $ref: padded } });
+  });
+
+  test("everything that is not an identifier is left exactly as it was", () => {
+    const params = {
+      species: "hsa",
+      sampleId: "3f1b8c2e-5d4a-4c9f-8b17-2a6e0d9f4c31",
+      note: `see {"not":"an id"}`,
+      count: 42,
+      enabled: true,
+      missing: null,
+      steps: [{ name: "filter", enabled: true }],
+      empty: {},
+    };
+
+    expect(wrapTemplateRefs(params)).toEqual(params);
+  });
+
+  test("a value the block wrapped by hand is left alone, not wrapped twice", () => {
+    // The escape hatch for a carrier this walk cannot recognize — a foreign document holding
+    // a reference, say. Taking the block's word for it is what makes the hatch usable.
+    const foreign = JSON.stringify({ wrapper: createPlRef("samples", "reads") });
+    const params = { odd: toTemplateRef(foreign) };
+
+    expect(wrapTemplateRefs(params)).toEqual({ odd: { $ref: foreign } });
+  });
+
+  test("params with nothing to mark come back unchanged", () => {
+    expect(wrapTemplateRefs({})).toEqual({});
+    expect(wrapTemplateRefs({ numbers: [3, 1, 2] })).toEqual({ numbers: [3, 1, 2] });
+  });
+});
diff --git a/lib/model/common/src/template/template_wrap.ts b/lib/model/common/src/template/template_wrap.ts
new file mode 100644
index 0000000000..aca6f2dd89
--- /dev/null
+++ b/lib/model/common/src/template/template_wrap.ts
@@ -0,0 +1,64 @@
+import { isColumnUniversalKey, peelJsonLayers } from "../drivers";
+import { isTemplateRef, toTemplateRef } from "./template_ref";
+
+/**
+ * Mark every column identifier in a block's projected params as a reference.
+ *
+ * The half of the template contract that DOES know the reference system, and the reason the
+ * engine does not have to. It runs inside the block's own model bundle, on whatever
+ * `templateParams()` returned, and wraps each identifier it recognizes in a
+ * {@link TemplateRef}. Downstream — document, file, apply — nothing else looks at what is
+ * inside those wrappers.
+ *
+ * Automatic rather than the block author's job on purpose. Wrapping is not a decision: a
+ * value either carries block ids or it does not, and this module can tell, while an author
+ * who forgot would produce a template that silently applies wired to nothing. It also keeps
+ * the kind's params contract written in live terms — `templateParams()` returns `Params`, not
+ * some template-shaped variant of it.
+ *
+ * What counts as an identifier is exactly what `isColumnUniversalKey` accepts, in either
+ * spelling: the key object (`PlRef` included — it IS `GlobalPObjectKey`) and the canonical
+ * string, at whatever escape depth the value happens to sit. Recognition stops there and the
+ * value is stored verbatim, so an identifier that nests other identifiers is wrapped once, as
+ * a whole.
+ *
+ * A value already wrapped is left alone, so a block with an unusual carrier — a foreign JSON
+ * document holding a reference, say — can wrap it by hand with {@link toTemplateRef} and have
+ * that survive this pass.
+ */
+export function wrapTemplateRefs<T>(params: T): T {
+  const walk = (node: unknown): unknown => {
+    // Already declared by the block: take its word and do not look inside.
+    if (isTemplateRef(node)) return node;
+
+    if (typeof node === "string") return isIdentifierString(node) ? toTemplateRef(node) : node;
+
+    // Before the generic object case: an identifier is an object too, and descending into one
+    // would wrap the strings nested inside it instead of the identifier as a whole.
+    if (isColumnUniversalKey(node)) return toTemplateRef(node);
+
+    if (Array.isArray(node)) return node.map(walk);
+
+    if (typeof node === "object" && node !== null) {
+      return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, walk(v)]));
+    }
+
+    return node;
+  };
+
+  return walk(params) as T;
+}
+
+/**
+ * Whether a params string is a canonical column identifier.
+ *
+ * Peeled first, so a value that was stringified again on its way into params is still
+ * recognized — the string is wrapped exactly as found, since the redirect works on the text
+ * and neither knows nor cares how many layers are around it.
+ *
+ * Ordinary strings are the common case and stop at the first character.
+ */
+function isIdentifierString(value: string): boolean {
+  const peeled = peelJsonLayers(value);
+  return peeled !== undefined && isColumnUniversalKey(peeled.value);
+}
diff --git a/lib/model/middle-layer/src/block_meta/block_description.ts b/lib/model/middle-layer/src/block_meta/block_description.ts
index 6c58809d4f..9ae3d7cc8f 100644
--- a/lib/model/middle-layer/src/block_meta/block_description.ts
+++ b/lib/model/middle-layer/src/block_meta/block_description.ts
@@ -4,7 +4,10 @@ import { BlockComponentsDescriptionRaw } from "./block_components";
 import { BlockPackMetaDescriptionRaw } from "./block_meta";
 import { BlockPackId } from "./block_id";
 import { toMerged } from "es-toolkit";
-import type { BlockCodeKnownFeatureFlags } from "@milaboratories/pl-model-common";
+import type {
+  BlockCodeKnownFeatureFlags,
+  BlockKindReference,
+} from "@milaboratories/pl-model-common";
 
 /**
  * Block-pack description: a `BlockPackId`, the typed `components` and `meta`
@@ -17,6 +20,9 @@ export type BlockPackDescription<Components, Meta> = {
   components: Components;
   meta: Meta;
   featureFlags?: BlockCodeKnownFeatureFlags;
+  /** Reference to the block kind this pack implements, in `{name}@{version}`
+   * form. Lifted from the model's container-level `kind` by build_dist. */
+  kind?: BlockKindReference;
 };
 
 /**
@@ -33,6 +39,9 @@ export const FeatureFlags = z
   .record(z.string(), z.union([z.boolean(), z.number()]))
   .transform((flags) => flags as BlockCodeKnownFeatureFlags);
 
+/** Block-kind reference schema — a plain `{name}@{version}` string at rest. */
+export const BlockKindRef = z.string().transform((s) => s as BlockKindReference);
+
 export function CreateBlockPackDescriptionSchema<
   Components extends ZodTypeAny,
   Meta extends ZodTypeAny,
@@ -43,6 +52,7 @@ export function CreateBlockPackDescriptionSchema<
       components,
       meta,
       featureFlags: FeatureFlags.optional(),
+      kind: BlockKindRef.optional(),
     })
     .passthrough();
 }
diff --git a/lib/node/pl-middle-layer/src/block_registry/index.ts b/lib/node/pl-middle-layer/src/block_registry/index.ts
index 2c655c345a..14b32b4829 100644
--- a/lib/node/pl-middle-layer/src/block_registry/index.ts
+++ b/lib/node/pl-middle-layer/src/block_registry/index.ts
@@ -1,3 +1,4 @@
 export * from "./registry";
 export * from "./registry-v2-provider";
 export * from "./well_known_registries";
+export * from "./template_provider";
diff --git a/lib/node/pl-middle-layer/src/block_registry/location_provider.test.ts b/lib/node/pl-middle-layer/src/block_registry/location_provider.test.ts
new file mode 100644
index 0000000000..5e4db4fb58
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/block_registry/location_provider.test.ts
@@ -0,0 +1,248 @@
+import { beforeAll, describe, expect, test } from "vitest";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { BlockPackLocationReference } from "@milaboratories/pl-model-common";
+import { resolveBlockPackLocation } from "./location_provider";
+
+/**
+ * The filesystem side of template import, driven against real directories.
+ *
+ * Everything here is about what is actually on disk — which layout is present, whether
+ * the kind survived the build, whether a path with a space still resolves — so these
+ * tests build the layouts rather than mock the readers. What each failure *says* to the
+ * reader is the resolver's, and lives with it.
+ */
+
+const KIND = "@milaboratories/milaboratories.test-loc.kind@1.2.3";
+
+let root: string;
+
+beforeAll(async () => {
+  root = await fsp.mkdtemp(path.join(os.tmpdir(), "template-location-"));
+});
+
+const locate = (dir: string) =>
+  resolveBlockPackLocation(pathToFileURL(dir).href as BlockPackLocationReference);
+
+/**
+ * A built-but-never-packed block: the source `package.json` names the components, and
+ * the kind is only in the compiled model. The shape a developer's working tree is in.
+ */
+async function writeDevBlock(
+  dir: string,
+  options: { title?: string; kind?: string | null } = {},
+): Promise<string> {
+  const { title = "Located Block", kind = KIND } = options;
+  await fsp.mkdir(path.join(dir, "ui"), { recursive: true });
+  await fsp.writeFile(
+    path.join(dir, "package.json"),
+    JSON.stringify({
+      name: "@milaboratories/milaboratories.test-loc",
+      version: "1.0.0",
+      block: {
+        components: {
+          workflow: "./main.plj.gz",
+          model: "./model.json",
+          ui: "./ui",
+        },
+        meta: {
+          title,
+          description: "A block used to exercise location resolution",
+          organization: { name: "MiLaboratories Inc", url: "https://milaboratories.com/" },
+        },
+      },
+    }),
+  );
+  await fsp.writeFile(path.join(dir, "main.plj.gz"), "workflow-bytes");
+  await fsp.writeFile(path.join(dir, "ui", "index.html"), "<html></html>");
+  // A real config container, because loading a source description normalizes the model
+  // to read its feature flags and refuses anything it cannot recognize. The render
+  // envelope is left empty: the kind sits above it, and nothing on this path runs the
+  // block.
+  await fsp.writeFile(
+    path.join(dir, "model.json"),
+    JSON.stringify({ v3: {}, code: {}, ...(kind === null ? {} : { kind }) }),
+  );
+  return dir;
+}
+
+/** A packed block: one manifest naming everything, kind included. */
+async function writePackedBlock(
+  dir: string,
+  options: { title?: string; kind?: string | null } = {},
+): Promise<string> {
+  const { title = "Packed Block", kind = KIND } = options;
+  await fsp.mkdir(dir, { recursive: true });
+  await fsp.writeFile(
+    path.join(dir, "manifest.json"),
+    JSON.stringify({
+      schema: "v2",
+      description: {
+        id: { organization: "milaboratories", name: "test-loc", version: "1.0.0" },
+        components: {
+          workflow: { type: "workflow-v1", main: { type: "relative", path: "main.plj.gz" } },
+          model: { type: "relative", path: "model.json" },
+          ui: { type: "relative", path: "ui.tgz" },
+        },
+        meta: {
+          title,
+          description: "A packed block used to exercise location resolution",
+          organization: { name: "MiLaboratories Inc", url: "https://milaboratories.com/" },
+        },
+        ...(kind === null ? {} : { kind }),
+      },
+      files: [],
+    }),
+  );
+  return dir;
+}
+
+describe("a block built from source", () => {
+  test("resolves to the dev spec pointing at that very folder", async () => {
+    const dir = await writeDevBlock(path.join(root, "dev-basic"));
+
+    const outcome = await locate(dir);
+
+    expect(outcome.ok).toBe(true);
+    if (!outcome.ok) return;
+    expect(outcome.spec).toEqual({ type: "dev-v2", folder: dir });
+    expect(outcome.title).toBe("Located Block");
+  });
+
+  test("its kind is read out of the compiled model", async () => {
+    // The source `package.json` carries no kind — it is recorded when the model is
+    // compiled — so requiring a re-pack to see it would make every edit cost one.
+    const dir = await writeDevBlock(path.join(root, "dev-kind"));
+
+    const outcome = await locate(dir);
+
+    expect(outcome.ok && outcome.kind).toBe(KIND);
+  });
+
+  test("a model with no kind resolves, but declares none", async () => {
+    // Left for the resolver to refuse: it is the side holding the entry that says
+    // which kind was expected.
+    const dir = await writeDevBlock(path.join(root, "dev-no-kind"), { kind: null });
+
+    const outcome = await locate(dir);
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.ok && outcome.kind).toBeUndefined();
+  });
+});
+
+describe("a packed block", () => {
+  test("resolves to the pack spec addressing the folder the manifest was read from", async () => {
+    const dir = await writePackedBlock(path.join(root, "packed"));
+
+    const outcome = await locate(dir);
+
+    expect(outcome.ok).toBe(true);
+    if (!outcome.ok) return;
+    expect(outcome.spec).toEqual({ type: "from-pack-v2", packUrl: pathToFileURL(dir).href });
+    expect(outcome.title).toBe("Packed Block");
+    expect(outcome.kind).toBe(KIND);
+  });
+
+  test("the manifest wins over a package.json beside it", async () => {
+    // A facade package that has been packed holds both shapes; the manifest is the
+    // built artifact, and it is what the preparer will read.
+    const dir = path.join(root, "both-shapes");
+    await writeDevBlock(dir);
+    await writePackedBlock(dir, { title: "Packed Block" });
+
+    const outcome = await locate(dir);
+
+    expect(outcome.ok && outcome.spec.type).toBe("from-pack-v2");
+    expect(outcome.ok && outcome.title).toBe("Packed Block");
+  });
+});
+
+describe("a folder that is not itself the block", () => {
+  test("the conventional 'block' subfolder is found", async () => {
+    // So a hand-written entry may name what a person calls the block. Export never
+    // writes this form: it emits the folder the loader accepts.
+    const parent = path.join(root, "parent-block");
+    await writeDevBlock(path.join(parent, "block"));
+
+    const outcome = await locate(parent);
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.ok && outcome.spec).toEqual({
+      type: "dev-v2",
+      folder: path.join(parent, "block"),
+    });
+  });
+
+  test("the 'meta' subfolder too", async () => {
+    const parent = path.join(root, "parent-meta");
+    await writeDevBlock(path.join(parent, "meta"));
+
+    const outcome = await locate(parent);
+
+    expect(outcome.ok && outcome.spec).toEqual({
+      type: "dev-v2",
+      folder: path.join(parent, "meta"),
+    });
+  });
+});
+
+describe("what cannot be read", () => {
+  test("a folder that does not exist is not-found", async () => {
+    const outcome = await locate(path.join(root, "nowhere-at-all"));
+
+    expect(outcome).toEqual({ ok: false, reason: "not-found" });
+  });
+
+  test("a folder that exists but holds nothing is not-a-block", async () => {
+    // The two are kept apart because they send the reader somewhere different: one is
+    // a template carried to another machine, the other is a path one level off.
+    const dir = path.join(root, "empty");
+    await fsp.mkdir(dir, { recursive: true });
+
+    const outcome = await locate(dir);
+
+    expect(outcome).toEqual({ ok: false, reason: "not-a-block" });
+  });
+
+  test("an ordinary npm package is not a block", async () => {
+    // A `package.json` with no block description must not reach the loader, which
+    // would throw rather than report.
+    const dir = path.join(root, "plain-package");
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(
+      path.join(dir, "package.json"),
+      JSON.stringify({ name: "just-a-package", version: "1.0.0" }),
+    );
+
+    const outcome = await locate(dir);
+
+    expect(outcome).toEqual({ ok: false, reason: "not-a-block" });
+  });
+
+  test("a scheme with no reader here is reported as such, not as a missing block", async () => {
+    const outcome = await resolveBlockPackLocation(
+      "https://blocks.internal/enter-numbers" as BlockPackLocationReference,
+    );
+
+    expect(outcome).toEqual({ ok: false, reason: "unsupported-scheme" });
+  });
+});
+
+describe("paths that need decoding", () => {
+  test("a folder whose name contains a space resolves", async () => {
+    // The value is a URL, so the space arrives as `%20`; reading the URL's pathname
+    // directly instead of converting it would look correct and never find the folder.
+    const dir = await writeDevBlock(path.join(root, "my blocks", "spaced"));
+
+    const location = pathToFileURL(dir).href;
+    expect(location).toContain("%20");
+
+    const outcome = await resolveBlockPackLocation(location as BlockPackLocationReference);
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.ok && outcome.spec).toEqual({ type: "dev-v2", folder: dir });
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/block_registry/location_provider.ts b/lib/node/pl-middle-layer/src/block_registry/location_provider.ts
new file mode 100644
index 0000000000..65388abdec
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/block_registry/location_provider.ts
@@ -0,0 +1,129 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type {
+  BlockKindReference,
+  BlockPackLocationReference,
+} from "@milaboratories/pl-model-common";
+import { parseBlockPackLocation } from "@milaboratories/pl-model-common";
+import type { BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
+import type { BlockPackDescriptionAbsolute } from "@platforma-sdk/block-tools";
+import { loadPackDescription, loadPackDescriptionFromManifest } from "@platforma-sdk/block-tools";
+import type { LocationResolution } from "../model/template_resolve";
+
+/**
+ * Read the block a template entry's `location` points at.
+ *
+ * The filesystem half of {@link BlockPackProvider}, and the reason a project built from
+ * locally developed blocks can be exported and applied without publishing anything. No
+ * registry is involved and nothing is searched: the entry named a place.
+ *
+ * Only `file:` is served. The document's grammar admits any scheme so that a template
+ * stays readable by a consumer that can fetch more than this one can, and an unknown
+ * scheme is reported rather than treated as a missing block — "I cannot read this" and
+ * "there is nothing there" send the reader to different places.
+ */
+export async function resolveBlockPackLocation(
+  location: BlockPackLocationReference,
+): Promise<LocationResolution> {
+  if (parseBlockPackLocation(location).scheme !== "file") {
+    return { ok: false, reason: "unsupported-scheme" };
+  }
+
+  // The value is a URL, never a path: `fileURLToPath` is what turns `%20` back into the
+  // space that was in the folder name. Reading `pathname` directly would look right and
+  // fail on any path with a space in it.
+  const dir = fileURLToPath(location);
+
+  const found = await readPackAt(dir);
+  if (found === undefined) {
+    return (await exists(dir))
+      ? { ok: false, reason: "not-a-block" }
+      : { ok: false, reason: "not-found" };
+  }
+
+  return { ok: true, spec: found.spec, title: found.description.meta.title, kind: found.kind };
+}
+
+/** One readable block pack: which spec addresses it, and what it declares. */
+type FoundPack = {
+  readonly spec: BlockPackSpec;
+  readonly description: BlockPackDescriptionAbsolute;
+  readonly kind: BlockKindReference | undefined;
+};
+
+/**
+ * Identify what kind of block pack is at `dir`, by looking rather than by being told.
+ *
+ * Two layouts can sit behind one `location`, and they anchor differently — a packed
+ * block at the folder holding its `manifest.json`, a source block at the folder holding
+ * the `package.json` that names its components. The document deliberately records only
+ * the URI, so the layout is established here, where the filesystem is: encoding it in
+ * the file instead would freeze today's two shapes into the format, and a template
+ * written last month would name a layout that has since moved.
+ *
+ * A packed layout is checked first because it is the more specific one: a facade
+ * package's own folder holds `package.json` and, once packed, `block-pack/` beside it
+ * — never `manifest.json` directly.
+ *
+ * When neither matches, the two conventional subfolders are tried. Those are the same
+ * names the dev-block scanner probes, so a hand-written entry may name the block's own
+ * folder rather than the package inside it. Export never emits these: it writes the
+ * anchor the loader accepts, so there is nothing to guess on a round trip.
+ */
+async function readPackAt(dir: string): Promise<FoundPack | undefined> {
+  const direct = await readPackExactlyAt(dir);
+  if (direct !== undefined) return direct;
+
+  for (const subfolder of ["block", "meta"]) {
+    const nested = await readPackExactlyAt(path.join(dir, subfolder));
+    if (nested !== undefined) return nested;
+  }
+
+  return undefined;
+}
+
+async function readPackExactlyAt(dir: string): Promise<FoundPack | undefined> {
+  if (await exists(path.join(dir, "manifest.json"))) {
+    const description = await loadPackDescriptionFromManifest(dir);
+    return {
+      // The pack directory is what the preparer expects to be handed, and it is where
+      // the manifest was just read from — not something reconstructed from a parent.
+      spec: { type: "from-pack-v2", packUrl: pathToFileURL(dir).href },
+      description,
+      kind: description.kind,
+    };
+  }
+
+  if (await hasBlockDescription(path.join(dir, "package.json"))) {
+    const description = await loadPackDescription(dir);
+    return { spec: { type: "dev-v2", folder: dir }, description, kind: description.kind };
+  }
+
+  return undefined;
+}
+
+/**
+ * Whether this `package.json` describes a block at all.
+ *
+ * Checked before handing the folder to the loader so that an ordinary npm package —
+ * anything with a `package.json` and no block description — comes back as "not a
+ * block" rather than as a thrown parse failure from inside the loader.
+ */
+async function hasBlockDescription(packageJsonPath: string): Promise<boolean> {
+  try {
+    const parsed: unknown = JSON.parse(await fsp.readFile(packageJsonPath, "utf-8"));
+    return typeof parsed === "object" && parsed !== null && "block" in parsed;
+  } catch {
+    return false;
+  }
+}
+
+async function exists(target: string): Promise<boolean> {
+  try {
+    await fsp.stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/lib/node/pl-middle-layer/src/block_registry/registry.ts b/lib/node/pl-middle-layer/src/block_registry/registry.ts
index b1d2678764..9fe4ac6237 100644
--- a/lib/node/pl-middle-layer/src/block_registry/registry.ts
+++ b/lib/node/pl-middle-layer/src/block_registry/registry.ts
@@ -14,11 +14,13 @@ import type {
   BlockPackId,
   BlockPackListing,
   BlockPackOverview,
+  BlockPackFromRegistryV2,
   RegistryEntry,
   RegistryStatus,
   SingleBlockPackOverview,
 } from "@milaboratories/pl-model-middle-layer";
 import { AnyChannel, StableChannel } from "@milaboratories/pl-model-middle-layer";
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
 
 async function getFileContent(path: string) {
   try {
@@ -301,4 +303,24 @@ export class BlockPackRegistry {
     const reg = this.v2Provider.getRegistry(regSpec.url);
     return await reg.getSpecificOverview(blockId, channel);
   }
+
+  /**
+   * Resolve a block-kind reference (`{name}@{selector}`) against a `remote-v2`
+   * registry to a concrete `from-registry-v2` block spec. Thin facade cloned
+   * from {@link getOverview}: resolve `registryId` → assert `remote-v2` →
+   * delegate to the reader's pure-core-backed `resolveKind`. All version-math
+   * lives in `@platforma-sdk/block-tools` (no backend involvement).
+   */
+  public async resolveKind(
+    registryId: string,
+    ref: BlockKindReference,
+    { allowUnstable }: { allowUnstable: boolean },
+  ): Promise<BlockPackFromRegistryV2> {
+    const regSpec = this.registries.find((reg) => reg.id === registryId)?.spec;
+    if (!regSpec) throw new Error(`Registry with id "${registryId}" not found`);
+    if (regSpec.type !== "remote-v2")
+      throw new Error(`Only "remote-v2" registries support block-kind resolution.`);
+    const reg = this.v2Provider.getRegistry(regSpec.url);
+    return await reg.resolveKind(ref, { allowUnstable });
+  }
 }
diff --git a/lib/node/pl-middle-layer/src/block_registry/template_provider.test.ts b/lib/node/pl-middle-layer/src/block_registry/template_provider.test.ts
new file mode 100644
index 0000000000..328dcf5f0a
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/block_registry/template_provider.test.ts
@@ -0,0 +1,275 @@
+import { describe, expect, test } from "vitest";
+import { KindResolutionError } from "@platforma-sdk/block-tools";
+import type {
+  BlockPackFromRegistryV2,
+  BlockPackId,
+  RegistryEntry,
+  SingleBlockPackOverview,
+} from "@milaboratories/pl-model-middle-layer";
+import type { BlockKindSelectorReference } from "@milaboratories/pl-model-common";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import type { KindAwareRegistry } from "./template_provider";
+import { kindCapableRegistryIds, templateBlockPackProvider } from "./template_provider";
+
+/**
+ * The registry-backed provider, driven against a fake registry.
+ *
+ * Everything specific to this adapter is in what it does with two registry answers:
+ * which registries it asks, in what order, which failure it reports when they disagree,
+ * and where the block's title comes from. None of that needs a registry to check.
+ */
+
+const KIND = "@platforma-open/milaboratories.demo.kind@^1.0.0" as BlockKindSelectorReference;
+
+const blockId = (name: string, version = "1.2.3"): BlockPackId => ({
+  organization: "milaboratories",
+  name,
+  version,
+});
+
+const specIn = (registryUrl: string, id: BlockPackId): BlockPackFromRegistryV2 => ({
+  type: "from-registry-v2",
+  registryUrl,
+  id,
+  channel: "stable",
+});
+
+const overviewOf = (registryUrl: string, id: BlockPackId, title: string): SingleBlockPackOverview =>
+  ({ id, meta: { title }, spec: specIn(registryUrl, id) }) as unknown as SingleBlockPackOverview;
+
+const silent: MiLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+} as unknown as MiLogger;
+
+/**
+ * A registry whose per-registry answers are scripted.
+ *
+ * @param answers Keyed by registry id. A `KindResolutionError` reason stands for "this
+ *   registry cannot satisfy the kind"; anything else thrown stands for a read failure
+ */
+function fakeRegistry(answers: {
+  kind?: Record<string, BlockPackId | KindResolutionError | Error>;
+  overview?: Record<string, Record<string, string>>;
+}) {
+  const kindCalls: { registryId: string; ref: string; allowUnstable: boolean }[] = [];
+  const overviewCalls: { registryId: string; id: BlockPackId; channel: string }[] = [];
+
+  const registry: KindAwareRegistry = {
+    resolveKind: (registryId, ref, options) => {
+      kindCalls.push({ registryId, ref, allowUnstable: options.allowUnstable });
+      const answer = answers.kind?.[registryId];
+      if (answer === undefined) {
+        return Promise.reject(new KindResolutionError("no-matching-kind-version", ref));
+      }
+      if (answer instanceof Error) return Promise.reject(answer);
+      return Promise.resolve(specIn(`https://${registryId}`, answer));
+    },
+    getOverview: (registryId, id, channel) => {
+      overviewCalls.push({ registryId, id, channel });
+      const title = answers.overview?.[registryId]?.[id.name];
+      if (title === undefined) return Promise.reject(new Error("no such manifest"));
+      return Promise.resolve(overviewOf(`https://${registryId}`, id, title));
+    },
+  };
+
+  return { registry, kindCalls, overviewCalls };
+}
+
+const providerOver = (registry: KindAwareRegistry, registryIds: string[]) =>
+  templateBlockPackProvider({ registry, registryIds, logger: silent });
+
+describe("kindCapableRegistryIds", () => {
+  const entries: RegistryEntry[] = [
+    { id: "main", spec: { type: "remote-v2", url: "https://main" } },
+    { id: "local:{/w/blocks}", spec: { type: "local-dev", path: "/w/blocks" } },
+    { id: "extra", spec: { type: "remote-v2", url: "https://extra" } },
+  ];
+
+  test("keeps the remote registries, in configured order", () => {
+    expect(kindCapableRegistryIds(entries)).toEqual(["main", "extra"]);
+  });
+
+  test("drops a dev registry, which can never answer a kind", () => {
+    // Dev packets have no manifest and no kind publication, and every template entry
+    // names a kind — so asking is not a fallback, it is a guaranteed failure that would
+    // muddy the reported reason.
+    expect(kindCapableRegistryIds([entries[1]])).toEqual([]);
+  });
+});
+
+describe("byKind", () => {
+  test("resolves through the registry and reports the block's published title", async () => {
+    const { registry, kindCalls, overviewCalls } = fakeRegistry({
+      kind: { main: blockId("demo") },
+      overview: { main: { demo: "Demo Block" } },
+    });
+
+    const outcome = await providerOver(registry, ["main"]).byKind(KIND, { allowUnstable: false });
+
+    expect(outcome).toEqual({
+      ok: true,
+      spec: specIn("https://main", blockId("demo")),
+      title: "Demo Block",
+    });
+    // The projection first, then the manifest of the block it picked.
+    expect(kindCalls).toEqual([{ registryId: "main", ref: KIND, allowUnstable: false }]);
+    expect(overviewCalls).toEqual([{ registryId: "main", id: blockId("demo"), channel: "stable" }]);
+  });
+
+  test("passes the selector through unchanged", async () => {
+    // The facade's parameter is typed as an exact reference, but resolution parses the
+    // version segment as a selector — so `^1.0.0` must arrive verbatim, not normalized.
+    const { registry, kindCalls } = fakeRegistry({
+      kind: { main: blockId("demo") },
+      overview: { main: { demo: "Demo Block" } },
+    });
+
+    await providerOver(registry, ["main"]).byKind(KIND, { allowUnstable: true });
+
+    expect(kindCalls[0].ref).toBe("@platforma-open/milaboratories.demo.kind@^1.0.0");
+    expect(kindCalls[0].allowUnstable).toBe(true);
+  });
+
+  test("falls through to the next registry, first hit winning", async () => {
+    const { registry, kindCalls } = fakeRegistry({
+      kind: { extra: blockId("demo") },
+      overview: { extra: { demo: "Demo Block" } },
+    });
+
+    const outcome = await providerOver(registry, ["main", "extra"]).byKind(KIND, {
+      allowUnstable: false,
+    });
+
+    expect(outcome.ok).toBe(true);
+    expect(kindCalls.map((c) => c.registryId)).toEqual(["main", "extra"]);
+  });
+
+  test("stops at the first registry that answers", async () => {
+    const { registry, kindCalls } = fakeRegistry({
+      kind: { main: blockId("demo"), extra: blockId("demo") },
+      overview: { main: { demo: "From Main" }, extra: { demo: "From Extra" } },
+    });
+
+    const outcome = await providerOver(registry, ["main", "extra"]).byKind(KIND, {
+      allowUnstable: false,
+    });
+
+    expect(outcome.ok && outcome.title).toBe("From Main");
+    expect(kindCalls.map((c) => c.registryId)).toEqual(["main"]);
+  });
+
+  test("reports the failure that got furthest when registries disagree", async () => {
+    // One registry has never heard of the kind, the other has it but only as a
+    // pre-release. Reporting the first would tell the reader to check their spelling,
+    // when the actual way out is to import again with unstable allowed.
+    const { registry } = fakeRegistry({
+      kind: {
+        main: new KindResolutionError("no-matching-kind-version", KIND),
+        extra: new KindResolutionError("no-stable-implementation", KIND),
+      },
+    });
+
+    const outcome = await providerOver(registry, ["main", "extra"]).byKind(KIND, {
+      allowUnstable: false,
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: "no-stable-implementation" });
+  });
+
+  test("no registry knowing the kind is not-found, not an error", async () => {
+    const { registry } = fakeRegistry({});
+
+    const outcome = await providerOver(registry, ["main", "extra"]).byKind(KIND, {
+      allowUnstable: false,
+    });
+
+    expect(outcome).toEqual({ ok: false, reason: "no-matching-kind-version" });
+  });
+
+  test("no registries at all is not-found rather than a crash", async () => {
+    // Reachable: an environment configured with only dev registries.
+    const { registry, kindCalls } = fakeRegistry({});
+
+    const outcome = await providerOver(registry, []).byKind(KIND, { allowUnstable: false });
+
+    expect(outcome).toEqual({ ok: false, reason: "no-matching-kind-version" });
+    expect(kindCalls).toEqual([]);
+  });
+
+  test("an unreadable registry propagates instead of reading as not-found", async () => {
+    // An outage is not a statement about the file, and reporting it as "no such kind"
+    // would send the reader to edit a file that is correct.
+    const { registry } = fakeRegistry({ kind: { main: new Error("ECONNREFUSED") } });
+
+    await expect(
+      providerOver(registry, ["main"]).byKind(KIND, { allowUnstable: false }),
+    ).rejects.toThrow("ECONNREFUSED");
+  });
+
+  test("a picked block whose manifest cannot be read propagates too", async () => {
+    // The kind resolved, so this is not a resolution failure — the registry is
+    // inconsistent or unreachable, and either way the file is not at fault.
+    const { registry } = fakeRegistry({ kind: { main: blockId("demo") } });
+
+    await expect(
+      providerOver(registry, ["main"]).byKind(KIND, { allowUnstable: false }),
+    ).rejects.toThrow("no such manifest");
+  });
+});
+
+describe("byExactVersion", () => {
+  test("reads the pinned version's manifest for both its spec and its title", async () => {
+    const { registry, overviewCalls } = fakeRegistry({
+      overview: { main: { demo: "Demo Block" } },
+    });
+
+    const outcome = await providerOver(registry, ["main"]).byExactVersion(blockId("demo", "2.0.1"));
+
+    expect(outcome).toEqual({
+      ok: true,
+      spec: specIn("https://main", blockId("demo", "2.0.1")),
+      title: "Demo Block",
+    });
+    expect(overviewCalls[0].channel).toBe("stable");
+  });
+
+  test("tries every registry before giving up", async () => {
+    const { registry, overviewCalls } = fakeRegistry({ overview: { extra: { demo: "Demo" } } });
+
+    const outcome = await providerOver(registry, ["main", "extra"]).byExactVersion(blockId("demo"));
+
+    expect(outcome.ok).toBe(true);
+    expect(overviewCalls.map((c) => c.registryId)).toEqual(["main", "extra"]);
+  });
+
+  test("a version no registry has is reported, not thrown", async () => {
+    // The entry pinned it, so this is a statement about the file — and resolution turns
+    // it into the message offering both ways out.
+    const { registry } = fakeRegistry({});
+
+    expect(await providerOver(registry, ["main"]).byExactVersion(blockId("gone", "9.9.9"))).toEqual(
+      { ok: false, reason: "no-such-block-version" },
+    );
+  });
+
+  test("every registry that could not answer is logged", async () => {
+    // The reader throws the same way for an absent block and an unreadable one, so the
+    // fallback cannot tell them apart. The log is the only place the reason survives.
+    const lines: string[] = [];
+    const logger = { info: (m: string) => lines.push(m), warn: () => {}, error: () => {} };
+    const { registry } = fakeRegistry({});
+
+    await templateBlockPackProvider({
+      registry,
+      registryIds: ["main", "extra"],
+      logger: logger as unknown as MiLogger,
+    }).byExactVersion(blockId("gone", "9.9.9"));
+
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toContain("milaboratories/gone 9.9.9");
+    expect(lines[0]).toContain("'main'");
+    expect(lines[0]).toContain("no such manifest");
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/block_registry/template_provider.ts b/lib/node/pl-middle-layer/src/block_registry/template_provider.ts
new file mode 100644
index 0000000000..9994af47cb
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/block_registry/template_provider.ts
@@ -0,0 +1,168 @@
+import { KindResolutionError } from "@platforma-sdk/block-tools";
+import type {
+  BlockPackFromRegistryV2,
+  BlockPackId,
+  RegistryEntry,
+  SingleBlockPackOverview,
+} from "@milaboratories/pl-model-middle-layer";
+import { StableChannel } from "@milaboratories/pl-model-middle-layer";
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import { ensureError } from "@platforma-sdk/model";
+import type { BlockPackProvider, ExactResolution, KindResolution } from "../model/template_resolve";
+import { resolveBlockPackLocation } from "./location_provider";
+
+/**
+ * The part of {@link BlockPackRegistry} a template's provider uses.
+ *
+ * Structural, so the provider can be exercised without a registry, a network or a
+ * configured environment — and so it is obvious that these two calls are the entire
+ * dependency.
+ */
+export type KindAwareRegistry = {
+  resolveKind: (
+    registryId: string,
+    ref: BlockKindReference,
+    options: { allowUnstable: boolean },
+  ) => Promise<BlockPackFromRegistryV2>;
+  getOverview: (
+    registryId: string,
+    blockId: BlockPackId,
+    channel: string,
+  ) => Promise<SingleBlockPackOverview>;
+};
+
+/**
+ * The ids of the configured registries a template can be resolved against, in the order
+ * they should be consulted.
+ *
+ * Answers the standing "which registry" question, and answers it by capability rather
+ * than by preference: kinds are published to the `kinds/` tree of a `remote-v2`
+ * registry, so no other registry type can satisfy an entry at all. A `local-dev`
+ * registry serves dev packets, which have no manifest and no kind publication — every
+ * template entry names a kind, so such a registry can never answer one.
+ *
+ * Configured order is kept: it is the order the environment chose, and the first
+ * registry that has the kind wins. Nothing here dedupes a kind published to two
+ * registries — with the search stopping at the first hit, the earlier registry is
+ * simply the answer.
+ */
+export function kindCapableRegistryIds(entries: readonly RegistryEntry[]): string[] {
+  return entries.filter((entry) => entry.spec.type === "remote-v2").map((entry) => entry.id);
+}
+
+/**
+ * A {@link BlockPackProvider} over the configured block registries.
+ *
+ * The adapter between the import path's port and what the registry layer already does:
+ * `resolveKind` walks a kind's projection and picks an implementing block,
+ * `getOverview` reads one block's manifest. Both live in the registry; the port exists
+ * so that resolution can be tested without one, and so that which registries to consult
+ * stays an environment decision.
+ *
+ * Both routes also return the block's published title, because both have to read a
+ * manifest to produce a spec anyway and nothing downstream can recover it. On the pinned
+ * route it is free; on the kind route it costs one manifest read after the projection.
+ *
+ * @param registryIds Registries to consult, in order — see {@link kindCapableRegistryIds}
+ * @param logger Where a registry that could not answer is recorded. A read failure and
+ *   an absent block are indistinguishable here (the reader throws for both), so the
+ *   fallback to the next registry has to swallow the reason; this is the only place it
+ *   survives
+ */
+export function templateBlockPackProvider(deps: {
+  readonly registry: KindAwareRegistry;
+  readonly registryIds: readonly string[];
+  readonly logger: MiLogger;
+}): BlockPackProvider {
+  const { registry, registryIds, logger } = deps;
+
+  return {
+    byKind: async (kind, options): Promise<KindResolution> => {
+      let furthest: KindResolutionFailure | undefined;
+
+      for (const registryId of registryIds) {
+        try {
+          // The selector brand is widened here, deliberately and in one place. The
+          // facade types this parameter as an exact `{name}@X.Y.Z` reference, but its
+          // implementation passes the version segment to the selector parser, so
+          // `~`/`^` resolve correctly — the type is narrower than the behaviour. Until
+          // the facade takes the selector brand, the cast is the honest way to say so.
+          const spec = await registry.resolveKind(
+            registryId,
+            kind as unknown as BlockKindReference,
+            options,
+          );
+          // Read back the manifest of the block the projection picked, in the channel it
+          // was picked from. `channel` is optional on the spec and the resolver always
+          // fills it, so the fallback is unreachable — it exists because the channel only
+          // decides where future update suggestions come from, and `stable` is the answer
+          // that surprises nobody.
+          const overview = await registry.getOverview(
+            registryId,
+            spec.id,
+            spec.channel ?? StableChannel,
+          );
+          return { ok: true, spec, title: overview.meta.title };
+        } catch (e) {
+          if (!(e instanceof KindResolutionError)) {
+            // Not an answer about this kind: an unreadable registry, or a registry that
+            // does not serve kinds at all. Falling through would report "no such kind"
+            // for what is really an outage, so it propagates instead. (The second case
+            // is unreachable through `kindCapableRegistryIds`, which filters by type.)
+            throw e;
+          }
+          furthest = furthestFailure(furthest, e.reason);
+        }
+      }
+
+      return { ok: false, reason: furthest ?? "no-matching-kind-version" };
+    },
+
+    // No registry is consulted for a located entry, and none of this adapter's
+    // registry knowledge applies to it — which is why it is a straight delegation.
+    byLocation: resolveBlockPackLocation,
+
+    byExactVersion: async (id): Promise<ExactResolution> => {
+      for (const registryId of registryIds) {
+        try {
+          // `stable` is recorded on the spec as the channel to watch for updates in.
+          // The entry pinned this exact version, so nothing is being chosen here — the
+          // channel only decides where a future update suggestion would come from.
+          const overview = await registry.getOverview(registryId, id, StableChannel);
+          return { ok: true, spec: overview.spec, title: overview.meta.title };
+        } catch (e) {
+          logger.info(
+            `template apply: block ${id.organization}/${id.name} ${id.version} not read ` +
+              `from registry '${registryId}': ${ensureError(e).message}`,
+          );
+        }
+      }
+
+      return { ok: false, reason: "no-such-block-version" };
+    },
+  };
+}
+
+type KindResolutionFailure = Extract<KindResolution, { ok: false }>["reason"];
+
+/**
+ * The more informative of two failures across registries.
+ *
+ * With several registries consulted, the reasons can differ — one has never heard of the
+ * kind, another has it but only as a pre-release. Reporting the first would tell the
+ * reader to check their spelling when the real answer is "import again with unstable
+ * allowed", so the one that got furthest wins.
+ */
+function furthestFailure(
+  current: KindResolutionFailure | undefined,
+  next: KindResolutionFailure,
+): KindResolutionFailure {
+  const rank: Record<KindResolutionFailure, number> = {
+    "no-matching-kind-version": 0,
+    "no-implementation": 1,
+    "no-stable-implementation": 2,
+  };
+  if (current === undefined) return next;
+  return rank[next] > rank[current] ? next : current;
+}
diff --git a/lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts b/lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts
index 17ceaf4731..1f908aab52 100644
--- a/lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts
+++ b/lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts
@@ -20,7 +20,24 @@ import {
   ProjectsField,
   ProjectsResourceType,
 } from "./project_list";
-import { createProject, duplicateProject, withProjectAuthored } from "../mutator/project";
+import {
+  createProject,
+  duplicateProject,
+  withProject,
+  withProjectAuthored,
+} from "../mutator/project";
+import type { ProjectTemplateExportOutcome } from "../model/template_serializer";
+import type { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
+import { extractConfig, ensureError } from "@platforma-sdk/model";
+import type { TemplateApplyProblem, TemplateApplyReport } from "../model/template_apply";
+import { TemplateEntryRejected, liveParamsForCheck } from "../model/template_apply";
+import type { BlockPackProvider } from "../model/template_resolve";
+import { resolveTemplateEntries } from "../model/template_resolve";
+import { validateTemplateV1ForApply } from "../model/template_validate";
+import type { PreparedTemplateEntry } from "../mutator/template_construct";
+import { applyTemplateEntries } from "../mutator/template_construct";
+import { throwIfMissingServerCapabilities } from "./project";
+import { cacheBlockPackTemplate } from "../mutator/template/template_cache";
 import { ProjectMetaKey } from "../model/project_model";
 import type { ProjectId } from "../model/project_model";
 import type { SynchronizedTreeState } from "@milaboratories/pl-tree";
@@ -75,6 +92,7 @@ import type {
   ProjectMeta,
   BlockPlatform,
 } from "@milaboratories/pl-model-middle-layer";
+import type { AppliedEntry } from "../model/template_apply";
 import { BlockUpdateWatcher } from "../block_registry/watcher";
 import type { QuickJSWASMModule } from "quickjs-emscripten";
 import { getQuickJS } from "quickjs-emscripten";
@@ -325,6 +343,159 @@ export class MiddleLayer {
     await this.projectListTree.refreshState();
   }
 
+  /**
+   * Renders a project as a `template-v1` YAML document, or reports every reason it
+   * cannot be — the backing call for an "Export Project as Template…" command.
+   *
+   * Takes a project id rather than an open {@link Project} because exporting is a
+   * property of the stored project, not of a session with it: the command belongs on
+   * a project card, where the project is usually closed. Opening one to read it would
+   * spin up trees and watchers for a one-shot read, and then have to decide whether to
+   * close them again.
+   *
+   * Read-only — the underlying mutator touches no field, so the transaction is never
+   * committed and the project list needs no refresh.
+   *
+   * @param id - project id of the project to export
+   */
+  public async exportProjectAsTemplate(id: ProjectId): Promise<ProjectTemplateExportOutcome> {
+    const rid = await this.resolveProjectId(id);
+    return await withProject(
+      this.env.projectHelper,
+      this.pl,
+      rid,
+      (prj) => prj.exportAsTemplateV1(),
+      { name: "exportProjectAsTemplate" },
+    );
+  }
+
+  /**
+   * Creates the blocks a `template-v1` document describes in an existing project, in the
+   * order the document lists them — the backing call for a "Create Project from Template
+   * file…" command, which is `createProject` followed by this.
+   *
+   * Takes a project id rather than an open {@link Project}, like
+   * {@link exportProjectAsTemplate} and for the same reason: applying a template is a
+   * property of the stored project, not of a session with it, and the flow that needs it
+   * has just created the project and has no session yet. An already-open session picks the
+   * new blocks up through its own refresh loop.
+   *
+   * Four stages, and their order is the design:
+   *
+   * 1. **Check the document** — reference consistency, and ids belonging to the project
+   *    the file was written in. All of it knowable from the file alone.
+   * 2. **Resolve every entry** to a concrete block pack, through `provider`.
+   * 3. **Prepare every block**: fetch it, check it can run against this backend, cache its
+   *    workflow template, and offer the entry's params to the block's kind for a shape
+   *    check.
+   * 4. **Create the blocks**, in one transaction.
+   *
+   * The first three create nothing, so any of them failing leaves the project exactly as
+   * it was. They are also what leaves stage 4 with only in-memory work, and hence able to be
+   * a single transaction.
+   *
+   * **Stage 4 is all or nothing too**, because it is that one transaction: an entry it cannot
+   * create throws, the transaction is never committed, and the project keeps none of the
+   * blocks the apply had placed. So `problems` non-empty always means `added` is empty, at
+   * every stage — a caller never has to reconcile a half-built project, and never has to ask
+   * which of the blocks present came from the file.
+   *
+   * @param id Project to apply into
+   * @param document A parsed template document
+   * @param provider Where each entry's block comes from
+   * @param options `allowUnstable` widens resolution to pre-release implementations, for
+   *   the whole document
+   */
+  public async applyTemplateToProject(
+    id: ProjectId,
+    document: ProjectTemplateV1,
+    provider: BlockPackProvider,
+    options: { allowUnstable?: boolean; author?: AuthorMarker } = {},
+  ): Promise<TemplateApplyReport> {
+    const documentProblems = validateTemplateV1ForApply(document);
+    if (documentProblems.length > 0) return { added: [], problems: documentProblems };
+
+    const resolution = await resolveTemplateEntries(document, provider, {
+      allowUnstable: options.allowUnstable ?? false,
+    });
+    if (resolution.problems.length > 0) return { added: [], problems: resolution.problems };
+
+    const paramsByEntry = new Map(document.blocks.map((entry) => [entry.id, entry.params]));
+    const prepared = new Map<string, PreparedTemplateEntry>();
+    const problems: TemplateApplyProblem[] = [];
+
+    for (const entry of resolution.resolved) {
+      try {
+        const preparedBp = await this.env.bpPreparer.prepare(entry.spec);
+        const blockCfg = extractConfig(preparedBp.config);
+
+        // The same two gates `Project.addBlock` applies, for the same reason: a block that
+        // cannot run here must not be installed. Here they become per-entry problems
+        // rather than throws, so one unusable block reads as one bad entry.
+        this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
+        throwIfMissingServerCapabilities(this.pl, preparedBp.requiredCapabilities);
+
+        const cachedBp = await cacheBlockPackTemplate(this.pl, preparedBp);
+
+        // Offered to the block's kind while nothing has been created yet. Every entry is
+        // checked, including one whose file omitted `params` — the parser read that as `{}`,
+        // which a kind with required fields rejects, and rightly: it would otherwise apply as
+        // a block that looks configured and is not.
+        const checked = this.env.projectHelper.validateTemplateParamsInVM(
+          blockCfg,
+          liveParamsForCheck(paramsByEntry.get(entry.entryId)!),
+        );
+        if (checked.error !== undefined) {
+          problems.push({ entryId: entry.entryId, error: checked.error.message });
+          continue;
+        }
+
+        // The block package's own title, the same thing the add-block UI writes. It is
+        // what the user sees for a block whose model derives no title of its own, and it
+        // is resolution's to supply — nothing here could reconstruct it.
+        prepared.set(entry.entryId, { blockPack: cachedBp, label: entry.title });
+      } catch (e) {
+        problems.push({
+          entryId: entry.entryId,
+          error: `This entry's block could not be installed: ${ensureError(e).message}`,
+        });
+      }
+    }
+
+    if (problems.length > 0) return { added: [], problems };
+
+    const rid = await this.resolveProjectId(id);
+    let added: AppliedEntry[] = [];
+    try {
+      await withProjectAuthored(
+        this.env.projectHelper,
+        this.pl,
+        rid,
+        options.author,
+        (mut) => {
+          added = applyTemplateEntries({
+            document,
+            placer: mut,
+            entries: prepared,
+            projectHelper: this.env.projectHelper,
+          });
+        },
+        // Under the same lock an open session's own mutations take, so an apply and a user
+        // editing the project cannot interleave.
+        { name: "applyTemplateToProject", lockId: `project:${id}` },
+      );
+    } catch (e: unknown) {
+      // A statement about the file: the transaction went with the throw, so the project kept
+      // none of the blocks the apply had placed, and `added` is empty by construction.
+      // Anything else — a backend that refused the write, say — is not about the file and
+      // keeps propagating.
+      if (!(e instanceof TemplateEntryRejected)) throw e;
+      return { added: [], problems: [{ entryId: e.entryId, error: e.message }] };
+    }
+
+    return { added, problems: [] };
+  }
+
   /** Permanently deletes project from the project list, this will result in
    * destruction of all attached objects, like files, analysis results etc. */
   public async deleteProject(id: ProjectId): Promise<void> {
diff --git a/lib/node/pl-middle-layer/src/middle_layer/project.ts b/lib/node/pl-middle-layer/src/middle_layer/project.ts
index 28874f6bc0..c88dca6c68 100644
--- a/lib/node/pl-middle-layer/src/middle_layer/project.ts
+++ b/lib/node/pl-middle-layer/src/middle_layer/project.ts
@@ -996,7 +996,7 @@ function convertErrorsToStrings(
  * the UI (`AddBlockModal`) and direct middle-layer callers (the MCP server's
  * `add_block` tool, programmatic block installs, tests) reject incompatible
  * blocks consistently. */
-function throwIfMissingServerCapabilities(
+export function throwIfMissingServerCapabilities(
   pl: PlClient,
   requiredCapabilities: readonly string[] | undefined,
 ): void {
diff --git a/lib/node/pl-middle-layer/src/model/args.ts b/lib/node/pl-middle-layer/src/model/args.ts
index a8face5a05..56290af33c 100644
--- a/lib/node/pl-middle-layer/src/model/args.ts
+++ b/lib/node/pl-middle-layer/src/model/args.ts
@@ -1,5 +1,6 @@
 import { assertNever } from "@milaboratories/ts-helpers";
 import type { PlRef } from "@platforma-sdk/model";
+import { peelJsonLayers } from "@milaboratories/pl-model-common";
 
 export function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {
   if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };
@@ -48,9 +49,15 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
     case "undefined":
       return;
     case "string": {
-      unwrapEmbeddedRef(node as string, (parsed) =>
-        addAllReferencedBlocks(result, parsed, allowed),
-      );
+      // A reference can be hiding inside a string under any number of `JSON.stringify`
+      // passes, and this walk would otherwise never reach it. Peeling is shared with the
+      // column-id remapper so that "how a value hides inside a string" has one
+      // definition; what happens at the bottom is not shared, and here it is deliberately
+      // broad — anything the peel produced is walked, including a foreign-schema document
+      // that merely contains a reference. That breadth is what makes this detector usable
+      // as a guard over carriers the template codec declines to touch.
+      const peeled = peelJsonLayers(node as string);
+      if (peeled !== undefined) addAllReferencedBlocks(result, peeled.value, allowed);
       return;
     }
     case "object": {
@@ -71,33 +78,6 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
   }
 }
 
-/**
- * Detect a PlRef carried inside a string and hand the decoded value to `onParsed`.
- *
- * A PlRef-as-string is canonical `{...}` optionally wrapped by N `JSON.stringify`
- * passes. Each pass adds a symmetric prefix/suffix made only of `"` and `\`
- * chars (the escape padding) of equal length. The regex below is the strict
- * shape gate — non-ref strings fail at the very first character, so we never
- * scan their body. One pass is peeled per call; deeper nesting is unwrapped
- * via recursion in the caller.
- */
-const EMBEDDED_REF_RE = /^(?<pre>[\\"]*)\{[\s\S]*?__isRef[\s\S]*\}(?<suf>[\\"]*)$/;
-
-function unwrapEmbeddedRef(s: string, onParsed: (value: unknown) => void) {
-  const c0 = s.charCodeAt(0);
-  if (c0 !== 0x7b /* { */ && c0 !== 0x22 /* " */) return;
-  const m = EMBEDDED_REF_RE.exec(s);
-  if (m === null) return;
-  if (m.groups!.pre.length !== m.groups!.suf.length) return;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(s);
-  } catch {
-    return;
-  }
-  if (parsed !== s) onParsed(parsed);
-}
-
 function recordRef(
   result: BlockUpstreams,
   blockId: string,
diff --git a/lib/node/pl-middle-layer/src/model/index.ts b/lib/node/pl-middle-layer/src/model/index.ts
index 87a698fba6..f751284feb 100644
--- a/lib/node/pl-middle-layer/src/model/index.ts
+++ b/lib/node/pl-middle-layer/src/model/index.ts
@@ -14,3 +14,26 @@ export {
 } from "./project_model";
 
 export * from "./sharing_model";
+
+// The template import path. A caller reads a file, parses it, creates a project and
+// applies the document — so the parser and the report types are as public as the
+// `MiddleLayer.applyTemplateToProject` that consumes them. `BlockPackProvider` is here
+// for the same reason: which registries to consult is the caller's decision.
+export { parseProjectTemplateV1Yaml, type TemplateParseOutcome } from "./template_parser";
+export { validateTemplateV1ForApply } from "./template_validate";
+export {
+  resolveTemplateEntries,
+  parseBlockPackName,
+  type BlockPackProvider,
+  type KindResolution,
+  type ExactResolution,
+  type ResolvedEntry,
+  type TemplateResolveOutcome,
+} from "./template_resolve";
+export {
+  TemplateEntryRejected,
+  liveParamsForCheck,
+  type AppliedEntry,
+  type TemplateApplyProblem,
+  type TemplateApplyReport,
+} from "./template_apply";
diff --git a/lib/node/pl-middle-layer/src/model/project_helper.ts b/lib/node/pl-middle-layer/src/model/project_helper.ts
index 2a4e69cfc7..56f4b058e7 100644
--- a/lib/node/pl-middle-layer/src/model/project_helper.ts
+++ b/lib/node/pl-middle-layer/src/model/project_helper.ts
@@ -40,6 +40,20 @@ export type MigrationResult =
  */
 type ArgsDeriveResult = { error: string } | { error?: undefined; value: unknown };
 
+/**
+ * Result of building initial storage from params.
+ * Returned by the __pl_storage_initialFromParams VM callback.
+ */
+type ParamsStorageResult =
+  | { error: string }
+  | { error?: undefined; storageJson: StringifiedJson<BlockStorage> };
+
+/**
+ * Result of checking params against their kind.
+ * Returned by the __pl_initializationParams_validate VM callback.
+ */
+type InitializationParamsValidateResult = { error: string } | { error?: undefined };
+
 export class ProjectHelper {
   private readonly enrichmentTargetsCache = new LRUCache<
     string,
@@ -131,6 +145,88 @@ export class ProjectHelper {
     }
   }
 
+  /**
+   * Derives this block's template-export params from storage JSON using the VM
+   * callback (`__pl_initializationParams_derive`).
+   *
+   * The template-export counterpart of {@link deriveArgsFromStorage}: instead of
+   * the args a workflow runs on, it returns the params that would recreate the
+   * block — the inverse of the data model's `init`. Params come back with every column
+   * identifier wrapped as a `{ $ref: … }`, done inside the block's own bundle, so nothing here
+   * has to know a kind's params shape or how a reference is spelled.
+   *
+   * A `{ value: undefined }` result means the block declares no `templateParams`, which only
+   * a block built against an older SDK can do. It does not reach a document: the export walk
+   * requires a mapping and reports anything else as that block's problem, so an entry always
+   * carries params.
+   *
+   * Unlike {@link derivePrerunArgsFromStorage}, a failure here is surfaced rather
+   * than swallowed — a prerun that cannot derive args just skips a block in
+   * staging, whereas an export that silently drops a block produces a template
+   * that does not describe the project.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param storageJson Storage as JSON string
+   * @returns The derived params with identifiers wrapped, `undefined` if the block declares
+   *   no lambda, or an error if derivation failed
+   */
+  public deriveTemplateParamsFromStorage(
+    blockConfig: BlockConfig,
+    storageJson: string,
+  ): ResultOrError<unknown> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error(
+          "deriveTemplateParamsFromStorage is only supported for model API version 2",
+        ),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.InitializationParamsDerive];
+
+    // A model built before this callback existed simply has no entry for it. That is
+    // NOT the same as a block declaring no `templateParams`: the block may well have
+    // params, we just have no way to ask for them. Reporting it as `undefined` params
+    // would export the block stripped of its configuration and quietly rebuild a
+    // differently-configured project, so it has to be an error.
+    // The message names the one action available to whoever pressed Export. It
+    // deliberately says nothing about SDKs or callbacks: the person reading it did
+    // not build this block and cannot change how it was built.
+    if (callback === undefined) {
+      return {
+        error: new Error(
+          "This version of the block cannot be written to a template. Update the block " +
+            "to a newer version and export again.",
+        ),
+      };
+    }
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        storageJson,
+      ) as ArgsDeriveResult;
+
+      if (result.error !== undefined) {
+        return { error: new Error(result.error) };
+      }
+      return { value: result.value };
+    } catch (e) {
+      const cause = ensureError(e);
+      // The reason goes in the message, not only in `cause`: this error is rendered
+      // into a per-block export problem and shown to whoever triggered the export,
+      // and every layer between here and there carries only `message`.
+      return {
+        error: new Error(`Template params derivation from storage failed: ${cause.message}`, {
+          cause,
+        }),
+      };
+    }
+  }
+
   private calculateEnrichmentTargets(req: EnrichmentTargetsRequest): PlRef[] | undefined {
     const blockConfig = req.blockConfig();
     if (blockConfig.enrichmentTargets === undefined) return undefined;
@@ -191,6 +287,133 @@ export class ProjectHelper {
     }
   }
 
+  /**
+   * Checks a template entry's params against the block's kind, creating nothing.
+   *
+   * The pre-flight half of {@link getInitialStorageFromParamsInVM}: run once per entry
+   * before a template is applied, so params a kind rejects are reported against the
+   * entry that carries them while there is still no project. Skipping it is safe —
+   * initialization runs the same check — but then the report arrives after earlier
+   * entries have already been created.
+   *
+   * Every kind declares a parser, so a pass here means the params were checked against
+   * the contract — not merely that they were JSON.
+   *
+   * A block whose model predates the callback passes unchecked rather than failing.
+   * Unlike initialization, this method creates nothing, so there is nothing to get wrong
+   * by proceeding, and such a block is refused outright at the point it is applied.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param params The entry's params. Reference ids may be placeholders: what is being
+   *   checked is the shape of the params, not what they point at
+   * @returns Nothing, or why the params were rejected
+   */
+  public validateTemplateParamsInVM(
+    blockConfig: BlockConfig,
+    params: unknown,
+  ): ResultOrError<undefined> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error("validateTemplateParamsInVM is only supported for model API version 2"),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.InitializationParamsValidate];
+    if (callback === undefined) return { value: undefined };
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        JSON.stringify(params ?? {}),
+      ) as InitializationParamsValidateResult;
+
+      if (result.error !== undefined) return { error: new Error(result.error) };
+      return { value: undefined };
+    } catch (e) {
+      const cause = ensureError(e);
+      return { error: new Error(`Params check failed to run: ${cause.message}`, { cause }) };
+    }
+  }
+
+  /**
+   * Creates initial BlockStorage for a block being created from template params.
+   *
+   * The inverse of {@link deriveTemplateParamsFromStorage}, and the reason a block
+   * can be created by anything other than the UI: it hands the params to the
+   * block's own init factory inside the model VM, so the resulting storage is
+   * whatever that block considers a correctly-initialized state.
+   *
+   * The caller must resolve references in `params` first — a reference reaching the
+   * factory has to name a block that already exists in the target project.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param params The entry's params, with references already resolved
+   * @returns The initial storage as JSON string, or why the params yield none
+   */
+  public getInitialStorageFromParamsInVM(
+    blockConfig: BlockConfig,
+    params: unknown,
+  ): ResultOrError<string> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error(
+          "getInitialStorageFromParamsInVM is only supported for model API version 2",
+        ),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.StorageInitialFromParams];
+
+    // A model built before this callback existed has no entry for it. Falling back
+    // to the params-less initializer is not an option: it would produce a
+    // default-configured block that looks like a successful apply, so the block the
+    // user gets would silently differ from the one the template describes.
+    //
+    // The message offers the two actions available to whoever applied the file. The
+    // second one is the reason this branch is reachable at all: kind resolution only
+    // ever returns a block that declares a kind, and such a block is new enough to
+    // support this — but an entry may pin an exact block version instead, bypassing
+    // resolution, and that pin can name anything ever published.
+    if (callback === undefined) {
+      return {
+        error: new Error(
+          "This version of the block cannot be created from a template. Use a newer " +
+            "version of the block, or remove the pinned block version from the template " +
+            "entry so a supported one is chosen automatically.",
+        ),
+      };
+    }
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        // Params cross the VM boundary as text, like storage does. `undefined` would
+        // stringify to nothing at all, and an entry with no params must go through
+        // the params-less initializer rather than reaching this method.
+        JSON.stringify(params ?? {}),
+      ) as ParamsStorageResult;
+
+      if (result.error !== undefined) return { error: new Error(result.error) };
+      return { value: result.storageJson };
+    } catch (e) {
+      const cause = ensureError(e);
+      // The reason goes in the message, not only in `cause`: this error becomes a
+      // per-entry apply problem shown to whoever triggered the import, and every
+      // layer in between carries only `message`.
+      return {
+        error: new Error(`Initial storage creation from params failed: ${cause.message}`, {
+          cause,
+        }),
+      };
+    }
+  }
+
   /**
    * Applies a state update using VM-based transformation.
    * This calls the model's `__pl_storage_applyUpdate` callback which:
diff --git a/lib/node/pl-middle-layer/src/model/project_helper_params_init.test.ts b/lib/node/pl-middle-layer/src/model/project_helper_params_init.test.ts
new file mode 100644
index 0000000000..992e1b9ae3
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/project_helper_params_init.test.ts
@@ -0,0 +1,234 @@
+import { beforeAll, describe, expect, test } from "vitest";
+import { getQuickJS, type QuickJSWASMModule } from "quickjs-emscripten";
+import type { BlockConfig, ResultOrError } from "@platforma-sdk/model";
+import { BlockStorageFacadeCallbacks } from "@platforma-sdk/model";
+import { ProjectHelper } from "./project_helper";
+
+/**
+ * `ProjectHelper.getInitialStorageFromParamsInVM` — the middle layer's side of the
+ * params-to-storage callback.
+ *
+ * The block model is hand-written here rather than loaded from a built block: the
+ * method's whole job is the boundary (does the callback exist, what crosses it as
+ * text, how each failure is reported), and a hand-written model is the only way to
+ * drive every failure branch on purpose. What the SDK puts behind the callback is
+ * covered by `sdk/model/src/template_init.test.ts`.
+ */
+
+const HANDLE = BlockStorageFacadeCallbacks.StorageInitialFromParams;
+
+/**
+ * A block model whose params callback body is `body`.
+ *
+ * Registration mirrors what the SDK's `tryRegisterCallback` does inside a real
+ * bundle: write the function into the render context's callback registry, which is
+ * where the invoker looks it up by handle.
+ */
+function modelCode(body: string): string {
+  return `globalThis.cfgRenderCtx.callbackRegistry[${JSON.stringify(HANDLE)}] = ${body};`;
+}
+
+/**
+ * A config carrying `code` and declaring the callback.
+ *
+ * Only three fields are read on this path — `modelAPIVersion`, the callback handle,
+ * and `code` — so the rest of `BlockConfig` (outputs, sections, inputsValid) is left
+ * out and the cast stands in for it.
+ */
+function configWith(
+  code: string,
+  options: { declareCallback?: boolean; modelAPIVersion?: number } = {},
+): BlockConfig {
+  const { declareCallback = true, modelAPIVersion = 2 } = options;
+  return {
+    modelAPIVersion,
+    sdkVersion: "1.0.0",
+    code: { type: "plain", content: code },
+    blockLifecycleCallbacks: declareCallback ? { [HANDLE]: { handle: HANDLE } } : {},
+  } as unknown as BlockConfig;
+}
+
+/** The storage the callback produced, parsed. Fails the test if it errored instead. */
+function storageFrom(result: ResultOrError<string>): unknown {
+  if (result.error !== undefined) throw new Error(`expected storage, got: ${result.error.message}`);
+  return JSON.parse(result.value);
+}
+
+let helper: ProjectHelper;
+let quickJs: QuickJSWASMModule;
+
+beforeAll(async () => {
+  quickJs = await getQuickJS();
+  helper = new ProjectHelper(quickJs);
+});
+
+describe("getInitialStorageFromParamsInVM", () => {
+  test("params reach the block's callback and its storage comes back", () => {
+    // The model echoes what it was given, so this asserts both directions of the
+    // boundary at once: the params arrived as text, the storage came back as text.
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode("(paramsJson) => ({ storageJson: paramsJson })")),
+      { numbers: [3, 1, 2], label: "run 1" },
+    );
+
+    expect(storageFrom(result)).toEqual({ numbers: [3, 1, 2], label: "run 1" });
+  });
+
+  test("a reference in params survives the crossing unchanged", () => {
+    // References are resolved before this call, so the concrete ids the applier
+    // just assigned must arrive byte-identical — a mangled `__isRef` object would
+    // produce a block wired to nothing.
+    const ref = { __isRef: true, blockId: "11111111-1111-4111-8111-111111111111", name: "reads" };
+
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode("(paramsJson) => ({ storageJson: paramsJson })")),
+      { source: ref },
+    );
+
+    expect(storageFrom(result)).toEqual({ source: ref });
+  });
+
+  test("absent params arrive as an empty object, never as the literal undefined", () => {
+    // `JSON.stringify(undefined)` is not a string at all, so the callback would be
+    // handed nothing and fail to parse. An entry with no params is supposed to go
+    // through the params-less initializer instead; this is the safety net.
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode("(paramsJson) => ({ storageJson: paramsJson })")),
+      undefined,
+    );
+
+    expect(storageFrom(result)).toEqual({});
+  });
+
+  test("a block that does not support params is reported, with the way out", () => {
+    // The load-bearing case: the old block CAN be added to a project, so silently
+    // falling back to default initialization would produce a block that looks
+    // applied but ignores everything the template said about it.
+    //
+    // The wording is asserted because it is the whole value of this branch. Whoever
+    // applied the file did not build the block and cannot rebuild it, so a message
+    // about SDKs or callbacks would leave them with nothing to do.
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode("(paramsJson) => ({ storageJson: paramsJson })"), {
+        declareCallback: false,
+      }),
+      { numbers: [1] },
+    );
+
+    expect(result.error?.message).toBe(
+      "This version of the block cannot be created from a template. Use a newer version " +
+        "of the block, or remove the pinned block version from the template entry so a " +
+        "supported one is chosen automatically.",
+    );
+  });
+
+  test("the callback's own error is passed through verbatim", () => {
+    // Params the block rejects — the expected failure for a hand-written template.
+    // The message is the block's, so it must not be wrapped or reworded.
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode('() => ({ error: "numbers must not be empty" })')),
+      { numbers: [] },
+    );
+
+    expect(result.error?.message).toBe("numbers must not be empty");
+  });
+
+  test("a throwing model is reported with its reason in the message", () => {
+    // Not the same as the case above: this is the model failing rather than
+    // declining. The reason has to reach `message`, since that is all the layers
+    // between here and the user carry.
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode('() => { throw new Error("boom"); }')),
+      { numbers: [1] },
+    );
+
+    expect(result.error?.message).toContain("Initial storage creation from params failed");
+    expect(result.error?.message).toContain("boom");
+  });
+
+  test("a v1 block is rejected outright", () => {
+    const result = helper.getInitialStorageFromParamsInVM(
+      configWith(modelCode("(paramsJson) => ({ storageJson: paramsJson })"), {
+        modelAPIVersion: 1,
+      }),
+      { numbers: [1] },
+    );
+
+    expect(result.error?.message).toMatch(/only supported for model API version 2/);
+  });
+});
+
+describe("validateTemplateParamsInVM", () => {
+  const VALIDATE = BlockStorageFacadeCallbacks.InitializationParamsValidate;
+
+  /** A model registering only the validate callback, with `body` as its implementation. */
+  const validatorConfig = (body: string, options: { declareCallback?: boolean } = {}) => {
+    const { declareCallback = true } = options;
+    return {
+      modelAPIVersion: 2,
+      sdkVersion: "1.0.0",
+      code: {
+        type: "plain",
+        content: `globalThis.cfgRenderCtx.callbackRegistry[${JSON.stringify(VALIDATE)}] = ${body};`,
+      },
+      blockLifecycleCallbacks: declareCallback ? { [VALIDATE]: { handle: VALIDATE } } : {},
+    } as unknown as BlockConfig;
+  };
+
+  test("params the kind accepts come back with no error and nothing else", () => {
+    // Every kind declares a parser, so a pass needs no flag saying whether anything ran:
+    // reaching here without an error means the params were held to the contract.
+    const result = helper.validateTemplateParamsInVM(validatorConfig("() => ({})"), {
+      numbers: [1, 2],
+    });
+
+    expect(result.error).toBeUndefined();
+  });
+
+  test("params the kind rejects come back with the kind's reason", () => {
+    // The whole point of the pre-flight: this is reported against the entry that
+    // carries the params, with no project created yet.
+    const result = helper.validateTemplateParamsInVM(
+      validatorConfig('() => ({ error: "numbers: Expected array, received string" })'),
+      { numbers: "1,2,3" },
+    );
+
+    expect(result.error?.message).toBe("numbers: Expected array, received string");
+  });
+
+  test("a block whose model predates the callback passes unchecked", () => {
+    // Unlike initialization, this creates nothing, so there is nothing to get wrong by
+    // proceeding — and such a block is refused outright at the point it is applied.
+    const result = helper.validateTemplateParamsInVM(
+      validatorConfig("() => ({})", { declareCallback: false }),
+      { numbers: [1] },
+    );
+
+    expect(result.error).toBeUndefined();
+  });
+
+  test("params reach the check as text, references included", () => {
+    // A reference id here may be a placeholder — the check runs before blocks exist —
+    // so what crosses must be the shape, unaltered.
+    const result = helper.validateTemplateParamsInVM(
+      validatorConfig("(paramsJson) => ({ error: paramsJson })"),
+      { source: { __isRef: true, blockId: "placeholder", name: "reads" } },
+    );
+
+    expect(JSON.parse(result.error!.message)).toEqual({
+      source: { __isRef: true, blockId: "placeholder", name: "reads" },
+    });
+  });
+
+  test("a check that throws is reported as failing to run", () => {
+    // Distinct from a rejection: the kind did not decline the params, its own code
+    // broke.
+    const result = helper.validateTemplateParamsInVM(
+      validatorConfig('() => { throw new Error("schema is broken"); }'),
+      { numbers: [1] },
+    );
+
+    expect(result.error?.message).toContain("Params check failed to run");
+    expect(result.error?.message).toContain("schema is broken");
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_apply.ts b/lib/node/pl-middle-layer/src/model/template_apply.ts
new file mode 100644
index 0000000000..628c5daa02
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_apply.ts
@@ -0,0 +1,76 @@
+import { resolveTemplateRefs } from "@milaboratories/pl-model-common";
+
+/**
+ * One entry the file describes in a way this project cannot honour.
+ *
+ * Thrown, not returned, and that is the whole failure policy: an apply either creates every
+ * entry or creates none. It travels out through the open transaction, which is therefore
+ * never committed, so a rejected file leaves the project exactly as it was. The caller turns
+ * it into a {@link TemplateApplyProblem}; anything else reaching that caller is an outage
+ * rather than a statement about the file, and keeps propagating.
+ */
+export class TemplateEntryRejected extends Error {
+  constructor(
+    readonly entryId: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "TemplateEntryRejected";
+  }
+}
+
+/**
+ * Params in live shape, with each entry's template-local id standing in for the block id it
+ * has not been given yet.
+ *
+ * For the pre-flight check, which runs before any block exists and therefore before any
+ * reference can be redirected. Checking the file form directly would not work: a kind
+ * describing a param as a reference sees the `{ $ref: … }` wrapper and rejects it, so every
+ * entry with a reference would fail a check meant to catch the opposite. Unwrapping with
+ * nothing to redirect asks the only question this stage can answer — are these params the
+ * right shape — and leaves what they point at to validation, which already owns it.
+ *
+ * The ids stay the file's own rather than becoming invented placeholders: nothing dereferences
+ * them here, and if one surfaces in a kind's rejection message it names something the reader
+ * can find in their file.
+ */
+export function liveParamsForCheck(params: Record<string, unknown>): Record<string, unknown> {
+  return resolveTemplateRefs(params, new Map());
+}
+
+/**
+ * Something that stopped one entry from being applied.
+ *
+ * Every stage of an apply reports in this shape — resolution, validation,
+ * construction — so a caller assembles one list and the reader sees which entry in
+ * their file each problem belongs to. `error` is a finished sentence for the person
+ * who applied the file, not a code.
+ */
+export type TemplateApplyProblem = {
+  /** The template-local id of the entry the problem belongs to. */
+  readonly entryId: string;
+  readonly error: string;
+};
+
+/** One entry that made it into the project. */
+export type AppliedEntry = {
+  /** The entry's id in the file. */
+  readonly templateLocalId: string;
+  /** The project-local id the block was given. */
+  readonly blockId: string;
+};
+
+/**
+ * What a whole apply — reading, checking, resolving, placing — left behind.
+ *
+ * One shape for every stage's findings, because the reader does not care which stage
+ * objected. `problems` empty means the project holds exactly what the document described;
+ * otherwise `added` is empty, because no stage creates anything until every entry has passed.
+ *
+ * A stage that checks reports every problem it found, so a file with three mistakes takes one
+ * pass to fix. Placement stops at the first one — hence at most one problem from there.
+ */
+export type TemplateApplyReport = {
+  readonly added: readonly AppliedEntry[];
+  readonly problems: readonly TemplateApplyProblem[];
+};
diff --git a/lib/node/pl-middle-layer/src/model/template_export.test.ts b/lib/node/pl-middle-layer/src/model/template_export.test.ts
new file mode 100644
index 0000000000..857fd9c2df
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_export.test.ts
@@ -0,0 +1,255 @@
+import { describe, expect, test } from "vitest";
+import canonicalize from "canonicalize";
+import { createPlRef, toTemplateRef } from "@milaboratories/pl-model-common";
+import type { ProjectStructure } from "./project_model";
+import type { TemplateParamsResult } from "./template_export";
+import { walkProjectForTemplateExport } from "./template_export";
+
+function simpleStructure(...ids: string[]): ProjectStructure {
+  return {
+    groups: [
+      {
+        id: "g1",
+        label: "G1",
+        blocks: ids.map((id) => ({ id, label: id, renderingMode: "Heavy" })),
+      },
+    ],
+  };
+}
+
+/** A provider backed by a plain map; blocks absent from it yield `undefined`. */
+function providerFrom(params: Record<string, TemplateParamsResult>) {
+  return (blockId: string): TemplateParamsResult | undefined => params[blockId];
+}
+
+const ok = (value: unknown): TemplateParamsResult => ({ value });
+
+describe("order", () => {
+  test("entries come out in structure order — no sort, none needed", () => {
+    // The structure IS the topological order: a block can only legally reference
+    // blocks above it, so emitting in this order gives a template file the ordering
+    // it needs — every block after the blocks it references — for free.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("samples", "mixcr", "browser"),
+      providerFrom({
+        samples: ok({ dataset: "bulk-rna" }),
+        mixcr: ok({ input: { block: "samples", output: "reads" } }),
+        browser: ok({ clonotypes: { block: "mixcr", output: "clonotypes" } }),
+      }),
+    );
+
+    expect(walk.problems).toEqual([]);
+    expect(walk.entries.map((e) => e.blockId)).toEqual(["samples", "mixcr", "browser"]);
+  });
+
+  test("structure order wins over reference order", () => {
+    // Same three blocks, structure reordered. The walk reports what the project
+    // says, so a structure that violates the ordering rule produces a file that
+    // reference validation rejects — it is not silently fixed here, because
+    // reordering would change which references are even legal.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("browser", "samples", "mixcr"),
+      providerFrom({ browser: ok({}), samples: ok({}), mixcr: ok({}) }),
+    );
+
+    expect(walk.entries.map((e) => e.blockId)).toEqual(["browser", "samples", "mixcr"]);
+  });
+
+  test("groups are flattened in order", () => {
+    const structure: ProjectStructure = {
+      groups: [
+        { id: "g1", label: "G1", blocks: [{ id: "a", label: "a", renderingMode: "Heavy" }] },
+        {
+          id: "g2",
+          label: "G2",
+          blocks: [
+            { id: "b", label: "b", renderingMode: "Heavy" },
+            { id: "c", label: "c", renderingMode: "Heavy" },
+          ],
+        },
+      ],
+    };
+
+    const walk = walkProjectForTemplateExport(
+      structure,
+      providerFrom({ a: ok({}), b: ok({}), c: ok({}) }),
+    );
+
+    expect(walk.entries.map((e) => e.blockId)).toEqual(["a", "b", "c"]);
+  });
+
+  test("an empty project walks to an empty template", () => {
+    expect(walkProjectForTemplateExport(simpleStructure(), providerFrom({}))).toEqual({
+      entries: [],
+      problems: [],
+    });
+  });
+});
+
+describe("collecting each block's descriptor output", () => {
+  test("params are carried through untouched", () => {
+    // The walk does not reshape params — references were already rewritten into
+    // template form on the SDK side, so there is nothing kind-specific to do here.
+    const params = {
+      species: "human",
+      input: { block: "samples", output: "reads" },
+      thresholds: [0.1, 0.2],
+    };
+
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("mixcr"),
+      providerFrom({ mixcr: ok(params) }),
+    );
+
+    expect(walk.entries).toEqual([{ blockId: "mixcr", params }]);
+  });
+
+  test("a block with nothing to project yields empty params", () => {
+    // Every block declares the lambda, so "no params at all" is not an outcome the walk
+    // can produce. A block whose state carries nothing worth restoring returns `{}`.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("pool-explorer"),
+      providerFrom({ "pool-explorer": ok({}) }),
+    );
+
+    expect(walk.entries).toEqual([{ blockId: "pool-explorer", params: {} }]);
+    expect(walk.problems).toEqual([]);
+  });
+});
+
+describe("what the walk does with params", () => {
+  const UUID_A = "3f1b8c2e-5d4a-4c9f-8b17-2a6e0d9f4c31";
+  const UUID_B = "9c7e4d10-2b83-4f6a-91d5-7e0c3a8b5f42";
+
+  /** A canonical global-leaf identifier, i.e. a reference held as a string. */
+  const leafId = (blockId: string, name: string) => canonicalize({ __isRef: true, blockId, name })!;
+
+  test("params are written exactly as the block projected them", () => {
+    // The walk parses nothing and rewrites nothing: a template-local entry id IS the block's
+    // own id, so a wrapped reference already names the right entry.
+    const params = { input: toTemplateRef(createPlRef(UUID_A, "reads")), species: "hsa" };
+    const walk = walkProjectForTemplateExport(
+      simpleStructure(UUID_A, UUID_B),
+      providerFrom({ [UUID_A]: ok({}), [UUID_B]: ok(params) }),
+    );
+
+    expect(walk.problems).toEqual([]);
+    expect(walk.entries[1].params).toBe(params);
+  });
+
+  test("a non-UUID id passes through unchanged too", () => {
+    // `Project.addBlock` accepts an explicit id and only *defaults* it to a random UUID, so
+    // "UUID" describes the common case, not a constraint.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("block1"),
+      providerFrom({ block1: ok({}) }),
+    );
+
+    expect(walk.entries).toEqual([{ blockId: "block1", params: {} }]);
+  });
+
+  test("a wrapper's contents are never inspected, whatever they are", () => {
+    // An identifier as a string, one under escape padding, a whole nested structure — all the
+    // same to the walk, which is the property the wrapper exists to buy.
+    const params = {
+      asObject: toTemplateRef(createPlRef("a", "reads")),
+      asString: toTemplateRef(leafId("a", "clones")),
+      stringified: toTemplateRef(JSON.stringify(leafId("a", "clones"))),
+      nested: { deeper: [toTemplateRef([createPlRef("a", "x")])] },
+    };
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("a", "b"),
+      providerFrom({ a: ok({}), b: ok(params) }),
+    );
+
+    expect(walk.problems).toEqual([]);
+    expect(walk.entries[1].params).toBe(params);
+  });
+
+  test("a reference the block did not wrap is written out as data, not refused", () => {
+    // The engine exposes the wrapper mechanic and models nothing else, so it has no opinion
+    // about an unwrapped `PlRef` — it is a value like any other. Wrapping the right things is
+    // the block's statement to make, and getting it wrong yields a template that does not
+    // work, the same way a wrong field name would. Pinned so the boundary stays deliberate.
+    const params = { input: createPlRef("a", "reads") };
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("a", "b"),
+      providerFrom({ a: ok({}), b: ok(params) }),
+    );
+
+    expect(walk.problems).toEqual([]);
+    expect(walk.entries[1].params).toBe(params);
+  });
+
+  test("a reference to a block outside the project is written out too", () => {
+    // Same boundary from the other side: telling this apart would mean recognizing which
+    // strings are identifiers, which is exactly the knowledge the engine does not hold. It
+    // surfaces on apply, as a block wired to nothing.
+    const params = { input: toTemplateRef(createPlRef("deleted", "reads")) };
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("b"),
+      providerFrom({ b: ok(params) }),
+    );
+
+    expect(walk.problems).toEqual([]);
+    expect(walk.entries[0].params).toBe(params);
+  });
+});
+
+describe("problems", () => {
+  test("a failed derivation is reported against its block, and the walk continues", () => {
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("a", "b", "c"),
+      providerFrom({
+        a: ok({ x: 1 }),
+        b: { error: "templateParams() threw: not exportable yet" },
+        c: ok({ z: 3 }),
+      }),
+    );
+
+    // Every offending block is reported at once rather than aborting on the
+    // first, so the user fixes them in one pass.
+    expect(walk.problems).toEqual([
+      { blockId: "b", error: "templateParams() threw: not exportable yet" },
+    ]);
+    expect(walk.entries.map((e) => e.blockId)).toEqual(["a", "c"]);
+  });
+
+  test("a block with unreadable state is a problem, not a silent skip", () => {
+    // `productionGraph` skips blocks it has no args for; export must not, because
+    // a template that quietly omits a block does not describe the project — and
+    // the surviving entries may still reference the omitted one.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("a", "ghost"),
+      providerFrom({ a: ok({}) }),
+    );
+
+    expect(walk.entries.map((e) => e.blockId)).toEqual(["a"]);
+    expect(walk.problems).toEqual([
+      {
+        blockId: "ghost",
+        error: "Block state is unavailable, so its template params could not be derived",
+      },
+    ]);
+  });
+
+  test.each([
+    { label: "a string", value: "not-params", expected: "a string" },
+    { label: "a number", value: 42, expected: "a number" },
+    { label: "null", value: null, expected: "null" },
+    { label: "an array", value: [1, 2], expected: "an array" },
+  ])("non-object params are rejected: $label", ({ value, expected }) => {
+    // An entry's `params` must be a mapping. A block kind carries its params type
+    // as a TypeScript type only, with no runtime schema, so nothing upstream
+    // enforces this — the walk is the only place that can catch it.
+    const walk = walkProjectForTemplateExport(
+      simpleStructure("odd"),
+      providerFrom({ odd: ok(value) }),
+    );
+
+    expect(walk.entries).toEqual([]);
+    expect(walk.problems).toEqual([
+      { blockId: "odd", error: `templateParams() must return an object, got ${expected}` },
+    ]);
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_export.ts b/lib/node/pl-middle-layer/src/model/template_export.ts
new file mode 100644
index 0000000000..c0cd433ca0
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_export.ts
@@ -0,0 +1,136 @@
+import type { ProjectStructure } from "./project_model";
+import { allBlocks } from "./project_model_util";
+
+/**
+ * One block's template-descriptor output as the walk receives it.
+ *
+ * Deliberately the same shape the `__pl_initializationParams_derive` facade callback
+ * returns, so a provider can hand the VM's result straight through without
+ * reshaping it.
+ */
+export type TemplateParamsResult =
+  | { readonly error: string }
+  | { readonly error?: undefined; readonly value: unknown };
+
+/** One block's contribution to the template being exported. */
+export type TemplateExportEntry = {
+  /**
+   * The block's project-local id, which is also its template-local id: a template
+   * has no id namespace of its own, so the id is reused verbatim and references
+   * already stored in params need no translation.
+   */
+  readonly blockId: string;
+  /**
+   * The block's params exactly as it projected them.
+   *
+   * Always a mapping: a block that declared no `templateParams`, or whose lambda returned
+   * something else, is reported as a problem rather than carried here — see the object check
+   * in the walk. So nothing downstream has an absent case to decide.
+   */
+  readonly params: Record<string, unknown>;
+};
+
+/** Why one block could not be exported. */
+export type TemplateExportProblem = {
+  readonly blockId: string;
+  readonly error: string;
+};
+
+/**
+ * Outcome of the walk: the blocks that can be written, and the ones that cannot.
+ *
+ * Both lists are returned rather than throwing on the first failure, so the
+ * caller can report every offending block at once instead of making the user fix
+ * them one export at a time. Whether a non-empty `problems` aborts the export is
+ * the caller's policy, not the walk's — but note that emitting `entries` while
+ * ignoring `problems` can produce a file whose surviving entries reference a
+ * dropped block, which is an unusable template.
+ */
+export type TemplateExportWalk = {
+  readonly entries: readonly TemplateExportEntry[];
+  readonly problems: readonly TemplateExportProblem[];
+};
+
+/**
+ * Walk a project's blocks in dependency order, collecting each one's
+ * template-descriptor output.
+ *
+ * **No topological sort is performed, because none is needed.** The project
+ * structure is already stored in topological order, and that is enforced rather
+ * than assumed: `productionGraph` traverses `allBlocks(structure)` and passes the
+ * set of blocks seen *so far* as the allowed set to `inferAllReferencedBlocks`, so
+ * a reference to a block that is not already above is recorded as a missing
+ * reference instead of an upstream. A block can therefore only legally reference
+ * blocks earlier in this sequence — which is exactly what a template file needs,
+ * since its block order is the instantiation order and the engine creates blocks
+ * upstream-first. Emitting entries in structure order satisfies that for free.
+ *
+ * Groups are flattened in order, so cross-group ordering is the structure's too.
+ *
+ * A structure that violates the ordering rule is reported as-is, not repaired:
+ * reordering would change which references are legal in the first place.
+ *
+ * Params are written exactly as the block projected them. The walk parses nothing, rewrites
+ * nothing and inspects nothing inside them — a template engine is the mechanical half: it
+ * exposes the `{ $ref: … }` mechanic and knows no more about references than that. Which
+ * values carry block ids, and therefore which have to be wrapped, is the block's statement to
+ * make, and a block that gets it wrong produces a template that does not work — the same way
+ * one whose `templateParams` returns the wrong fields does.
+ *
+ * @param structure The project structure — the source of both membership and order
+ * @param paramsProvider Yields a block's derived template params. Return
+ *   `undefined` for a block whose state cannot be read at all; such a block is
+ *   recorded as a problem rather than skipped, because a template that quietly
+ *   omits a block does not describe the project it was exported from, and the
+ *   surviving entries may still reference the omitted one.
+ */
+export function walkProjectForTemplateExport(
+  structure: ProjectStructure,
+  paramsProvider: (blockId: string) => TemplateParamsResult | undefined,
+): TemplateExportWalk {
+  const entries: TemplateExportEntry[] = [];
+  const problems: TemplateExportProblem[] = [];
+
+  for (const { id } of allBlocks(structure)) {
+    const derived = paramsProvider(id);
+
+    if (derived === undefined) {
+      problems.push({
+        blockId: id,
+        error: "Block state is unavailable, so its template params could not be derived",
+      });
+      continue;
+    }
+
+    if (derived.error !== undefined) {
+      problems.push({ blockId: id, error: derived.error });
+      continue;
+    }
+
+    const params = derived.value;
+
+    // An entry's `params` must be a mapping. The lambda's declared return type is the
+    // block kind's params type, and the kind's parser checks values coming IN, but
+    // nothing checks what the lambda hands back on the way out — so a block whose
+    // params type is a primitive or a tuple compiles fine and would produce an
+    // unwritable entry. This is the only place that can catch it.
+    if (typeof params !== "object" || params === null || Array.isArray(params)) {
+      problems.push({
+        blockId: id,
+        error: `templateParams() must return an object, got ${typeName(params)}`,
+      });
+      continue;
+    }
+
+    entries.push({ blockId: id, params: params as Record<string, unknown> });
+  }
+
+  return { entries, problems };
+}
+
+/** Name the offending value's type for an error message, without printing the value. */
+function typeName(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return `a ${typeof value}`;
+}
diff --git a/lib/node/pl-middle-layer/src/model/template_parser.test.ts b/lib/node/pl-middle-layer/src/model/template_parser.test.ts
new file mode 100644
index 0000000000..67f5e5fa03
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_parser.test.ts
@@ -0,0 +1,258 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { PROJECT_TEMPLATE_SCHEMA_V1 } from "@milaboratories/pl-model-common";
+import { parseProjectTemplateV1Yaml } from "./template_parser";
+import { stringifyProjectTemplateV1 } from "./template_serializer";
+
+const FIXTURE_DIR = join(import.meta.dirname, "..", "..", "test_fixtures", "template-v1");
+
+const KIND = "@platforma-open/milaboratories.demo.kind@^1.0.0";
+
+/** The document, or a test failure naming what went wrong instead. */
+function documentOf(text: string) {
+  const outcome = parseProjectTemplateV1Yaml(text);
+  if (!outcome.ok) throw new Error(`expected a document, got: ${outcome.error}`);
+  return outcome.document;
+}
+
+/** The error message, or a test failure if the text parsed after all. */
+function errorOf(text: string): string {
+  const outcome = parseProjectTemplateV1Yaml(text);
+  if (outcome.ok) throw new Error("expected a failure, but the text parsed");
+  return outcome.error;
+}
+
+describe("parseProjectTemplateV1Yaml", () => {
+  test("reads a file into the document import applies", () => {
+    const document = documentOf(
+      [
+        `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}`,
+        "blocks:",
+        "  - id: first",
+        `    kind: "${KIND}"`,
+        "    params:",
+        "      dataset: bulk-rna",
+        "  - id: second",
+        `    kind: "${KIND}"`,
+        "    params:",
+        "      input:",
+        "        $ref:",
+        "          __isRef: true",
+        "          blockId: first",
+        "          name: reads",
+        "",
+      ].join("\n"),
+    );
+
+    expect(document.blocks).toEqual([
+      { id: "first", kind: KIND, params: { dataset: "bulk-rna" } },
+      {
+        id: "second",
+        kind: KIND,
+        // Carried verbatim: the parser recognizes the wrapper and looks no further.
+        params: { input: { $ref: { __isRef: true, blockId: "first", name: "reads" } } },
+      },
+    ]);
+  });
+
+  test("an entry without params reads as empty params", () => {
+    // The one thing the parser fills in. Leaving the key absent would make every reader
+    // downstream normalize it, and one of them would eventually forget.
+    const [entry] = documentOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n    kind: "${KIND}"\n`,
+    ).blocks;
+
+    expect(entry.params).toEqual({});
+  });
+
+  test("JSON is accepted, being valid YAML", () => {
+    // Not a feature to advertise, but a file someone hand-wrote as JSON should not be
+    // rejected for a reason that has nothing to do with its contents.
+    const document = documentOf(
+      JSON.stringify({
+        schema: PROJECT_TEMPLATE_SCHEMA_V1,
+        blocks: [{ id: "a", kind: KIND }],
+      }),
+    );
+
+    expect(document.blocks).toHaveLength(1);
+  });
+
+  test("every golden export file reads back", () => {
+    // The other side of the round trip, checked against the files the export tests
+    // pin: whatever export writes, this reads. A fixture that stopped parsing here
+    // would mean the two halves had drifted apart.
+    const files = readdirSync(FIXTURE_DIR).filter((f) => f.endsWith(".yaml"));
+
+    expect(files.length).toBeGreaterThan(0);
+    for (const file of files) {
+      const text = readFileSync(join(FIXTURE_DIR, file), "utf-8");
+      const outcome = parseProjectTemplateV1Yaml(text);
+
+      expect(outcome.ok, `${file}: ${outcome.ok ? "" : outcome.error}`).toBe(true);
+    }
+  });
+
+  test("a document survives being written and read again", () => {
+    // Text → document → text → document. Pins the two text layers against each other
+    // rather than against a fixture, so a change to either shows up here.
+    const original = documentOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n    kind: "${KIND}"\n    params:\n      n: 1\n`,
+    );
+
+    expect(documentOf(stringifyProjectTemplateV1(original))).toEqual(original);
+  });
+});
+
+describe("what a broken file says", () => {
+  test("an empty file is called empty", () => {
+    // Blank input, whitespace and comment-only files all parse to null, where the
+    // schema would report a type mismatch instead of the actual mistake.
+    expect(errorOf("")).toBe("The file is empty.");
+    expect(errorOf("   \n\n")).toBe("The file is empty.");
+    expect(errorOf("# just a comment\n")).toBe("The file is empty.");
+  });
+
+  test("a YAML syntax error is located, without a code frame", () => {
+    // The position is what a person needs; the frame duplicates the editor they are
+    // already looking at.
+    const error = errorOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n   kind: x\n`,
+    );
+
+    expect(error).toContain("not valid YAML");
+    expect(error).toContain("line 4");
+    expect(error).not.toContain("\n");
+  });
+
+  test("a repeated key is reported rather than silently dropped", () => {
+    // A realistic hand-editing mistake: copy an entry, forget to change a field. YAML
+    // would otherwise keep one of the two and the file would apply, wrongly.
+    const error = errorOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n    id: b\n    kind: "${KIND}"\n`,
+    );
+
+    expect(error).toContain("not valid YAML");
+    expect(error).toMatch(/keys must be unique/i);
+  });
+
+  test("tabs are reported as such", () => {
+    // Tab indentation is invalid YAML and the failure is otherwise baffling.
+    expect(errorOf("schema: x\n\tblocks: []\n")).toMatch(/tabs/i);
+  });
+
+  test("something that is not a mapping says what was expected", () => {
+    expect(errorOf("a plain string\n")).toContain("expected a mapping");
+    expect(errorOf("- a\n- b\n")).toContain("expected a mapping");
+  });
+
+  test("the wrong kind of file is named as such, not as a type error", () => {
+    // The likeliest mistake of all — a file picker was pointed at the wrong file — so
+    // it gets its own message rather than the schema's literal-mismatch wording.
+    expect(errorOf("schema: template-v2\nblocks: []\n")).toBe(
+      `This file says it is 'template-v2', not ${PROJECT_TEMPLATE_SCHEMA_V1}.`,
+    );
+    expect(errorOf("blocks: []\n")).toBe(
+      `This file has no 'schema' field, so it is not a ${PROJECT_TEMPLATE_SCHEMA_V1} template.`,
+    );
+  });
+
+  test("a schema problem is located the way the file is written", () => {
+    // `blocks[0].kind`, not the parser's `blocks.0.kind`: the reader finds it by
+    // reading, not by counting.
+    const error = errorOf(`schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n`);
+
+    expect(error).toContain("- blocks[0].kind:");
+  });
+
+  test("every schema problem is listed, and counted", () => {
+    // One pass to fix the file, not one pass per problem.
+    const error = errorOf(
+      [`schema: ${PROJECT_TEMPLATE_SCHEMA_V1}`, "blocks:", "  - id: a", "  - id: b", ""].join("\n"),
+    );
+
+    expect(error).toContain("2 problems:");
+    expect(error).toContain("- blocks[0].kind:");
+    expect(error).toContain("- blocks[1].kind:");
+  });
+
+  test("a malformed kind reference explains the grammar", () => {
+    const error = errorOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n    kind: no-version\n`,
+    );
+
+    expect(error).toContain("blocks[0].kind:");
+    expect(error).toContain("{name}@{selector}");
+  });
+
+  test("two entries with the same id are rejected", () => {
+    // Template-local ids are what references name, so a duplicate makes a reference
+    // ambiguous — and the apply would map one id to two blocks.
+    const error = errorOf(
+      [
+        `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}`,
+        "blocks:",
+        "  - id: a",
+        `    kind: "${KIND}"`,
+        "  - id: a",
+        `    kind: "${KIND}"`,
+        "",
+      ].join("\n"),
+    );
+
+    expect(error).toContain("Duplicate template-local id: a");
+  });
+
+  test("an unknown field is refused, not ignored", () => {
+    // A misspelled key that was silently dropped would apply a file that does not say
+    // what the author meant.
+    const error = errorOf(
+      `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}\nblocks:\n  - id: a\n    kind: "${KIND}"\n    parms: {}\n`,
+    );
+
+    expect(error).toMatch(/Unrecognized key/);
+  });
+});
+
+describe("scalars in params", () => {
+  test("what looks like a string stays a string", () => {
+    // Read as YAML 1.2 on purpose. Under 1.1 — PyYAML's default — a bare `yes` is
+    // `true` and `1:30` is `90`, so a hand-written file would silently change meaning
+    // depending on who wrote it. The export side quotes these anyway, which is the
+    // other half of the same decision.
+    const [entry] = documentOf(
+      [
+        `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}`,
+        "blocks:",
+        "  - id: a",
+        `    kind: "${KIND}"`,
+        "    params:",
+        "      answer: yes",
+        "      duration: 1:30",
+        "",
+      ].join("\n"),
+    ).blocks;
+
+    expect(entry.params).toEqual({ answer: "yes", duration: "1:30" });
+  });
+
+  test("numbers and booleans written as such stay themselves", () => {
+    const [entry] = documentOf(
+      [
+        `schema: ${PROJECT_TEMPLATE_SCHEMA_V1}`,
+        "blocks:",
+        "  - id: a",
+        `    kind: "${KIND}"`,
+        "    params:",
+        "      count: 42",
+        "      ratio: 0.5",
+        "      enabled: true",
+        "      missing: null",
+        "",
+      ].join("\n"),
+    ).blocks;
+
+    expect(entry.params).toEqual({ count: 42, ratio: 0.5, enabled: true, missing: null });
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_parser.ts b/lib/node/pl-middle-layer/src/model/template_parser.ts
new file mode 100644
index 0000000000..001c1de074
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_parser.ts
@@ -0,0 +1,118 @@
+import YAML from "yaml";
+import { z } from "zod";
+import type { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
+import {
+  PROJECT_TEMPLATE_SCHEMA_V1,
+  parseProjectTemplateV1,
+} from "@milaboratories/pl-model-common";
+
+/**
+ * A template file read, or why it could not be.
+ *
+ * A single message rather than a list of per-entry problems: until the document
+ * parses there are no entries to attach anything to, and a file that does not parse
+ * has one problem — it is not a template. Per-entry reporting starts at the stage
+ * after this one. The message may span several lines when the file has several
+ * fixable issues, so that fixing it takes one pass.
+ */
+export type TemplateParseOutcome =
+  | { readonly ok: true; readonly document: ProjectTemplateV1 }
+  | { readonly ok: false; readonly error: string };
+
+/**
+ * Read `template-v1` YAML text into a document.
+ *
+ * The text half of the import direction, mirroring `stringifyProjectTemplateV1` on the
+ * export side — and, like it, living here rather than in `pl-model-common`, which ships
+ * in every block-model and UI bundle and takes no `yaml` dependency. The document half
+ * is `parseProjectTemplateV1`, shared with export so that what export writes is by
+ * construction what import reads.
+ *
+ * JSON is accepted for free: every JSON document is also YAML.
+ *
+ * **Read as YAML 1.2**, while the emitter quotes as if for 1.1. That asymmetry is
+ * deliberate on both ends: quoting against the stricter ruleset makes a file we write
+ * mean the same thing to any reader, and reading with the looser one means a bare
+ * `yes` or `1:30` in a hand-written file stays the string it looks like instead of
+ * silently becoming `true` or `90`.
+ *
+ * Nothing here checks that references point anywhere or that a kind can be resolved —
+ * those are later stages, and both need more than the file to answer.
+ */
+export function parseProjectTemplateV1Yaml(text: string): TemplateParseOutcome {
+  let value: unknown;
+  try {
+    value = YAML.parse(text);
+  } catch (e) {
+    // The library's message already carries "at line L, column C"; what follows it is
+    // a code frame of the offending lines, dropped here because whoever is fixing the
+    // file has it open and the position is what they need.
+    const first = e instanceof Error ? e.message.split("\n")[0] : String(e);
+    return { ok: false, error: `The file is not valid YAML: ${first}` };
+  }
+
+  // Empty input, blank lines and a file of nothing but comments all parse to null.
+  // Left to the schema, this reads as "expected object, received null", which says
+  // nothing about the actual mistake.
+  if (value === null || value === undefined) {
+    return { ok: false, error: "The file is empty." };
+  }
+
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      ok: false,
+      error:
+        "The file does not describe a template: expected a mapping with 'schema' and " +
+        "'blocks' at the top level.",
+    };
+  }
+
+  // Checked ahead of the schema because it is the likeliest mistake by far — the wrong
+  // file was picked — and because the schema's own wording for it ("Invalid literal
+  // value, expected \"template-v1\"") describes a type mismatch rather than that.
+  const marker = (value as { schema?: unknown }).schema;
+  if (marker !== PROJECT_TEMPLATE_SCHEMA_V1) {
+    return {
+      ok: false,
+      error:
+        marker === undefined
+          ? `This file has no 'schema' field, so it is not a ${PROJECT_TEMPLATE_SCHEMA_V1} template.`
+          : `This file says it is '${String(marker)}', not ${PROJECT_TEMPLATE_SCHEMA_V1}.`,
+    };
+  }
+
+  try {
+    return { ok: true, document: parseProjectTemplateV1(value) };
+  } catch (e) {
+    if (e instanceof z.ZodError) return { ok: false, error: describeIssues(e) };
+    throw e;
+  }
+}
+
+/**
+ * Turn schema issues into something a person can act on, all of them at once.
+ *
+ * Each line locates the problem the way the file is written — `blocks[2].kind` rather
+ * than the parser's `blocks.2.kind` — so it can be found by reading, not counting.
+ */
+function describeIssues(error: z.ZodError): string {
+  const lines = error.issues.map((issue) => {
+    const path = issue.path.reduce<string>(
+      (acc, segment) =>
+        typeof segment === "number"
+          ? `${acc}[${segment}]`
+          : acc === ""
+            ? segment
+            : `${acc}.${segment}`,
+      "",
+    );
+    return path === "" ? `- ${issue.message}` : `- ${path}: ${issue.message}`;
+  });
+
+  const headline =
+    lines.length === 1
+      ? "The template file has a problem:"
+      : `The template file has ${lines.length} problems:`;
+
+  return [headline, ...lines].join("\n");
+}
diff --git a/lib/node/pl-middle-layer/src/model/template_resolve.test.ts b/lib/node/pl-middle-layer/src/model/template_resolve.test.ts
new file mode 100644
index 0000000000..449cf69efb
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_resolve.test.ts
@@ -0,0 +1,462 @@
+import { describe, expect, test } from "vitest";
+import type {
+  BlockKindReference,
+  BlockKindSelectorReference,
+  BlockPackLocationReference,
+  BlockPackLocatorOverride,
+  BlockPackReference,
+  ProjectTemplateV1,
+  ProjectTemplateV1Entry,
+} from "@milaboratories/pl-model-common";
+import { PROJECT_TEMPLATE_SCHEMA_V1 } from "@milaboratories/pl-model-common";
+import type { BlockPackId, BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
+import type {
+  BlockPackProvider,
+  ExactResolution,
+  KindResolution,
+  LocationResolution,
+} from "./template_resolve";
+import { parseBlockPackName, resolveTemplateEntries } from "./template_resolve";
+
+/**
+ * Resolution stage, driven against a fake provider.
+ *
+ * No registry, no network, no project: what registry to read and how is on the far
+ * side of `BlockPackProvider`, and everything these tests cover — which path an entry
+ * takes, what each failure tells the reader, that every entry is attempted — is on
+ * this side.
+ */
+
+const KIND = "@platforma-open/milaboratories.demo.kind@^1.0.0" as BlockKindSelectorReference;
+
+const specFor = (name: string): BlockPackSpec => ({
+  type: "from-registry-v2",
+  registryUrl: "https://block.registry.platforma.bio/releases",
+  id: { organization: "milaboratories", name, version: "1.2.3" },
+  channel: "stable",
+});
+
+/** A successful resolution of `name`, titled the way a registry would title it. */
+const foundBlock = (name: string) => ({
+  ok: true as const,
+  spec: specFor(name),
+  title: `The ${name} Block`,
+});
+
+/**
+ * An entry as the parser hands it over, with the locator override left to the caller.
+ *
+ * `extra` takes {@link BlockPackLocatorOverride} rather than a `Partial<Pick<…>>` of the
+ * entry: the latter would let a test hand over both `block` and `location`, which is a
+ * document the type forbids and the parser rejects.
+ */
+const entry = (
+  id: string,
+  extra: { kind?: BlockKindSelectorReference } & BlockPackLocatorOverride = {},
+): ProjectTemplateV1Entry => ({ id, kind: KIND, params: {}, ...extra });
+
+const documentOf = (...blocks: ProjectTemplateV1Entry[]): ProjectTemplateV1 => ({
+  schema: PROJECT_TEMPLATE_SCHEMA_V1,
+  blocks,
+});
+
+/** A provider whose three answers are fixed, recording what it was asked. */
+function fakeProvider(answers: {
+  byKind?: KindResolution;
+  byExactVersion?: ExactResolution;
+  byLocation?: LocationResolution;
+}): {
+  provider: BlockPackProvider;
+  kindCalls: { kind: string; allowUnstable: boolean }[];
+  exactCalls: BlockPackId[];
+  locationCalls: string[];
+} {
+  const kindCalls: { kind: string; allowUnstable: boolean }[] = [];
+  const exactCalls: BlockPackId[] = [];
+  const locationCalls: string[] = [];
+
+  return {
+    kindCalls,
+    exactCalls,
+    locationCalls,
+    provider: {
+      byKind: (kind, options) => {
+        kindCalls.push({ kind, allowUnstable: options.allowUnstable });
+        return Promise.resolve(answers.byKind ?? foundBlock("resolved"));
+      },
+      byExactVersion: (id) => {
+        exactCalls.push(id);
+        return Promise.resolve(answers.byExactVersion ?? foundBlock("pinned"));
+      },
+      byLocation: (location) => {
+        locationCalls.push(location);
+        return Promise.resolve(
+          answers.byLocation ?? { ...foundBlock("located"), kind: DECLARED_KIND },
+        );
+      },
+    },
+  };
+}
+
+/** The concrete kind the located block declares, matching {@link KIND}'s selector. */
+const DECLARED_KIND = "@platforma-open/milaboratories.demo.kind@1.0.0" as BlockKindReference;
+
+const LOCATION = "file:///Users/dev/blocks/demo/block" as BlockPackLocationReference;
+
+const resolve = (document: ProjectTemplateV1, provider: BlockPackProvider, allowUnstable = false) =>
+  resolveTemplateEntries(document, provider, { allowUnstable });
+
+describe("resolveTemplateEntries", () => {
+  test("resolves each entry's kind, in file order", async () => {
+    const { provider, kindCalls } = fakeProvider({});
+
+    const outcome = await resolve(documentOf(entry("a"), entry("b")), provider);
+
+    expect(kindCalls).toHaveLength(2);
+    expect(outcome.problems).toEqual([]);
+    expect(outcome.resolved.map((r) => r.entryId)).toEqual(["a", "b"]);
+    expect(outcome.resolved[0].spec).toEqual(specFor("resolved"));
+  });
+
+  test("the apply-wide unstable flag reaches every entry", async () => {
+    // One decision for the whole file, not per entry: a template that resolved some
+    // entries to stable blocks and others to pre-releases would be unreproducible in
+    // a way the file itself does not record.
+    const { provider, kindCalls } = fakeProvider({});
+
+    await resolve(documentOf(entry("a"), entry("b")), provider, true);
+
+    expect(kindCalls.map((c) => c.allowUnstable)).toEqual([true, true]);
+  });
+
+  test("a pinned version bypasses kind resolution entirely", async () => {
+    const { provider, kindCalls, exactCalls } = fakeProvider({});
+    const pinned = entry("a", {
+      block: "@platforma-open/milaboratories.demo@2.0.1" as BlockPackReference,
+    });
+
+    const outcome = await resolve(documentOf(pinned), provider);
+
+    expect(kindCalls).toEqual([]);
+    expect(exactCalls).toEqual([
+      { organization: "milaboratories", name: "demo", version: "2.0.1" },
+    ]);
+    expect(outcome.resolved[0]).toEqual({
+      entryId: "a",
+      spec: specFor("pinned"),
+      title: "The pinned Block",
+      pinned: true,
+    });
+  });
+
+  test("both paths produce the same kind of result", async () => {
+    // Everything downstream of resolution — preparation, construction — must not care
+    // which way an entry got its block.
+    const { provider } = fakeProvider({});
+
+    const outcome = await resolve(
+      documentOf(
+        entry("a"),
+        entry("b", { block: "@platforma-open/milaboratories.demo@2.0.1" as BlockPackReference }),
+      ),
+      provider,
+    );
+
+    expect(outcome.resolved.map((r) => Object.keys(r).sort())).toEqual([
+      ["entryId", "pinned", "spec", "title"],
+      ["entryId", "pinned", "spec", "title"],
+    ]);
+  });
+
+  test("the block's published title comes back with it, whichever route it took", async () => {
+    // It becomes the created block's label, and this is the only stage that can know it:
+    // a prepared block pack carries the model, the workflow and the frontend, none of
+    // which names the block. Deriving it from the entry would put a UUID there, since an
+    // exported template names its entries by the source project's block ids.
+    const { provider } = fakeProvider({});
+
+    const outcome = await resolve(
+      documentOf(
+        entry("aaaaaaaa-0000-4000-8000-000000000001"),
+        entry("bbbbbbbb-0000-4000-8000-000000000002", {
+          block: "@platforma-open/milaboratories.demo@2.0.1" as BlockPackReference,
+        }),
+      ),
+      provider,
+    );
+
+    expect(outcome.resolved.map((r) => r.title)).toEqual([
+      "The resolved Block",
+      "The pinned Block",
+    ]);
+  });
+
+  test("every entry is attempted, and every failure collected", async () => {
+    // Fixing an unapplicable file should take one pass, not one pass per bad entry.
+    const { provider } = fakeProvider({ byKind: { ok: false, reason: "no-implementation" } });
+
+    const outcome = await resolve(documentOf(entry("a"), entry("b"), entry("c")), provider);
+
+    expect(outcome.problems.map((p) => p.entryId)).toEqual(["a", "b", "c"]);
+    expect(outcome.resolved).toEqual([]);
+  });
+
+  test("a document that half resolves reports both halves", async () => {
+    // `resolved` being shorter than the document is the signal that it must not be
+    // applied — resolution is all-or-nothing for the caller, not per entry.
+    const provider: BlockPackProvider = {
+      byKind: () => Promise.resolve(foundBlock("resolved")),
+      byExactVersion: () => Promise.resolve({ ok: false, reason: "no-such-block-version" }),
+      byLocation: () => Promise.resolve({ ok: false, reason: "not-found" }),
+    };
+
+    const outcome = await resolve(
+      documentOf(
+        entry("a"),
+        entry("b", { block: "@platforma-open/milaboratories.gone@9.9.9" as BlockPackReference }),
+      ),
+      provider,
+    );
+
+    expect(outcome.resolved.map((r) => r.entryId)).toEqual(["a"]);
+    expect(outcome.problems.map((p) => p.entryId)).toEqual(["b"]);
+  });
+
+  test("an empty document resolves to nothing at all", async () => {
+    const { provider, kindCalls } = fakeProvider({});
+
+    expect(await resolve(documentOf(), provider)).toEqual({ resolved: [], problems: [] });
+    expect(kindCalls).toEqual([]);
+  });
+});
+
+describe("an entry that says where its block is", () => {
+  test("reads that place, and consults no registry at all", async () => {
+    const { provider, kindCalls, exactCalls, locationCalls } = fakeProvider({});
+
+    const outcome = await resolve(documentOf(entry("a", { location: LOCATION })), provider);
+
+    expect(locationCalls).toEqual([LOCATION]);
+    expect(kindCalls).toEqual([]);
+    expect(exactCalls).toEqual([]);
+    expect(outcome.problems).toEqual([]);
+    expect(outcome.resolved[0]).toEqual({
+      entryId: "a",
+      spec: specFor("located"),
+      title: "The located Block",
+      pinned: true,
+    });
+  });
+
+  test("a located entry looks like any other downstream", async () => {
+    // Preparation and construction must not be able to tell how an entry found its
+    // block — that convergence is what lets an unpublished block travel the same path.
+    const { provider } = fakeProvider({});
+
+    const outcome = await resolve(
+      documentOf(entry("a"), entry("b", { location: LOCATION })),
+      provider,
+    );
+
+    expect(outcome.resolved.map((r) => Object.keys(r).sort())).toEqual([
+      ["entryId", "pinned", "spec", "title"],
+      ["entryId", "pinned", "spec", "title"],
+    ]);
+  });
+
+  test("the location wins over a kind, which is the point of naming a place", async () => {
+    const { provider, kindCalls, locationCalls } = fakeProvider({});
+
+    await resolve(documentOf(entry("a", { location: LOCATION })), provider);
+
+    expect(locationCalls).toHaveLength(1);
+    expect(kindCalls).toEqual([]);
+  });
+
+  describe("what each failure tells the reader", () => {
+    const messageFor = async (answer: LocationResolution) => {
+      const { provider } = fakeProvider({ byLocation: answer });
+      const outcome = await resolve(documentOf(entry("a", { location: LOCATION })), provider);
+      return outcome.problems[0].error;
+    };
+
+    test("a scheme this application cannot read says so, and names what it can", async () => {
+      // Distinct from "nothing there": the file may be perfectly correct and simply
+      // written for a consumer that fetches more than this one does.
+      const message = await messageFor({ ok: false, reason: "unsupported-scheme" });
+
+      expect(message).toMatch(/cannot read/);
+      expect(message).toContain("file:");
+      expect(message).toContain(LOCATION);
+    });
+
+    test("a missing folder names the reason a pinned template travels badly", async () => {
+      const message = await messageFor({ ok: false, reason: "not-found" });
+
+      expect(message).toMatch(/Nothing is at/);
+      expect(message).toMatch(/only works on the machine/);
+    });
+
+    test("a folder that is not a block says what was looked for", async () => {
+      // Reachable by pointing one directory off, so the message has to be actionable
+      // rather than just negative.
+      const message = await messageFor({ ok: false, reason: "not-a-block" });
+
+      expect(message).toMatch(/is not a block/);
+      expect(message).toMatch(/package\.json/);
+    });
+  });
+
+  describe("the entry's kind is verified against what was found", () => {
+    const resolveWith = async (kind: BlockKindReference | undefined) => {
+      const { provider } = fakeProvider({
+        byLocation: { ...foundBlock("located"), ...(kind !== undefined ? { kind } : {}) },
+      });
+      return await resolve(documentOf(entry("a", { location: LOCATION })), provider);
+    };
+
+    test("a version inside the entry's range is accepted", async () => {
+      // KIND asks for `^1.0.0`, so a later minor of the same kind still implements the
+      // contract the params were written against.
+      const outcome = await resolveWith(
+        "@platforma-open/milaboratories.demo.kind@1.4.0" as BlockKindReference,
+      );
+
+      expect(outcome.problems).toEqual([]);
+      expect(outcome.resolved).toHaveLength(1);
+    });
+
+    test("a version outside the range is refused, naming both sides", async () => {
+      const outcome = await resolveWith(
+        "@platforma-open/milaboratories.demo.kind@2.0.0" as BlockKindReference,
+      );
+
+      expect(outcome.resolved).toEqual([]);
+      expect(outcome.problems[0].error).toContain(KIND);
+      expect(outcome.problems[0].error).toContain("version 2.0.0");
+    });
+
+    test("a different kind entirely is refused, naming both", async () => {
+      // The failure a location makes possible: the path still resolves, but what is
+      // there now is a different block than the one the params were written for.
+      const outcome = await resolveWith(
+        "@platforma-open/milaboratories.other.kind@1.0.0" as BlockKindReference,
+      );
+
+      expect(outcome.problems[0].error).toContain("@platforma-open/milaboratories.demo.kind");
+      expect(outcome.problems[0].error).toContain("@platforma-open/milaboratories.other.kind");
+    });
+
+    test("a block declaring no kind cannot serve the entry", async () => {
+      const outcome = await resolveWith(undefined);
+
+      expect(outcome.problems[0].error).toMatch(/declares no kind/);
+    });
+
+    test("an unreadable declared kind is a problem, not a throw", async () => {
+      const outcome = await resolveWith("no-version-here" as BlockKindReference);
+
+      expect(outcome.problems[0].error).toMatch(/unreadable kind/);
+    });
+
+    test("the failing entry's location is named, since the path is what to fix", async () => {
+      const outcome = await resolveWith(
+        "@platforma-open/milaboratories.other.kind@1.0.0" as BlockKindReference,
+      );
+
+      expect(outcome.problems[0].error).toContain(LOCATION);
+    });
+  });
+});
+
+describe("what each failure tells the reader", () => {
+  const messageFor = async (answer: KindResolution) => {
+    const { provider } = fakeProvider({ byKind: answer });
+    const outcome = await resolve(documentOf(entry("a")), provider);
+    return outcome.problems[0].error;
+  };
+
+  test("no matching kind version points at the file or the registry", async () => {
+    const message = await messageFor({ ok: false, reason: "no-matching-kind-version" });
+
+    // The kind's own name, not just the raw reference: the reference is what they
+    // wrote, the name is what they look for in a registry.
+    expect(message).toContain("@platforma-open/milaboratories.demo.kind");
+    expect(message).toContain(KIND);
+    expect(message).toMatch(/Check the version, or update the block registry/);
+  });
+
+  test("no implementation says nothing can be installed yet", async () => {
+    const message = await messageFor({ ok: false, reason: "no-implementation" });
+
+    expect(message).toMatch(/no block implementing/);
+  });
+
+  test("only unstable implementations names the one action that needs no edit", async () => {
+    // This is the reason the allow-unstable checkbox exists, and the only failure a
+    // user can clear without touching the file.
+    const message = await messageFor({ ok: false, reason: "no-stable-implementation" });
+
+    expect(message).toMatch(/pre-release/);
+    expect(message).toMatch(/Import again with unstable versions allowed/);
+  });
+
+  test("a missing pinned version offers both ways out", async () => {
+    // Correct the pin, or drop it — the second one is easy to miss, and is usually
+    // what the reader wants.
+    const { provider } = fakeProvider({
+      byExactVersion: { ok: false, reason: "no-such-block-version" },
+    });
+
+    const outcome = await resolve(
+      documentOf(
+        entry("a", { block: "@platforma-open/milaboratories.demo@2.0.1" as BlockPackReference }),
+      ),
+      provider,
+    );
+
+    expect(outcome.problems[0].error).toContain("milaboratories/demo");
+    expect(outcome.problems[0].error).toContain("2.0.1");
+    expect(outcome.problems[0].error).toMatch(/remove it so a version is chosen automatically/);
+  });
+
+  test("an unreadable pinned name is a problem, not a throw", async () => {
+    // Reachable from a hand-written file: the document parser checks the
+    // `{name}@X.Y.Z` grammar but not that the name carries an organization.
+    const { provider } = fakeProvider({});
+
+    const outcome = await resolve(
+      documentOf(entry("a", { block: "@platforma-open/demo@2.0.1" as BlockPackReference })),
+      provider,
+    );
+
+    expect(outcome.problems[0].entryId).toBe("a");
+    expect(outcome.problems[0].error).toMatch(/Pinned block version is not readable/);
+  });
+});
+
+describe("parseBlockPackName", () => {
+  test("splits the organization out of the npm name", () => {
+    // The npm scope and the organization are different, and only the organization
+    // reaches the registry.
+    expect(parseBlockPackName("@milaboratories/milaboratories.test-download-file")).toEqual({
+      organization: "milaboratories",
+      name: "test-download-file",
+    });
+    expect(parseBlockPackName("@platforma-open/milaboratories.mixcr-clonotyping")).toEqual({
+      organization: "milaboratories",
+      name: "mixcr-clonotyping",
+    });
+  });
+
+  test("splits on the first dot, so a name may contain more", () => {
+    expect(parseBlockPackName("@scope/org.a.b")).toEqual({ organization: "org", name: "a.b" });
+  });
+
+  test("rejects a name that cannot address a registry", () => {
+    expect(() => parseBlockPackName("no-scope.name")).toThrow(/expected '@npm-scope/);
+    expect(() => parseBlockPackName("@scope/nodot")).toThrow(/does not separate an organization/);
+    expect(() => parseBlockPackName("@scope/.name")).toThrow(/does not separate an organization/);
+    expect(() => parseBlockPackName("@scope/org.")).toThrow(/does not separate an organization/);
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_resolve.ts b/lib/node/pl-middle-layer/src/model/template_resolve.ts
new file mode 100644
index 0000000000..62a7a83462
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_resolve.ts
@@ -0,0 +1,416 @@
+import type {
+  BlockKindReference,
+  BlockKindSelectorReference,
+  BlockPackLocationReference,
+  ProjectTemplateV1,
+  ProjectTemplateV1Entry,
+} from "@milaboratories/pl-model-common";
+import {
+  parseBlockPackReference,
+  parseKindRef,
+  parseKindSelectorReference,
+} from "@milaboratories/pl-model-common";
+import type { BlockPackId, BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
+import { selectorToRange } from "@platforma-sdk/block-tools";
+import * as semver from "semver";
+import type { TemplateApplyProblem } from "./template_apply";
+
+/**
+ * Where a template entry's block comes from.
+ *
+ * All three of an entry's paths to an implementation go through this one interface, and
+ * all three come back as the same `BlockPackSpec` — the shape the existing add-block
+ * path already consumes — plus the block's published title. That convergence is the
+ * point: everything downstream of resolution treats a kind-resolved entry, a
+ * version-pinned one and a filesystem-located one identically, which is why a locally
+ * built block travels the same preparation and construction path as a published one.
+ *
+ * Registry knowledge sits deliberately on the far side of this interface. A template
+ * file names no registry, so choosing which one (or ones) to consult is a property
+ * of the environment applying the file, not of the file — and keeping it out here is
+ * what lets resolution be tested with no registry at all.
+ *
+ * The title is required rather than optional for the same reason: an implementation
+ * always has one to hand — a registry adapter reads it off the block's manifest, and
+ * anything else names the blocks it serves — while a caller downstream has no source
+ * for it at all, and the fallbacks it could invent are all wrong. See
+ * {@link ResolvedEntry}'s `title`.
+ */
+export type BlockPackProvider = {
+  /**
+   * Find the block implementing a kind selector.
+   *
+   * @param kind The entry's `{name}@{selector}` reference
+   * @param options `allowUnstable` widens the search from stable implementations to
+   *   every published one, for the whole apply
+   */
+  byKind: (
+    kind: BlockKindSelectorReference,
+    options: { allowUnstable: boolean },
+  ) => Promise<KindResolution>;
+
+  /**
+   * Find one exact block package version, named directly.
+   *
+   * This is the `block` override's path, and it bypasses kinds entirely — the
+   * override exists precisely to pin an implementation that resolution would not
+   * have chosen.
+   */
+  byExactVersion: (id: BlockPackId) => Promise<ExactResolution>;
+
+  /**
+   * Read the implementation sitting at one location.
+   *
+   * The `location` override's path, for a block that no registry knows because it was
+   * built and never published. Nothing is searched: the entry says where, so either
+   * that place holds a block or the entry is wrong.
+   *
+   * Unlike the other two, this one also returns the kind the implementation declares.
+   * Resolution cannot take the entry's word for it here — a folder's contents change
+   * under a path that does not — so the two are compared, and that comparison needs
+   * both halves. See {@link LocationResolution}'s `kind`.
+   */
+  byLocation: (location: BlockPackLocationReference) => Promise<LocationResolution>;
+};
+
+/**
+ * The outcome of resolving one kind selector.
+ *
+ * The three failure reasons are distinct because each has a different way out, and
+ * a caller that collapsed them would leave the reader guessing which:
+ *
+ * - `no-matching-kind-version` — the selector matches no published version of the
+ *   kind at all. The file, or the registry, is wrong.
+ * - `no-implementation` — the kind version exists, but nothing implements it. The
+ *   kind was published ahead of any block.
+ * - `no-stable-implementation` — implementations exist but none is stable, and the
+ *   apply did not allow unstable ones. This is the only reason the user can act on
+ *   without editing anything.
+ */
+export type KindResolution =
+  | { readonly ok: true; readonly spec: BlockPackSpec; readonly title: string }
+  | {
+      readonly ok: false;
+      readonly reason:
+        | "no-matching-kind-version"
+        | "no-implementation"
+        | "no-stable-implementation";
+    };
+
+/** The outcome of locating one exact block version. */
+export type ExactResolution =
+  | { readonly ok: true; readonly spec: BlockPackSpec; readonly title: string }
+  | { readonly ok: false; readonly reason: "no-such-block-version" };
+
+/**
+ * The outcome of reading the implementation at one location.
+ *
+ * The three failure reasons separate three different mistakes, and each is fixed
+ * differently:
+ *
+ * - `unsupported-scheme` — the URI is well-formed but names a way of fetching that
+ *   this environment has no reader for. A property of the environment, not the file.
+ * - `not-found` — nothing is at that location. Usually a template carried to another
+ *   machine, or a folder that moved.
+ * - `not-a-block` — something is there, but it is not a block. Usually a path pointing
+ *   one directory off, which is why the message has to say what was looked for.
+ */
+export type LocationResolution =
+  | {
+      readonly ok: true;
+      readonly spec: BlockPackSpec;
+      readonly title: string;
+      /**
+       * The kind this implementation declares, absent for one that declares none.
+       *
+       * Returned so resolution can hold it against what the entry asked for. A
+       * location is the one locator whose target can be swapped without the file
+       * changing, so it is also the one where the entry's kind has to be verified
+       * rather than assumed — params written against one contract must not be handed
+       * to a block implementing another.
+       */
+      readonly kind?: BlockKindReference;
+    }
+  | {
+      readonly ok: false;
+      readonly reason: "unsupported-scheme" | "not-found" | "not-a-block";
+    };
+
+/** Where one entry's block will come from. */
+export type ResolvedEntry = {
+  /** The entry's template-local id. */
+  readonly entryId: string;
+  readonly spec: BlockPackSpec;
+  /**
+   * The block package's own title, as its author published it — `meta.title` for a
+   * registry block.
+   *
+   * Carried here because resolution is the only stage that talks to a registry, and a
+   * registry is the only thing that knows it. Nothing downstream can recover it: a
+   * prepared block pack holds the model, the workflow and the frontend, none of which
+   * names the block.
+   *
+   * It becomes the created block's label, which is what the user sees for any block
+   * whose model derives no title of its own — `graph-maker`, `table` and seven other
+   * shipped blocks. Deriving it from the entry instead is specifically wrong: an
+   * exported template names its entries by the source project's block ids, so a
+   * round-tripped project would show UUIDs in the sidebar.
+   */
+  readonly title: string;
+  /**
+   * True when the entry named its own implementation — an exact version or a location —
+   * rather than letting its kind choose one.
+   *
+   * Both overrides count, because what this records is that the choice was the file's
+   * and not the registry's, which is the same fact for either of them.
+   */
+  readonly pinned: boolean;
+};
+
+/**
+ * What resolution found for a whole document.
+ *
+ * `resolved` is in file order and holds only the entries that resolved, so
+ * `problems.length > 0` means it is incomplete. A caller must not apply a partial
+ * resolution: the point of resolving before construction is that nothing is created
+ * until every entry has an implementation.
+ */
+export type TemplateResolveOutcome = {
+  readonly resolved: readonly ResolvedEntry[];
+  readonly problems: readonly TemplateApplyProblem[];
+};
+
+/**
+ * Resolve every entry in a template document to a concrete block pack.
+ *
+ * The first stage of an apply, and the only one that touches the network. It runs
+ * before the project exists, which is what makes "no block for this entry" a message
+ * about a file rather than a half-built project — and it is also why the whole
+ * construction API downstream can be synchronous.
+ *
+ * Every entry is attempted, and every failure collected: an unapplicable file should
+ * take one pass to fix, not one pass per bad entry. The one exception is that a
+ * problem short-circuits nothing, so `resolved` may be shorter than the document.
+ *
+ * @param document A parsed template document
+ * @param provider Where blocks come from
+ * @param options `allowUnstable` applies to the whole document, not per entry
+ */
+export async function resolveTemplateEntries(
+  document: ProjectTemplateV1,
+  provider: BlockPackProvider,
+  options: { allowUnstable: boolean },
+): Promise<TemplateResolveOutcome> {
+  const resolved: ResolvedEntry[] = [];
+  const problems: TemplateApplyProblem[] = [];
+
+  // Sequential, not concurrent. Entries commonly share a kind, and a provider
+  // caching its reads can only dedupe them if the second request happens after the
+  // first has landed. A template holds a handful of entries, so there is nothing to
+  // win by overlapping the reads.
+  for (const entry of document.blocks) {
+    const outcome = await resolveEntry(entry, provider, options);
+    if (outcome.ok) resolved.push(outcome.entry);
+    else problems.push(outcome.problem);
+  }
+
+  return { resolved, problems };
+}
+
+type EntryOutcome =
+  | { ok: true; entry: ResolvedEntry }
+  | { ok: false; problem: TemplateApplyProblem };
+
+async function resolveEntry(
+  entry: ProjectTemplateV1Entry,
+  provider: BlockPackProvider,
+  options: { allowUnstable: boolean },
+): Promise<EntryOutcome> {
+  const problem = (error: string): EntryOutcome => ({
+    ok: false,
+    problem: { entryId: entry.id, error },
+  });
+
+  if (entry.location !== undefined) {
+    const outcome = await provider.byLocation(entry.location);
+
+    if (!outcome.ok) {
+      switch (outcome.reason) {
+        case "unsupported-scheme":
+          return problem(
+            `This entry says its block is at '${entry.location}', which this application ` +
+              `cannot read. Only a local path ('file:') is supported here.`,
+          );
+        case "not-found":
+          return problem(
+            `Nothing is at '${entry.location}', where this entry says its block is. A ` +
+              `template that pins a folder only works on the machine that folder is on.`,
+          );
+        case "not-a-block":
+          return problem(
+            `'${entry.location}' is not a block: it holds neither a built block package ` +
+              `nor a block's manifest. Point the entry at the folder holding the block's ` +
+              `package.json.`,
+          );
+      }
+    }
+
+    // The entry's kind is not what found this block, but it is still the contract its
+    // params were written against, so the block has to actually implement it.
+    const mismatch = kindMismatch(entry.kind, outcome.kind);
+    if (mismatch !== undefined) return problem(`${mismatch} (${entry.location})`);
+
+    return {
+      ok: true,
+      entry: { entryId: entry.id, spec: outcome.spec, title: outcome.title, pinned: true },
+    };
+  }
+
+  if (entry.block !== undefined) {
+    let id: BlockPackId;
+    try {
+      const { name, version } = parseBlockPackReference(entry.block);
+      id = { ...parseBlockPackName(name), version };
+    } catch (e) {
+      // The document's parser already checked the `{name}@X.Y.Z` grammar, but not
+      // that the name carries an organization, so this is reachable from a
+      // hand-written file. Reported rather than thrown, so one malformed entry cannot
+      // hide the state of the rest.
+      return problem(`Pinned block version is not readable: ${messageOf(e)}`);
+    }
+
+    const outcome = await provider.byExactVersion(id);
+    if (outcome.ok)
+      return {
+        ok: true,
+        entry: { entryId: entry.id, spec: outcome.spec, title: outcome.title, pinned: true },
+      };
+
+    return problem(
+      `Block '${id.organization}/${id.name}' version ${id.version} was not found. Correct ` +
+        `the pinned version in this entry, or remove it so a version is chosen ` +
+        `automatically.`,
+    );
+  }
+
+  let kindName: string;
+  try {
+    kindName = parseKindSelectorReference(entry.kind).name;
+  } catch (e) {
+    return problem(`Block kind is not readable: ${messageOf(e)}`);
+  }
+
+  const outcome = await provider.byKind(entry.kind, options);
+  if (outcome.ok)
+    return {
+      ok: true,
+      entry: { entryId: entry.id, spec: outcome.spec, title: outcome.title, pinned: false },
+    };
+
+  switch (outcome.reason) {
+    case "no-matching-kind-version":
+      return problem(
+        `No published version of '${kindName}' matches what this entry asks for ` +
+          `(${entry.kind}). Check the version, or update the block registry.`,
+      );
+    case "no-implementation":
+      return problem(
+        `'${kindName}' has no block implementing the version this entry asks for ` +
+          `(${entry.kind}). Nothing can be installed for it yet.`,
+      );
+    case "no-stable-implementation":
+      // The one failure with a way out that changes nothing in the file, so the
+      // message names it.
+      return problem(
+        `The only blocks implementing '${kindName}' for this entry (${entry.kind}) are ` +
+          `pre-release versions. Import again with unstable versions allowed to use them.`,
+      );
+  }
+}
+
+/**
+ * Why the block found at a location cannot serve the entry that named it, or
+ * `undefined` when it can.
+ *
+ * The check the registry route gets for free: there, the kind's own projection picks
+ * the block, so the block provably implements the kind. A location skips that, and a
+ * folder's contents can change without the file changing — so the same guarantee has
+ * to be re-established by asking the implementation what it implements.
+ *
+ * Version comparison goes through the same selector-to-range translation the registry
+ * resolver uses, so "this resolves locally" and "this would resolve once published"
+ * cannot disagree about the version math.
+ */
+function kindMismatch(
+  asked: BlockKindSelectorReference,
+  declared: BlockKindReference | undefined,
+): string | undefined {
+  if (declared === undefined) {
+    return (
+      "The block at this location declares no kind, so it cannot be the implementation " +
+      "this entry asks for"
+    );
+  }
+
+  let wanted: { name: string; selector: { op: "exact" | "patch" | "minor"; version: string } };
+  let has: { name: string; version: string };
+  try {
+    wanted = parseKindSelectorReference(asked);
+    has = parseKindRef(declared);
+  } catch (e) {
+    // The entry's own selector was checked when the document was parsed, so this is
+    // the block's stored reference being unreadable.
+    return `The block at this location declares an unreadable kind: ${messageOf(e)}`;
+  }
+
+  if (wanted.name !== has.name) {
+    return (
+      `This entry asks for kind '${wanted.name}', but the block at this location ` +
+      `implements '${has.name}'`
+    );
+  }
+
+  if (!semver.satisfies(has.version, selectorToRange(wanted.selector))) {
+    return (
+      `This entry asks for '${asked}', but the block at this location implements ` +
+      `version ${has.version} of that kind`
+    );
+  }
+
+  return undefined;
+}
+
+/**
+ * Split a block package's npm name into the organization and name a registry knows
+ * it by: `@npm-scope/organization.name` → `{ organization, name }`.
+ *
+ * The npm scope and the organization are different things, and only the second one
+ * reaches the registry — `@milaboratories/milaboratories.test-download-file` is
+ * published as organization `milaboratories`, name `test-download-file`. The split is
+ * on the FIRST dot, so a name may contain further dots.
+ *
+ * Kind names follow the same convention, which is why a template can carry both in
+ * the same npm-ish form.
+ *
+ * @throws if the name has no npm scope or no organization segment
+ */
+export function parseBlockPackName(npmName: string): { organization: string; name: string } {
+  const slash = npmName.indexOf("/");
+  if (!npmName.startsWith("@") || slash < 0) {
+    throw new Error(`expected '@npm-scope/organization.name', got '${npmName}'`);
+  }
+
+  const base = npmName.slice(slash + 1);
+  const dot = base.indexOf(".");
+  if (dot <= 0 || dot === base.length - 1) {
+    throw new Error(
+      `'${base}' does not separate an organization from a name with '.' in '${npmName}'`,
+    );
+  }
+
+  return { organization: base.slice(0, dot), name: base.slice(dot + 1) };
+}
+
+function messageOf(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
diff --git a/lib/node/pl-middle-layer/src/model/template_serializer.test.ts b/lib/node/pl-middle-layer/src/model/template_serializer.test.ts
new file mode 100644
index 0000000000..b93f7bfb1b
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_serializer.test.ts
@@ -0,0 +1,397 @@
+import { describe, expect, test } from "vitest";
+import YAML from "yaml";
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
+import {
+  createPlRef,
+  toTemplateRef,
+  kindReferenceToSelectorReference,
+  parseProjectTemplateV1,
+} from "@milaboratories/pl-model-common";
+import type { BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
+import type { ProjectStructure } from "./project_model";
+import type { TemplateParamsResult } from "./template_export";
+import {
+  assembleProjectTemplateV1,
+  exportProjectAsTemplateV1,
+  locationOf,
+  stringifyProjectTemplateV1,
+} from "./template_serializer";
+
+function simpleStructure(...ids: string[]): ProjectStructure {
+  return {
+    groups: [
+      {
+        id: "g1",
+        label: "G1",
+        blocks: ids.map((id) => ({ id, label: id, renderingMode: "Heavy" })),
+      },
+    ],
+  };
+}
+
+const ok = (value: unknown): TemplateParamsResult => ({ value });
+
+const kindOf = (name: string, version = "1.4.2") =>
+  `@platforma-open/milaboratories.${name}.kind@${version}` as BlockKindReference;
+
+/** Every block gets a kind derived from its own id. */
+const kindPerBlock = (blockId: string) => kindOf(blockId);
+
+/** A registry-installed block: found by name, so it needs no locator. */
+const registrySpec: BlockPackSpec = {
+  type: "from-registry-v2",
+  registryUrl: "https://block.registry.platforma.bio/releases",
+  id: { organization: "milaboratories", name: "demo", version: "1.4.2" },
+  channel: "stable",
+};
+
+const devSpec = (folder: string): BlockPackSpec => ({ type: "dev-v2", folder });
+
+function exportOf(
+  structure: ProjectStructure,
+  params: Record<string, TemplateParamsResult>,
+  kinds: (blockId: string) => BlockKindReference | undefined = kindPerBlock,
+  specs: (blockId: string) => BlockPackSpec | undefined = () => registrySpec,
+) {
+  return exportProjectAsTemplateV1(structure, (id) => params[id], kinds, specs);
+}
+
+describe("the document", () => {
+  test("an entry is the block id, its exact kind, and its params", () => {
+    const result = exportOf(simpleStructure("samples"), {
+      samples: ok({ dataset: "bulk-rna" }),
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.document).toEqual({
+      schema: "template-v1",
+      blocks: [
+        {
+          id: "samples",
+          kind: "@platforma-open/milaboratories.samples.kind@1.4.2",
+          params: { dataset: "bulk-rna" },
+        },
+      ],
+    });
+  });
+
+  test("the kind is emitted at the exact tier, never widened to a range", () => {
+    // A block implements exactly one kind version, so pinning it is the whole
+    // point; a `~` or `^` tier would let apply pick a different params contract.
+    const result = exportOf(simpleStructure("a"), { a: ok({}) });
+
+    expect(result.ok && result.document.blocks[0].kind).toBe(
+      "@platforma-open/milaboratories.a.kind@1.4.2",
+    );
+  });
+
+  test("no `block` override is emitted", () => {
+    // The override pins an implementation against a kind version *range*. Export
+    // writes the exact version, so there is nothing left for it to pin.
+    const result = exportOf(simpleStructure("a"), { a: ok({}) });
+
+    expect(result.ok && "block" in result.document.blocks[0]).toBe(false);
+  });
+
+  test("empty params are written as `params: {}`, never as `params: null`", () => {
+    // Every entry carries a `params` key, because every block projects one. `null` would
+    // be a third thing the schema does not define, and a reader would have to guess.
+    const result = exportOf(simpleStructure("empty"), { empty: ok({}) });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.document.blocks[0].params).toEqual({});
+    expect(result.yaml).toContain("params: {}");
+    expect(result.yaml).not.toContain("params: null");
+  });
+
+  test("entry order is structure order", () => {
+    const result = exportOf(simpleStructure("samples", "mixcr", "browser"), {
+      samples: ok({}),
+      mixcr: ok({ input: toTemplateRef(createPlRef("samples", "reads")) }),
+      browser: ok({ clones: toTemplateRef(createPlRef("mixcr", "clonotypes")) }),
+    });
+
+    expect(result.ok && result.document.blocks.map((b) => b.id)).toEqual([
+      "samples",
+      "mixcr",
+      "browser",
+    ]);
+  });
+});
+
+describe("the YAML", () => {
+  test("round-trips through the import-side parser unchanged", () => {
+    // The one property that matters: export emits exactly what import parses.
+    const result = exportOf(simpleStructure("samples", "mixcr"), {
+      samples: ok({ dataset: "bulk-rna", replicates: [1, 2, 3] }),
+      mixcr: ok({
+        input: toTemplateRef(createPlRef("samples", "reads")),
+        species: "hsa",
+        nested: { deep: { flag: true, absent: null } },
+      }),
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(parseProjectTemplateV1(YAML.parse(result.yaml))).toEqual(result.document);
+  });
+
+  test("opens with the schema marker", () => {
+    const result = exportOf(simpleStructure("a"), { a: ok({}) });
+
+    expect(result.ok && result.yaml.startsWith("schema: template-v1\n")).toBe(true);
+  });
+
+  test("nothing is line-folded", () => {
+    // A folded scalar still parses, but it makes a diff between two exported
+    // templates unreadable, which is most of the reason to emit YAML at all.
+    const long = "x".repeat(400);
+    const yaml = stringifyProjectTemplateV1({
+      schema: "template-v1",
+      blocks: [
+        {
+          id: "a",
+          kind: kindReferenceToSelectorReference(kindOf("a")),
+          params: { note: long },
+        },
+      ],
+    });
+
+    expect(yaml).toContain(long);
+  });
+
+  test("a reference is written as the block wrapped it, contents untouched", () => {
+    // How the engine finds a reference on apply, so the wrapper's presence in the file is
+    // part of the contract rather than a rendering detail. What is inside it is the block's
+    // own value, written verbatim.
+    const result = exportOf(simpleStructure("samples", "mixcr"), {
+      samples: ok({}),
+      mixcr: ok({ input: toTemplateRef(createPlRef("samples", "reads")) }),
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.yaml).toContain("$ref:");
+    expect(result.yaml).toContain("__isRef: true");
+    expect(result.yaml).toContain("blockId: samples");
+    expect(result.document.blocks[1].params).toEqual({
+      input: { $ref: createPlRef("samples", "reads") },
+    });
+  });
+});
+
+describe("problems", () => {
+  test("a kind-less block fails the export and is named", () => {
+    // Every block published before kinds existed is in this state, so this is the
+    // common case today rather than an edge one.
+    const result = exportOf(
+      simpleStructure("modern", "legacy"),
+      { modern: ok({}), legacy: ok({}) },
+      (id) => (id === "legacy" ? undefined : kindOf(id)),
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.problems).toHaveLength(1);
+    expect(result.problems[0].blockId).toBe("legacy");
+    expect(result.problems[0].error).toContain("declares no kind");
+  });
+
+  test("a malformed stored kind reference is a problem, not a throw", () => {
+    const result = exportOf(
+      simpleStructure("a"),
+      { a: ok({}) },
+      () => "no-version-here" as BlockKindReference,
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.problems[0].blockId).toBe("a");
+    expect(result.problems[0].error).toContain("malformed");
+  });
+
+  test("a reference to a block that is not in the project is NOT caught", () => {
+    // Deleting a block only removes it from the structure and does not rewrite downstream
+    // args, so a live project holds such references routinely. Recognizing one would mean
+    // knowing which values are identifiers, which the engine deliberately does not — so the
+    // reference is written out and surfaces on apply as a block wired to nothing.
+    const result = exportOf(simpleStructure("survivor"), {
+      survivor: ok({ input: toTemplateRef(createPlRef("deleted-upstream", "reads")) }),
+    });
+
+    expect(result.ok).toBe(true);
+  });
+
+  test("a forward reference is caught, and named as one", () => {
+    const result = exportOf(simpleStructure("downstream", "upstream"), {
+      downstream: ok({ input: toTemplateRef(createPlRef("upstream", "reads")) }),
+      upstream: ok({}),
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.problems[0].error).toContain("declared after it");
+  });
+
+  test("walk problems and assembly problems are reported together, in one pass", () => {
+    // Fixing an export should take one round, not one round per broken block.
+    const result = exportOf(
+      simpleStructure("unreadable", "kindless", "fine"),
+      { kindless: ok({}), fine: ok({}) },
+      (id) => (id === "kindless" ? undefined : kindOf(id)),
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.problems.map((p) => p.blockId).sort()).toEqual(["kindless", "unreadable"]);
+  });
+
+  test("no partial YAML is produced when anything is wrong", () => {
+    // All-or-nothing: a template missing blocks the user never chose to leave out
+    // would still look like a successful export.
+    const result = exportOf(simpleStructure("a", "b"), { a: ok({}), b: ok({}) }, (id) =>
+      id === "b" ? undefined : kindOf(id),
+    );
+
+    expect(result).not.toHaveProperty("yaml");
+  });
+
+  test("an empty project exports an empty template", () => {
+    const result = exportOf(simpleStructure(), {});
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.document.blocks).toEqual([]);
+    expect(parseProjectTemplateV1(YAML.parse(result.yaml))).toEqual(result.document);
+  });
+});
+
+describe("locationOf", () => {
+  test("a dev block's folder becomes a file URL", () => {
+    expect(locationOf(devSpec("/Users/dev/blocks/enter-numbers/block"))).toBe(
+      "file:///Users/dev/blocks/enter-numbers/block",
+    );
+  });
+
+  test("a path with a space is encoded, not written raw", () => {
+    // A raw space makes the value not a URI at all, so it would be rejected by the
+    // document parser on the way back in.
+    expect(locationOf(devSpec("/Users/dev/my blocks/x"))).toBe("file:///Users/dev/my%20blocks/x");
+  });
+
+  test("an npm-consumed pack's own URL is passed through untouched", () => {
+    // The block emitted this locator itself; rebuilding one from it could only lose
+    // information, and the pack directory is not derivable from the package root.
+    expect(
+      locationOf({
+        type: "from-pack-v2",
+        packUrl: "file:///repo/node_modules/@o/x/block-pack",
+        rootUrl: "file:///repo/node_modules/@o/x",
+      }),
+    ).toBe("file:///repo/node_modules/@o/x/block-pack");
+  });
+
+  test("a registry block gets no locator, which is what keeps it portable", () => {
+    expect(locationOf(registrySpec)).toBeUndefined();
+    expect(
+      locationOf({
+        type: "from-registry-v1",
+        registryUrl: "https://old",
+        id: { organization: "o", name: "n", version: "1.0.0" },
+      }),
+    ).toBeUndefined();
+  });
+
+  test("a legacy dev block gets none either", () => {
+    // It predates kinds, so it has no kind reference and the assembler refuses it
+    // before a locator would matter.
+    expect(locationOf({ type: "dev-v1", folder: "/Users/dev/old" })).toBeUndefined();
+  });
+});
+
+describe("locating a block installed from a folder", () => {
+  test("the entry carries the folder, and keeps the kind alongside it", () => {
+    const result = exportOf(
+      simpleStructure("samples"),
+      { samples: ok({ dataset: "bulk-rna" }) },
+      kindPerBlock,
+      () => devSpec("/Users/dev/blocks/samples/block"),
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.document.blocks[0].location).toBe("file:///Users/dev/blocks/samples/block");
+    // The kind stays alongside: it is the params contract, not the locator.
+    expect(result.document.blocks[0].kind).toBe(
+      kindReferenceToSelectorReference(kindOf("samples")),
+    );
+  });
+
+  test("what is written survives the round trip through YAML", () => {
+    const result = exportOf(simpleStructure("samples"), { samples: ok({}) }, kindPerBlock, () =>
+      devSpec("/Users/dev/blocks/samples/block"),
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(parseProjectTemplateV1(YAML.parse(result.yaml))).toEqual(result.document);
+  });
+
+  test("a registry-only project is portable and says nothing", () => {
+    const result = exportOf(simpleStructure("samples"), { samples: ok({}) });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect("location" in result.document.blocks[0]).toBe(false);
+  });
+
+  test("a block whose origin is unknown is written without a locator", () => {
+    // Not a failure: an entry with no locator is the normal, portable form, and the
+    // kind is what the importer resolves.
+    const result = exportOf(
+      simpleStructure("samples"),
+      { samples: ok({}) },
+      kindPerBlock,
+      () => undefined,
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect("location" in result.document.blocks[0]).toBe(false);
+  });
+
+  test("a locator is written per block, and only for the located ones", () => {
+    const result = exportOf(
+      simpleStructure("a", "b", "c"),
+      { a: ok({}), b: ok({}), c: ok({}) },
+      kindPerBlock,
+      (id) => (id === "b" ? registrySpec : devSpec(`/Users/dev/blocks/${id}/block`)),
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.document.blocks.map((e) => e.location)).toEqual([
+      "file:///Users/dev/blocks/a/block",
+      undefined,
+      "file:///Users/dev/blocks/c/block",
+    ]);
+  });
+});
+
+describe("assembleProjectTemplateV1", () => {
+  test("carries the walk's problems through unchanged", () => {
+    const { document, problems } = assembleProjectTemplateV1(
+      {
+        entries: [{ blockId: "a", params: {} }],
+        problems: [{ blockId: "ghost", error: "state unavailable" }],
+      },
+      kindPerBlock,
+      () => registrySpec,
+    );
+
+    expect(problems).toEqual([{ blockId: "ghost", error: "state unavailable" }]);
+    expect(document.blocks.map((b) => b.id)).toEqual(["a"]);
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_serializer.ts b/lib/node/pl-middle-layer/src/model/template_serializer.ts
new file mode 100644
index 0000000000..0d23cd4ff4
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_serializer.ts
@@ -0,0 +1,234 @@
+import YAML from "yaml";
+import { pathToFileURL } from "node:url";
+import type {
+  BlockKindReference,
+  BlockKindSelectorReference,
+  BlockPackLocationReference,
+  ProjectTemplateV1,
+  ProjectTemplateV1Entry,
+} from "@milaboratories/pl-model-common";
+import {
+  PROJECT_TEMPLATE_SCHEMA_V1,
+  findProjectTemplateV1ReferenceProblems,
+  kindReferenceToSelectorReference,
+  parseProjectTemplateV1,
+} from "@milaboratories/pl-model-common";
+import type { BlockPackSpec } from "@milaboratories/pl-model-middle-layer";
+import type { ProjectStructure } from "./project_model";
+import type {
+  TemplateExportProblem,
+  TemplateExportWalk,
+  TemplateParamsResult,
+} from "./template_export";
+import { walkProjectForTemplateExport } from "./template_export";
+
+/** A block's exact kind reference, or `undefined` for a block that declares no kind. */
+export type BlockKindProvider = (blockId: string) => BlockKindReference | undefined;
+
+/**
+ * A block's origin spec — where the installed block came from — or `undefined` when
+ * it is not known for that block.
+ *
+ * The project stores this next to the kind reference, so both are read from the same
+ * place and neither costs an extra round-trip.
+ */
+export type BlockPackSpecProvider = (blockId: string) => BlockPackSpec | undefined;
+
+/** What the caller gets back for a whole project. */
+export type ProjectTemplateExportOutcome =
+  | {
+      readonly ok: true;
+      readonly yaml: string;
+      /** The document the YAML was rendered from, already validated. */
+      readonly document: ProjectTemplateV1;
+    }
+  | {
+      readonly ok: false;
+      /** Every block that stands in the way, not just the first. */
+      readonly problems: readonly TemplateExportProblem[];
+    };
+
+/**
+ * The `location` to write for a block installed from the filesystem, or `undefined`
+ * for one that came from a registry and therefore needs no locator.
+ *
+ * Both filesystem spec shapes are emitted, and they anchor at different directories
+ * — a dev block at its facade package, an npm-consumed one at its block-pack folder.
+ * The document does not distinguish them: one URI is written either way, and telling
+ * the two layouts apart is done by looking at what is actually there, by the side
+ * that has the filesystem anyway. Encoding the layout in the file instead would
+ * freeze today's two shapes into the format.
+ *
+ * A dev spec carries an OS path and is converted here, which also percent-encodes a
+ * path containing spaces. An npm-consumed spec already carries a `file:` URL and is
+ * passed through: it is the locator the block itself emitted, and reconstructing one
+ * from it could only lose information.
+ */
+export function locationOf(spec: BlockPackSpec): BlockPackLocationReference | undefined {
+  switch (spec.type) {
+    case "dev-v2":
+      return pathToFileURL(spec.folder).href as BlockPackLocationReference;
+    case "from-pack-v2":
+      return spec.packUrl as BlockPackLocationReference;
+    // A registry block is found by name, which is what makes the entry portable —
+    // writing where this machine happened to cache it would take that away. `dev-v1`
+    // predates kinds entirely, so such a block has no kind and never reaches here.
+    case "dev-v1":
+    case "from-registry-v1":
+    case "from-registry-v2":
+      return undefined;
+  }
+}
+
+/**
+ * Turn a project into a template document.
+ *
+ * Assembly is deliberately dull — the entry is the block's id, its widened kind
+ * reference, and the params the walk already collected. The interesting decisions
+ * were made upstream; what is left here is the two things only this layer can
+ * check, both of which produce problems rather than a broken file:
+ *
+ * - **A block with no kind cannot be written.** An entry's `kind` is required — it
+ *   is the params contract the entry is typed against — while a block's kind is
+ *   optional, so a block that predates kinds, or that uses the deprecated
+ *   kind-less model overload, has no legal entry. Reported per block. This is not
+ *   an edge case today: it is what most existing projects will hit until their
+ *   blocks are republished.
+ * - **References must point at an entry declared earlier.** Verbatim id reuse
+ *   means a reference to a deleted block survives into the file naming nothing:
+ *   deleting a block only removes it from the structure and does not rewrite
+ *   downstream args, so a live project holds such references routinely.
+ *
+ * `block` is never emitted. That override exists to pin an implementation against
+ * a kind's version range, and export always writes the exact version the block
+ * implements, so there is nothing left for it to pin.
+ *
+ * `location` IS emitted, for every block that was installed from the filesystem. Such
+ * a block is not in any registry, so the kind reference alone names nothing the
+ * importer could find, and a file that omitted the one usable answer would describe a
+ * project that cannot be recreated. It costs portability, and nothing says so: such a
+ * file is the debugging path, read by the developer who wrote it on the machine that
+ * wrote it.
+ *
+ * Problems from `walk` are carried through, so a caller can hand a walk straight
+ * in and get one combined list.
+ */
+export function assembleProjectTemplateV1(
+  walk: TemplateExportWalk,
+  kindProvider: BlockKindProvider,
+  specProvider: BlockPackSpecProvider,
+): { document: ProjectTemplateV1; problems: readonly TemplateExportProblem[] } {
+  const problems: TemplateExportProblem[] = [...walk.problems];
+  const blocks: ProjectTemplateV1Entry[] = [];
+
+  for (const entry of walk.entries) {
+    const kind = kindProvider(entry.blockId);
+
+    if (kind === undefined) {
+      problems.push({
+        blockId: entry.blockId,
+        error:
+          "Block declares no kind, so it cannot be written to a template: an entry's kind " +
+          "carries the params contract the entry is typed against",
+      });
+      continue;
+    }
+
+    let selector: BlockKindSelectorReference;
+    try {
+      // Widening validates, and therefore throws — which is why it happens here
+      // and not where the reference is read: every read site sits inside a
+      // recomputed project overview, where one malformed stored reference must not
+      // be able to break unrelated blocks.
+      selector = kindReferenceToSelectorReference(kind);
+    } catch (e) {
+      problems.push({
+        blockId: entry.blockId,
+        error: `Block's stored kind reference is malformed: ${e instanceof Error ? e.message : String(e)}`,
+      });
+      continue;
+    }
+
+    const spec = specProvider(entry.blockId);
+    const location = spec === undefined ? undefined : locationOf(spec);
+
+    blocks.push({
+      id: entry.blockId,
+      kind: selector,
+      params: entry.params,
+      ...(location !== undefined ? { location } : {}),
+    });
+  }
+
+  const document: ProjectTemplateV1 = { schema: PROJECT_TEMPLATE_SCHEMA_V1, blocks };
+
+  for (const problem of findProjectTemplateV1ReferenceProblems(document)) {
+    problems.push({ blockId: problem.entryId, error: problem.message });
+  }
+
+  return { document, problems };
+}
+
+/**
+ * Render a template document to YAML text.
+ *
+ * Two non-default emitter settings, both about the file being read by someone
+ * else's code:
+ *
+ * - **No line folding.** A wrapped scalar still parses, but it makes a diff between
+ *   two exported templates unreadable, which is most of the reason to prefer YAML
+ *   over JSON here.
+ * - **Quote as if the reader were YAML 1.1**, while still parsing as 1.2. YAML 1.2
+ *   dropped `yes`/`no`/`on`/`off`/`y`/`n` as booleans and dropped sexagesimal
+ *   integers, so a 1.2 emitter leaves a params value of `"yes"` or `"1:30"` bare —
+ *   which a 1.1 reader (PyYAML's default, and Go's yaml.v2) turns into `true` and
+ *   `90`. A template is a contract for a second implementation, so the safe
+ *   combination is to quote against the stricter ruleset and read with the looser
+ *   one: a quoted scalar means the same thing under both. This adds no `%YAML`
+ *   directive — it only changes which scalars get quotes.
+ */
+export function stringifyProjectTemplateV1(document: ProjectTemplateV1): string {
+  return YAML.stringify(document, { lineWidth: 0, version: "1.1" });
+}
+
+/**
+ * Export a project as `template-v1` YAML, or report every reason it cannot be.
+ *
+ * All-or-nothing on purpose. A partial template silently drops blocks and the
+ * surviving entries may reference the dropped ones, so what looks like a
+ * successful export would produce a project missing pieces the user never chose
+ * to leave out. Reporting everything at once instead of failing on the first
+ * problem is the other half of that: fixing an export should take one pass.
+ *
+ * @param structure The project structure, which supplies both membership and order
+ * @param paramsProvider A block's derived template params, in live form
+ * @param kindProvider A block's exact kind reference, read from its stored config
+ * @param specProvider A block's origin spec, read from the same stored container
+ */
+export function exportProjectAsTemplateV1(
+  structure: ProjectStructure,
+  paramsProvider: (blockId: string) => TemplateParamsResult | undefined,
+  kindProvider: BlockKindProvider,
+  specProvider: BlockPackSpecProvider,
+): ProjectTemplateExportOutcome {
+  const walk = walkProjectForTemplateExport(structure, paramsProvider);
+  const { document, problems } = assembleProjectTemplateV1(walk, kindProvider, specProvider);
+
+  if (problems.length > 0) return { ok: false, problems };
+
+  // Export must emit exactly what import parses, so that is asserted on every
+  // export rather than only in tests — running the import-side parser over the
+  // document we are about to write is the cheapest possible proof of it. Nothing
+  // user-facing is expected to fail here: the kind grammar was checked by the
+  // widening above, params were checked to be a mapping by the walk, and the
+  // reference rules by the assembler. A throw means a bug in the assembler, with
+  // one known exception: a project structure holding two blocks with the same id,
+  // which is reachable through the mutator and produces duplicate entry ids.
+  parseProjectTemplateV1(document);
+
+  return {
+    ok: true,
+    yaml: stringifyProjectTemplateV1(document),
+    document,
+  };
+}
diff --git a/lib/node/pl-middle-layer/src/model/template_serializer_fixtures.test.ts b/lib/node/pl-middle-layer/src/model/template_serializer_fixtures.test.ts
new file mode 100644
index 0000000000..fe397a108e
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_serializer_fixtures.test.ts
@@ -0,0 +1,274 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import YAML from "yaml";
+import type { BlockKindReference, ColumnUniversalId } from "@milaboratories/pl-model-common";
+import {
+  createColumnFilteredId,
+  createGlobalPObjectId,
+  createPlRef,
+  parseProjectTemplateV1,
+  wrapTemplateRefs,
+} from "@milaboratories/pl-model-common";
+import type { ProjectStructure } from "./project_model";
+import type { TemplateParamsResult } from "./template_export";
+import { exportProjectAsTemplateV1 } from "./template_serializer";
+
+/**
+ * Golden-file tests for the exported document's TEXT.
+ *
+ * The sibling `template_serializer.test.ts` asserts the document field by field,
+ * which says nothing about how it is rendered. These pin the bytes: key order,
+ * indentation, how `params` nests, which scalars get quoted, and that nothing is
+ * line-folded. That is what "export emits exactly what import parses" rests on,
+ * and what makes a diff between two exported templates readable.
+ *
+ * Each expected file lives on disk rather than in a snapshot, deliberately. There
+ * is no snapshot infrastructure in this repo to fit into, and a snapshot carries an
+ * `-u` flag that rewrites the expectation without anyone reading it — for a file
+ * format promised to a second implementation, changing the expectation should be a
+ * deliberate edit that shows up in review. To update one, run the test, read the
+ * diff, and write the new content in by hand.
+ *
+ * Every fixture is also parsed back with the import-side parser, so a golden file
+ * can never be updated to something import cannot read.
+ */
+const FIXTURE_DIR = join(import.meta.dirname, "..", "..", "test_fixtures", "template-v1");
+
+/**
+ * Params as the block's callback hands them over: written live, with every identifier marked
+ * by the same pass that runs inside a block's bundle. Spelling the wrappers by hand instead
+ * would pin what a test author believed the projection does.
+ */
+const ok = (value: unknown): TemplateParamsResult => ({ value: wrapTemplateRefs(value) });
+
+const kind = (name: string, version: string) =>
+  `@platforma-open/milaboratories.${name}.kind@${version}` as BlockKindReference;
+
+function structureOf(...ids: string[]): ProjectStructure {
+  return {
+    groups: [
+      {
+        id: "g1",
+        label: "Main",
+        blocks: ids.map((id) => ({ id, label: id, renderingMode: "Heavy" })),
+      },
+    ],
+  };
+}
+
+type Fixture = {
+  /** File under `test_fixtures/template-v1/`, and the test's name. */
+  readonly file: string;
+  /** What each fixture is here to pin — one property per fixture, not a grab bag. */
+  readonly pins: string;
+  readonly structure: ProjectStructure;
+  readonly params: Record<string, TemplateParamsResult>;
+  readonly kinds: Record<string, BlockKindReference>;
+};
+
+const FIXTURES: readonly Fixture[] = [
+  {
+    file: "empty-project.yaml",
+    pins: "an empty project is still a valid document, not an empty file",
+    structure: structureOf(),
+    params: {},
+    kinds: {},
+  },
+  {
+    file: "minimal.yaml",
+    pins: "the schema marker comes first, and a block with nothing to project renders `params: {}`",
+    structure: structureOf("11111111-1111-4111-8111-111111111111"),
+    params: { "11111111-1111-4111-8111-111111111111": ok({}) },
+    kinds: { "11111111-1111-4111-8111-111111111111": kind("pool-explorer", "1.0.0") },
+  },
+  {
+    file: "linear-chain.yaml",
+    pins: "the canonical shape — three blocks wired in a chain, ids reused verbatim",
+    structure: structureOf(
+      "aaaaaaaa-0000-4000-8000-000000000001",
+      "bbbbbbbb-0000-4000-8000-000000000002",
+      "cccccccc-0000-4000-8000-000000000003",
+    ),
+    params: {
+      "aaaaaaaa-0000-4000-8000-000000000001": ok({ dataset: "bulk-rna" }),
+      "bbbbbbbb-0000-4000-8000-000000000002": ok({
+        input: createPlRef("aaaaaaaa-0000-4000-8000-000000000001", "reads"),
+        species: "hsa",
+      }),
+      "cccccccc-0000-4000-8000-000000000003": ok({
+        clonotypes: createPlRef("bbbbbbbb-0000-4000-8000-000000000002", "clonotypes"),
+      }),
+    },
+    kinds: {
+      "aaaaaaaa-0000-4000-8000-000000000001": kind("import-fastq", "2.1.0"),
+      "bbbbbbbb-0000-4000-8000-000000000002": kind("mixcr-clonotyping", "3.0.4"),
+      "cccccccc-0000-4000-8000-000000000003": kind("clonotype-browser", "1.2.10"),
+    },
+  },
+  {
+    file: "nested-params.yaml",
+    pins: "how nesting renders — objects in arrays, references at depth, an empty object",
+    structure: structureOf(
+      "dddddddd-0000-4000-8000-000000000004",
+      "ffffffff-0000-4000-8000-000000000006",
+    ),
+    params: {
+      "dddddddd-0000-4000-8000-000000000004": ok({}),
+      "ffffffff-0000-4000-8000-000000000006": ok({
+        thresholds: { min: 0.01, max: 1, exact: 0.5 },
+        steps: [
+          { name: "filter", enabled: true },
+          { name: "cluster", enabled: false, seed: 42 },
+        ],
+        // Two references to the same upstream, inside an array.
+        inputs: [
+          createPlRef("dddddddd-0000-4000-8000-000000000004", "a"),
+          createPlRef("dddddddd-0000-4000-8000-000000000004", "b"),
+        ],
+        advanced: {},
+        tags: [],
+        note: null,
+      }),
+    },
+    kinds: {
+      "dddddddd-0000-4000-8000-000000000004": kind("import-fastq", "2.1.0"),
+      "ffffffff-0000-4000-8000-000000000006": kind("clonotype-clustering", "0.4.1"),
+    },
+  },
+  {
+    file: "wrapped-refs.yaml",
+    pins: "each identifier is marked where it sits, and written verbatim whatever its form",
+    structure: structureOf(
+      "aaaaaaaa-0000-4000-8000-000000000001",
+      "bbbbbbbb-0000-4000-8000-000000000002",
+    ),
+    params: {
+      "aaaaaaaa-0000-4000-8000-000000000001": ok({}),
+      "bbbbbbbb-0000-4000-8000-000000000002": ok({
+        // A filtered column id — a canonical JSON string with the block id buried inside it.
+        // The engine writes it as it came and redirects the id textually on apply; nothing
+        // here parses the identifier.
+        anchor: createColumnFilteredId({
+          source: createGlobalPObjectId(
+            "aaaaaaaa-0000-4000-8000-000000000001",
+            "clonotypes",
+          ) as ColumnUniversalId,
+          axisFilters: [[0, "IGH"]],
+        }),
+        // The same column as a `PlRef` object, marked the same way.
+        upstream: createPlRef("aaaaaaaa-0000-4000-8000-000000000001", "clonotypes"),
+      }),
+    },
+    kinds: {
+      "aaaaaaaa-0000-4000-8000-000000000001": kind("import-fastq", "2.1.0"),
+      "bbbbbbbb-0000-4000-8000-000000000002": kind("clonotype-browser", "1.2.10"),
+    },
+  },
+  {
+    file: "scalar-quoting.yaml",
+    pins: "strings that YAML would otherwise read back as something else stay strings",
+    structure: structureOf("eeeeeeee-0000-4000-8000-000000000005"),
+    params: {
+      "eeeeeeee-0000-4000-8000-000000000005": ok({
+        // Each of these is a real hazard: unquoted, some YAML reader turns them
+        // into a boolean, a number, a null, an alias, or a nested mapping.
+        // The first group is 1.1-only — a 1.2 emitter leaves them bare.
+        looksBoolean: "yes",
+        looksBooleanNo: "no",
+        looksBooleanOn: "on",
+        looksBooleanOff: "off",
+        looksBooleanY: "y",
+        looksBooleanN: "n",
+        looksSexagesimal: "1:30",
+        looksBooleanToo: "true",
+        looksNumeric: "1.0",
+        looksOctal: "0755",
+        looksNull: "null",
+        looksEmpty: "",
+        hasColon: "label: value",
+        startsWithAsterisk: "*anchor",
+        startsWithHash: "#not-a-comment",
+        startsWithDash: "-dash",
+        multiline: "first\nsecond",
+        unicode: "受容体 — αβ",
+        // Long enough to be folded at any default width; folding is switched off.
+        long: `${"x".repeat(200)} ${"y".repeat(200)}`,
+        actuallyBoolean: true,
+        actuallyNumeric: 1,
+      }),
+    },
+    kinds: { "eeeeeeee-0000-4000-8000-000000000005": kind("enter-numbers", "1.0.0") },
+  },
+];
+
+function exportFixture(fixture: Fixture) {
+  const result = exportProjectAsTemplateV1(
+    fixture.structure,
+    (blockId) => fixture.params[blockId],
+    (blockId) => fixture.kinds[blockId],
+    // The golden files describe portable templates, so every block is a registry one:
+    // a locator would pin them to whichever machine produced the fixture.
+    () => ({
+      type: "from-registry-v2",
+      registryUrl: "https://block.registry.platforma.bio/releases",
+      id: { organization: "milaboratories", name: "demo", version: "1.0.0" },
+      channel: "stable",
+    }),
+  );
+  if (!result.ok)
+    throw new Error(
+      `fixture '${fixture.file}' failed to export: ${result.problems.map((p) => p.error).join("; ")}`,
+    );
+  return result;
+}
+
+describe.each(FIXTURES)("$file", (fixture) => {
+  test(`renders as the golden file — ${fixture.pins}`, () => {
+    const expected = readFileSync(join(FIXTURE_DIR, fixture.file), "utf-8");
+
+    // Compared as text, not as a parsed value: the parsed comparison is the test
+    // below, and it cannot see formatting at all.
+    expect(exportFixture(fixture).yaml).toBe(expected);
+  });
+
+  test("the golden file parses back to the document it was rendered from", () => {
+    const result = exportFixture(fixture);
+    const fromDisk = readFileSync(join(FIXTURE_DIR, fixture.file), "utf-8");
+
+    expect(parseProjectTemplateV1(YAML.parse(fromDisk))).toEqual(result.document);
+  });
+});
+
+describe("what the golden files guard", () => {
+  test("no scalar is line-folded, however long", () => {
+    const yaml = exportFixture(FIXTURES.find((f) => f.file === "scalar-quoting.yaml")!).yaml;
+
+    // A folded scalar shows up as a continuation line; the value must stay on one.
+    const long = `${"x".repeat(200)} ${"y".repeat(200)}`;
+    expect(yaml).toContain(long);
+  });
+
+  test("scalars only YAML 1.1 would misread are quoted", () => {
+    // The emitter quotes against 1.1 rules even though we parse as 1.2, because the
+    // file is read by other implementations: PyYAML and Go's yaml.v2 default to 1.1,
+    // where a bare `yes` is `true` and a bare `1:30` is `90`. A 1.2 emitter leaves
+    // both bare, so this is the one formatting choice that is an interop bug rather
+    // than a matter of taste — and a round trip through our own parser cannot catch
+    // it, since 1.2 reads them back as strings either way.
+    const yaml = exportFixture(FIXTURES.find((f) => f.file === "scalar-quoting.yaml")!).yaml;
+
+    for (const bare of ["yes", "no", "on", "off", "y", "n", "1:30"]) {
+      expect(yaml).toContain(`: "${bare}"`);
+      expect(yaml).not.toContain(`: ${bare}\n`);
+    }
+  });
+
+  test("a document with no blocks is an empty sequence, not a null", () => {
+    // `blocks:` alone would parse as null and fail the schema, turning an empty
+    // project into an unreadable file.
+    const yaml = exportFixture(FIXTURES.find((f) => f.file === "empty-project.yaml")!).yaml;
+
+    expect(yaml).toContain("blocks: []");
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_validate.test.ts b/lib/node/pl-middle-layer/src/model/template_validate.test.ts
new file mode 100644
index 0000000000..408bcd51bd
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_validate.test.ts
@@ -0,0 +1,156 @@
+import { describe, expect, test } from "vitest";
+import type {
+  BlockKindSelectorReference,
+  ProjectTemplateV1,
+  ProjectTemplateV1Entry,
+} from "@milaboratories/pl-model-common";
+import {
+  PROJECT_TEMPLATE_SCHEMA_V1,
+  createPlRef,
+  toTemplateRef,
+} from "@milaboratories/pl-model-common";
+import { validateTemplateV1ForApply } from "./template_validate";
+
+/**
+ * The checks that can be made from the file alone, before anything is created.
+ */
+
+const KIND = "@platforma-open/milaboratories.demo.kind@^1.0.0" as BlockKindSelectorReference;
+
+const FOREIGN = "aaaaaaaa-0000-4000-8000-000000000001";
+
+/** An entry as the parser hands it over: `params` settled, absent read as `{}`. */
+const entry = (id: string, params: Record<string, unknown> = {}): ProjectTemplateV1Entry => ({
+  id,
+  kind: KIND,
+  params,
+});
+
+const documentOf = (...blocks: ProjectTemplateV1Entry[]): ProjectTemplateV1 => ({
+  schema: PROJECT_TEMPLATE_SCHEMA_V1,
+  blocks,
+});
+
+/**
+ * A document whose references are wrapped, as a block that projected them writes it.
+ *
+ * The unwrapped builder above stays for the opposite checks — params that carry a block id
+ * where the engine will never look for one.
+ */
+const wiredDocumentOf = (
+  ...live: readonly { id: string; params?: Record<string, unknown> }[]
+): ProjectTemplateV1 => ({
+  schema: PROJECT_TEMPLATE_SCHEMA_V1,
+  blocks: live.map((e) =>
+    entry(
+      e.id,
+      e.params === undefined
+        ? undefined
+        : Object.fromEntries(Object.entries(e.params).map(([k, v]) => [k, toTemplateRef(v)])),
+    ),
+  ),
+});
+
+describe("validateTemplateV1ForApply", () => {
+  test("a consistent document has nothing to report", () => {
+    const document = wiredDocumentOf(
+      { id: "a", params: { dataset: "bulk-rna" } },
+      { id: "b", params: { input: createPlRef("a", "reads") } },
+      { id: "c", params: { input: createPlRef("b", "clonotypes"), extra: {} } },
+    );
+
+    expect(validateTemplateV1ForApply(document)).toEqual([]);
+  });
+
+  test("an empty document is valid", () => {
+    expect(validateTemplateV1ForApply(documentOf())).toEqual([]);
+  });
+
+  test("references at any depth are checked", () => {
+    // A wrapper can sit anywhere in opaque params, so a check that only looked at the top
+    // level would pass files it cannot apply.
+    const document = wiredDocumentOf(
+      { id: "a" },
+      { id: "b", params: { steps: [{ from: toTemplateRef(createPlRef("later", "reads")) }] } },
+      { id: "later" },
+    );
+
+    expect(validateTemplateV1ForApply(document)).toHaveLength(1);
+  });
+
+  test("an entry referencing itself is told what to do about it", () => {
+    const problems = validateTemplateV1ForApply(
+      wiredDocumentOf({ id: "a", params: { input: createPlRef("a", "reads") } }),
+    );
+
+    expect(problems[0].entryId).toBe("a");
+    expect(problems[0].error).toContain("its own output");
+    expect(problems[0].error).toMatch(/Point it at another entry, or remove the reference/);
+  });
+
+  test("a reference to an entry the file does not define is NOT reported", () => {
+    // The documented cost of an engine that does not parse reference payloads: it can only
+    // ask which of the ids this file defines appear in there, so an id naming no entry is
+    // indistinguishable from any other text. Such a reference surfaces as an applied block
+    // wired to nothing. Pinned as a test so the gap is visible rather than folklore.
+    const problems = validateTemplateV1ForApply(
+      wiredDocumentOf({ id: "a" }, { id: "b", params: { input: createPlRef("typo", "reads") } }),
+    );
+
+    expect(problems).toEqual([]);
+  });
+
+  test("a reference to a later entry says to move it up", () => {
+    // Order is not a formality: blocks are created top to bottom, so the upstream has
+    // to exist before the block that reads it. The fix is a move, and the message says
+    // so rather than only stating the rule.
+    const problems = validateTemplateV1ForApply(
+      wiredDocumentOf({ id: "a", params: { input: createPlRef("b", "reads") } }, { id: "b" }),
+    );
+
+    expect(problems[0].entryId).toBe("a");
+    expect(problems[0].error).toContain("listed after it");
+    expect(problems[0].error).toMatch(/move 'b' above this entry/);
+  });
+
+  test("every problem is reported, grouped by entry in file order", () => {
+    // One pass to fix the file. Grouping by entry keeps the report readable next to the
+    // file itself.
+    const problems = validateTemplateV1ForApply(
+      wiredDocumentOf(
+        { id: "a", params: { self: createPlRef("a", "x"), later: createPlRef("b", "y") } },
+        { id: "b", params: { later: createPlRef("c", "z") } },
+        { id: "c" },
+      ),
+    );
+
+    expect(problems.map((p) => p.entryId)).toEqual(["a", "a", "b"]);
+  });
+});
+
+describe("what the check does not look at", () => {
+  test("a block id outside a wrapper is not the engine's business", () => {
+    // `{ __isRef: true, … }` written straight into params is a reference in a running
+    // project, and applying it would wire the block to nothing. The engine still says
+    // nothing: it exposes the `{ $ref: … }` mechanic and models no other notion of a
+    // reference, so it cannot tell this from data. Pinned so the boundary is deliberate.
+    const problems = validateTemplateV1ForApply(
+      documentOf(entry("a", { input: createPlRef(FOREIGN, "reads") })),
+    );
+
+    expect(problems).toEqual([]);
+  });
+
+  test("an id-looking string is not a reference either", () => {
+    // Params legitimately carry uuids as data — a sample id, a label.
+    const problems = validateTemplateV1ForApply(
+      documentOf(entry("a", { sampleId: FOREIGN, note: `see ${FOREIGN}` })),
+    );
+
+    expect(problems).toEqual([]);
+  });
+
+  test("an entry with no params has nothing to check", () => {
+    expect(validateTemplateV1ForApply(documentOf(entry("a")))).toEqual([]);
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/model/template_validate.ts b/lib/node/pl-middle-layer/src/model/template_validate.ts
new file mode 100644
index 0000000000..5d92c957d2
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/model/template_validate.ts
@@ -0,0 +1,68 @@
+import type { ProjectTemplateV1, TemplateReferenceProblem } from "@milaboratories/pl-model-common";
+import { findProjectTemplateV1ReferenceProblems } from "@milaboratories/pl-model-common";
+import type { TemplateApplyProblem } from "./template_apply";
+
+/**
+ * Everything wrong with a template document that can be known from the document alone.
+ *
+ * The stage between reading the file and touching anything: it needs no registry and no
+ * project, so its failures are statements about the file. That placement is the point —
+ * once a project exists, the same problems would have to be reported against a
+ * half-built project instead.
+ *
+ * One check: **references name an earlier entry.** Detection is shared with export
+ * (`findProjectTemplateV1ReferenceProblems`), the wording is not — export tells a developer
+ * their project cannot be written out, this tells a reader how to fix a file they wrote.
+ *
+ * Nothing here looks inside an entry's params beyond the `{ $ref: … }` wrapper. What a
+ * payload contains, and whether the block that wrote it wrapped the right things, is not
+ * something this layer models: it exposes the wrapper mechanic and nothing else.
+ *
+ * Problems are grouped by entry in file order, so the report reads in the same order as
+ * the file, and every entry's problems appear together. Everything is collected: a file
+ * with three mistakes should take one pass to fix.
+ *
+ * What is deliberately NOT here: whether an entry's kind resolves (that needs a
+ * registry) and whether its params suit the kind (nothing types them at runtime yet).
+ */
+export function validateTemplateV1ForApply(document: ProjectTemplateV1): TemplateApplyProblem[] {
+  const byEntry = new Map<string, TemplateReferenceProblem[]>();
+  for (const problem of findProjectTemplateV1ReferenceProblems(document)) {
+    const existing = byEntry.get(problem.entryId);
+    if (existing === undefined) byEntry.set(problem.entryId, [problem]);
+    else existing.push(problem);
+  }
+
+  const problems: TemplateApplyProblem[] = [];
+
+  for (const entry of document.blocks) {
+    for (const reference of byEntry.get(entry.id) ?? []) {
+      problems.push({ entryId: entry.id, error: describeReferenceProblem(reference) });
+    }
+  }
+
+  return problems;
+}
+
+/**
+ * An import-facing sentence for one bad reference.
+ *
+ * The shared detector's own `message` describes the document; these name the edit. The
+ * `reason` is a discriminant precisely so each direction can word it for its own reader
+ * without re-deriving the finding.
+ */
+function describeReferenceProblem(problem: TemplateReferenceProblem): string {
+  const { referencedId } = problem;
+  switch (problem.reason) {
+    case "self":
+      return (
+        `This entry uses its own output as an input. Point it at another entry, or remove the ` +
+        `reference.`
+      );
+    case "forward":
+      return (
+        `This entry uses entry '${referencedId}', which is listed after it. Blocks are created ` +
+        `in the order they are listed, so move '${referencedId}' above this entry.`
+      );
+  }
+}
diff --git a/lib/node/pl-middle-layer/src/mutator/project-v3.test.ts b/lib/node/pl-middle-layer/src/mutator/project-v3.test.ts
index 4b9277765d..6f2f6c9f77 100644
--- a/lib/node/pl-middle-layer/src/mutator/project-v3.test.ts
+++ b/lib/node/pl-middle-layer/src/mutator/project-v3.test.ts
@@ -14,13 +14,13 @@ import path from "node:path";
 // These blocks use the new unified state format (state instead of args+uiState)
 const BPSpecEnterV3: BlockPackSpec = {
   type: "dev-v2",
-  // Navigate from lib/node/pl-middle-layer/src/mutator to etc/blocks/enter-numbers-v3/block
-  folder: path.resolve(__dirname, "../../../../../etc/blocks/enter-numbers-v3/block"),
+  // Navigate from lib/node/pl-middle-layer/src/mutator to etc/blocks/enter-numbers/block
+  folder: path.resolve(__dirname, "../../../../../etc/blocks/enter-numbers/block"),
 };
 
 const BPSpecSumV3: BlockPackSpec = {
   type: "dev-v2",
-  folder: path.resolve(__dirname, "../../../../../etc/blocks/sum-numbers-v3/block"),
+  folder: path.resolve(__dirname, "../../../../../etc/blocks/sum-numbers/block"),
 };
 
 test("v3 blocks: basic test with unified state", async () => {
@@ -34,7 +34,7 @@ test("v3 blocks: basic test with unified state", async () => {
       return await toGlobalResourceId(prjRef);
     });
 
-    // Add enter-numbers-v3 block with storageMode: 'fromModel'
+    // Add enter-numbers block with storageMode: 'fromModel'
     // Initial storage comes from VM, then we set desired state via setStates
     await pl.withWriteTx("AddEnterNumbersV3Block", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
@@ -68,7 +68,7 @@ test("v3 blocks: basic test with unified state", async () => {
       expect(JSON.parse(stateData).__data).toStrictEqual({ numbers: [1, 2, 3] });
     });
 
-    // Add second enter-numbers-v3 block
+    // Add second enter-numbers block
     await pl.withWriteTx("AddEnterNumbersV3Block2", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
       mut.addBlock(
@@ -93,7 +93,7 @@ test("v3 blocks: basic test with unified state", async () => {
       await tx.commit();
     });
 
-    // Add sum-numbers-v3 block that references both enter blocks
+    // Add sum-numbers block that references both enter blocks
     await pl.withWriteTx("AddSumNumbersV3Block", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
       mut.addBlock(
@@ -126,7 +126,7 @@ test("v3 blocks: basic test with unified state", async () => {
         .get(projectFieldName("enter1", "stagingOutput"))
         .then((r) => r.final());
       const all = await stagingOutput.getAllFinal();
-      // V3 enter-numbers-v3 block has prerun with numbersCount output
+      // V3 enter-numbers block has prerun with numbersCount output
       expect(Object.keys(all)).toContain("numbersCount");
     });
 
@@ -167,7 +167,7 @@ test("v3 blocks: prerunArgs skip test", async () => {
       return await toGlobalResourceId(prjRef);
     });
 
-    // Add enter-numbers-v3 block
+    // Add enter-numbers block
     await pl.withWriteTx("AddEnterNumbersV3Block", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
       mut.addBlock(
@@ -296,7 +296,7 @@ test("v3 blocks: migrateBlockPack preserves state and re-derives args and prerun
       return await toGlobalResourceId(prjRef);
     });
 
-    // Add enter-numbers-v3 block and set data with even numbers
+    // Add enter-numbers block and set data with even numbers
     await pl.withWriteTx("AddBlock", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
       mut.addBlock(
@@ -368,7 +368,7 @@ test("v3 blocks: migrateBlockPack with storage migration re-derives args and pre
       return await toGlobalResourceId(prjRef);
     });
 
-    // Add enter-numbers-v3 block with initial data
+    // Add enter-numbers block with initial data
     await pl.withWriteTx("AddBlock", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
       mut.addBlock(
@@ -559,7 +559,7 @@ test("v3 blocks: migrateBlockPack assigns author marker", async () => {
 // return undefined`) must not crash. Previously applyStorageAndDeriveArgs passed the
 // undefined value straight to createJsonFieldValue -> Buffer.from(undefined) -> ERR_INVALID_ARG_TYPE,
 // aborting the update-block-pack task (reported by AstraZeneca on mixcr-clonotyping 2.14 -> 2.20).
-// The sentinel input [777] makes the enter-numbers-v3 model's args() return undefined without throwing.
+// The sentinel input [777] makes the enter-numbers model's args() return undefined without throwing.
 test("v3 blocks: migrateBlockPack does not crash when args() returns undefined", async () => {
   const quickJs = await getQuickJS();
 
diff --git a/lib/node/pl-middle-layer/src/mutator/project.ts b/lib/node/pl-middle-layer/src/mutator/project.ts
index b66ad352c1..02fce4bbf3 100644
--- a/lib/node/pl-middle-layer/src/mutator/project.ts
+++ b/lib/node/pl-middle-layer/src/mutator/project.ts
@@ -82,7 +82,11 @@ import {
   UiError,
   BLOCK_STORAGE_FACADE_VERSION,
   type BlockConfig,
+  type BlockKindReference,
 } from "@platforma-sdk/model";
+import type { ProjectTemplateExportOutcome } from "../model/template_serializer";
+import { exportProjectAsTemplateV1 } from "../model/template_serializer";
+import type { TemplateParamsResult } from "../model/template_export";
 import { getDebugFlags } from "../debug";
 import type { BlockPackInfo } from "../model/block_pack";
 
@@ -112,6 +116,12 @@ interface BlockInfoState {
   readonly id: string;
   readonly fields: BlockFieldStates;
   blockConfig?: BlockConfig;
+  /**
+   * The block's kind reference, kept separately because `blockConfig` cannot carry
+   * it: `extractConfig` normalizes the render envelope and the kind sits at the
+   * container level, one level above. Undefined for a block that declares no kind.
+   */
+  blockKind?: BlockKindReference;
   blockPack?: BlockPackSpec;
 }
 
@@ -141,6 +151,8 @@ class BlockInfo {
     public readonly fields: BlockFieldStates,
     public readonly config: BlockConfig,
     public readonly source: BlockPackSpec,
+    /** See {@link BlockInfoState.blockKind}. */
+    public readonly kind: BlockKindReference | undefined,
     private readonly logger: MiLogger = new ConsoleLoggerAdapter(),
   ) {}
 
@@ -303,7 +315,25 @@ class BlockInfo {
  */
 /** Specification for creating a new block. Discriminated union based on `storageMode`. */
 export type NewBlockSpec =
-  | { storageMode: "fromModel"; blockPack: BlockPackSpecPrepared }
+  | {
+      storageMode: "fromModel";
+      blockPack: BlockPackSpecPrepared;
+      /**
+       * Storage to start the block with, instead of the model's own default.
+       *
+       * Only for a caller that produced it through the block's own model, which today
+       * means one seeding a block from a template entry's params: the model's
+       * params-to-storage initializer can reject those params, and it has to do so
+       * before anything in the transaction changes. Computing the storage first turns
+       * that rejection into a value the caller can report, and leaves this method with
+       * no failure path it did not already have.
+       *
+       * The result is the same storage the block would have written itself, so args
+       * derivation below is unchanged — which is why this is the `fromModel` mode with
+       * one input filled in rather than a mode of its own.
+       */
+      initialStorage?: string;
+    }
   | { storageMode: "legacy"; blockPack: BlockPackSpecPrepared; legacyState: string };
 
 const NoNewBlocks = (blockId: string) => {
@@ -516,6 +546,48 @@ export class ProjectMutator {
       };
   }
 
+  //
+  // Template export
+  //
+
+  /**
+   * Render this project as a `template-v1` YAML document, or report every reason it
+   * cannot be.
+   *
+   * Read-only: it derives params in the VM and touches no field, so a `withProject`
+   * wrapper sees `wasModified === false` and skips the commit.
+   *
+   * This is where the three providers the serializer needs come from, and all are
+   * only reachable here. A block's storage lives behind `BlockInfo`, which is
+   * populated by the loader's batched round-trips, and both its kind reference and
+   * its origin spec are read off the block-pack container during that same load —
+   * `config` cannot carry the kind, since `extractConfig` normalizes the render
+   * envelope one level below it, and the spec is not part of the config at all.
+   */
+  public exportAsTemplateV1(): ProjectTemplateExportOutcome {
+    return exportProjectAsTemplateV1(
+      this.struct,
+      (blockId) => this.deriveTemplateParams(blockId),
+      (blockId) => this.blockInfos.get(blockId)?.kind,
+      (blockId) => this.blockInfos.get(blockId)?.source,
+    );
+  }
+
+  private deriveTemplateParams(blockId: string): TemplateParamsResult | undefined {
+    const info = this.blockInfos.get(blockId);
+    // A block in the structure with no loaded info, or with no storage yet, has no
+    // state to project into params. Returning undefined makes the walk report it
+    // rather than quietly leaving the block out of the template.
+    if (info === undefined) return undefined;
+
+    const storageJson = info.blockStorageJson;
+    if (storageJson === undefined) return undefined;
+
+    const derived = this.projectHelper.deriveTemplateParamsFromStorage(info.config, storageJson);
+    if (derived.error !== undefined) return { error: derived.error.message };
+    return { value: derived.value };
+  }
+
   private getPendingProductionGraph(): BlockGraph {
     if (this.pendingProductionGraph === undefined)
       this.pendingProductionGraph = productionGraph(this.struct, (blockId) =>
@@ -1142,6 +1214,7 @@ export class ProjectMutator {
       {},
       extractConfig(spec.blockPack.config),
       spec.blockPack.source,
+      spec.blockPack.config.kind,
       this.projectHelper.logger,
     );
     this.blockInfos.set(blockId, info);
@@ -1164,8 +1237,11 @@ export class ProjectMutator {
     let storageToWrite: string;
 
     if (spec.storageMode === "fromModel") {
-      // Model API v2+: get initial storage and derive args from it
-      storageToWrite = this.projectHelper.getInitialStorageInVM(blockConfig);
+      // Model API v2+: get initial storage and derive args from it. A caller that
+      // already produced the storage — a template seeding a block from its params —
+      // passes it in, precisely so the VM call that could reject those params happens
+      // before the transaction is touched; see `initialStorage`.
+      storageToWrite = spec.initialStorage ?? this.projectHelper.getInitialStorageInVM(blockConfig);
 
       // Derive prerunArgs first — always derived independently of args validation
       prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(blockConfig, storageToWrite);
@@ -1251,6 +1327,7 @@ export class ProjectMutator {
       {},
       originalBlockInfo.config,
       originalBlockInfo.source,
+      originalBlockInfo.kind,
       this.projectHelper.logger,
     );
 
@@ -1895,6 +1972,9 @@ export class ProjectMutator {
       const result = await response;
       const bpInfo = cachedDeserialize<BlockPackInfo>(notEmpty(result.data));
       info.blockConfig = extractConfig(bpInfo.config);
+      // Read off the container before `extractConfig`'s result replaces it as the
+      // only thing we keep. Costs no round-trip — `bpInfo` is already in hand.
+      info.blockKind = bpInfo.config.kind;
       info.blockPack = bpInfo.source;
     }
 
@@ -1926,10 +2006,17 @@ export class ProjectMutator {
     const blocksInLimboSet = new Set(blocksInLimbo);
 
     const blockInfos = new Map<string, BlockInfo>();
-    blockInfoStates.forEach(({ id, fields, blockConfig, blockPack }) =>
+    blockInfoStates.forEach(({ id, fields, blockConfig, blockKind, blockPack }) =>
       blockInfos.set(
         id,
-        new BlockInfo(id, fields, notEmpty(blockConfig), notEmpty(blockPack), projectHelper.logger),
+        new BlockInfo(
+          id,
+          fields,
+          notEmpty(blockConfig),
+          notEmpty(blockPack),
+          blockKind,
+          projectHelper.logger,
+        ),
       ),
     );
 
diff --git a/lib/node/pl-middle-layer/src/mutator/template_construct.test.ts b/lib/node/pl-middle-layer/src/mutator/template_construct.test.ts
new file mode 100644
index 0000000000..67acc31afd
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/mutator/template_construct.test.ts
@@ -0,0 +1,418 @@
+import { beforeAll, describe, expect, test } from "vitest";
+import { getQuickJS, type QuickJSWASMModule } from "quickjs-emscripten";
+import { BlockStorageFacadeCallbacks } from "@platforma-sdk/model";
+import type {
+  BlockKindSelectorReference,
+  ProjectTemplateV1,
+  ProjectTemplateV1Entry,
+} from "@milaboratories/pl-model-common";
+import {
+  PROJECT_TEMPLATE_SCHEMA_V1,
+  createPlRef,
+  toTemplateRef,
+} from "@milaboratories/pl-model-common";
+import { ProjectHelper } from "../model/project_helper";
+import type { BlockPackSpecPrepared } from "../model";
+import type { Block } from "../model/project_model";
+import type { NewBlockSpec } from "./project";
+import type { PreparedTemplateEntry } from "./template_construct";
+import { TemplateEntryRejected } from "../model/template_apply";
+import { applyTemplateEntries } from "./template_construct";
+
+/**
+ * Applying a document against a recording placer.
+ *
+ * A real mutator would need a backend; the one method construction uses does not, so the
+ * placer is faked and everything else here is real — a real `ProjectHelper`, a real model VM,
+ * real block code. What is being checked is the seam between an entry and a block: which id
+ * it got, which storage its params produced, what a rejection does, and how far an apply gets
+ * before it stops.
+ */
+
+const HANDLE = BlockStorageFacadeCallbacks.StorageInitialFromParams;
+
+/** A v4 block whose params-to-storage callback body is `body`. */
+function preparedBlock(
+  body: string,
+  options: { declareCallback?: boolean } = {},
+): BlockPackSpecPrepared {
+  const { declareCallback = true } = options;
+  return {
+    type: "prepared",
+    config: {
+      code: {
+        type: "plain",
+        content: `globalThis.cfgRenderCtx.callbackRegistry[${JSON.stringify(HANDLE)}] = ${body};`,
+      },
+      v4: {
+        sdkVersion: "1.0.0",
+        renderingMode: "Heavy",
+        outputs: {},
+        sections: [],
+        // A block that predates the params callback still declares the older ones, and
+        // it has to: `extractConfig` fills every handle in for a v4 block whose set is
+        // empty, which would hide this case entirely.
+        blockLifecycleCallbacks: {
+          [BlockStorageFacadeCallbacks.StorageInitial]: {
+            handle: BlockStorageFacadeCallbacks.StorageInitial,
+          },
+          ...(declareCallback ? { [HANDLE]: { handle: HANDLE } } : {}),
+        },
+      },
+    },
+  } as unknown as BlockPackSpecPrepared;
+}
+
+/** A block on the previous model API, which cannot be initialized from params at all. */
+function legacyPreparedBlock(): BlockPackSpecPrepared {
+  return {
+    type: "prepared",
+    config: {
+      code: { type: "plain", content: "" },
+      v3: {
+        sdkVersion: "1.0.0",
+        renderingMode: "Heavy",
+        outputs: {},
+        sections: [],
+        initialArgs: {},
+        inputsValid: "inputsValid",
+      },
+    },
+  } as unknown as BlockPackSpecPrepared;
+}
+
+/** Echoes its params back as the block's storage. */
+const echoModel = "(paramsJson) => ({ storageJson: paramsJson })";
+
+type Placement = { block: Block; spec: NewBlockSpec };
+
+/**
+ * @param throwOn Block label to refuse to place, as an exception — the mutator's way of
+ *   failing
+ */
+function recordingPlacer(throwOn?: string) {
+  const placements: Placement[] = [];
+  return {
+    placements,
+    placer: {
+      addBlock: (block: Block, spec: NewBlockSpec) => {
+        if (block.label === throwOn) throw new Error("structure is broken");
+        placements.push({ block, spec });
+      },
+    },
+  };
+}
+
+function entryMap(
+  entries: Record<string, BlockPackSpecPrepared>,
+): Map<string, PreparedTemplateEntry> {
+  return new Map(
+    Object.entries(entries).map(([id, blockPack]) => [id, { blockPack, label: `Block ${id}` }]),
+  );
+}
+
+/** The storage a placement carries, parsed. */
+function storageOf(placement: Placement): unknown {
+  if (placement.spec.storageMode !== "fromModel") throw new Error("expected fromModel");
+  const { initialStorage } = placement.spec;
+  if (initialStorage === undefined) throw new Error("expected seeded storage");
+  return JSON.parse(initialStorage);
+}
+
+let quickJs: QuickJSWASMModule;
+
+beforeAll(async () => {
+  quickJs = await getQuickJS();
+});
+
+const KIND = "@platforma-open/milaboratories.demo.kind@^1.0.0" as BlockKindSelectorReference;
+
+/** An entry as the parser hands it over: `params` settled, absent read as `{}`. */
+const entry = (id: string, params: Record<string, unknown> = {}): ProjectTemplateV1Entry => ({
+  id,
+  kind: KIND,
+  params,
+});
+
+const documentOf = (...blocks: ProjectTemplateV1Entry[]): ProjectTemplateV1 => ({
+  schema: PROJECT_TEMPLATE_SCHEMA_V1,
+  blocks,
+});
+
+/** One apply, with ids named as a counter so the assertions can spell them out. */
+function applyOver(
+  entries: Map<string, PreparedTemplateEntry>,
+  placer: { addBlock: (block: Block, spec: NewBlockSpec) => void },
+  document: ProjectTemplateV1,
+) {
+  let n = 0;
+  return applyTemplateEntries({
+    document,
+    placer,
+    projectHelper: new ProjectHelper(quickJs),
+    entries,
+    newBlockId: () => `block-${++n}`,
+  });
+}
+
+/**
+ * The rejection an apply throws, for tests that assert which entry stopped it.
+ *
+ * Note what these tests cannot show: that the placements made before the rejection are
+ * discarded. That is the transaction's doing, and the placer here is a recording fake with no
+ * transaction — so it keeps what it was told, while the real apply keeps nothing.
+ */
+function rejectionFrom(run: () => unknown): TemplateEntryRejected {
+  try {
+    run();
+  } catch (e: unknown) {
+    if (e instanceof TemplateEntryRejected) return e;
+    throw e;
+  }
+  throw new Error("expected the apply to reject an entry, but it succeeded");
+}
+
+describe("applyTemplateEntries", () => {
+  test("an entry's params become the storage its block starts with", () => {
+    // The whole reason a template can describe a configured block: the params go
+    // through the block's own model, so what lands is what that block considers a
+    // correctly initialized state.
+    const { placer, placements } = recordingPlacer();
+
+    const added = applyOver(
+      entryMap({ a: preparedBlock(echoModel) }),
+      placer,
+      documentOf(entry("a", { numbers: [3, 1, 2] })),
+    );
+
+    expect(added).toEqual([{ templateLocalId: "a", blockId: "block-1" }]);
+    expect(storageOf(placements[0])).toEqual({ numbers: [3, 1, 2] });
+  });
+
+  test("an entry with no params goes through the params path as `{}`", () => {
+    // Not routed around it. The two produce the same block anyway — both reach the same
+    // init factory — but only this way is the entry checked against its kind, so an
+    // omitted key cannot be a way to apply params the contract would have rejected.
+    const { placer, placements } = recordingPlacer();
+
+    applyOver(entryMap({ a: preparedBlock(echoModel) }), placer, documentOf(entry("a")));
+
+    expect(placements[0].spec).toEqual({
+      storageMode: "fromModel",
+      blockPack: expect.anything(),
+      initialStorage: expect.anything(),
+    });
+    expect(storageOf(placements[0])).toEqual({});
+  });
+
+  test("references are redirected to the blocks already placed", () => {
+    // The payoff of the whole import path: the second entry's params name a
+    // template-local id in the file and reach the block as a reference to the id the
+    // first block actually got.
+    const { placer, placements } = recordingPlacer();
+    const params = { input: toTemplateRef(createPlRef("samples", "reads")) };
+
+    applyOver(
+      entryMap({ samples: preparedBlock(echoModel), align: preparedBlock(echoModel) }),
+      placer,
+      documentOf(entry("samples"), entry("align", params)),
+    );
+
+    expect(placements[0].block.id).toBe("block-1");
+    expect(storageOf(placements[1])).toEqual({ input: createPlRef("block-1", "reads") });
+  });
+
+  test("entries are created in file order, and each pairs with the id it got", () => {
+    // File order is instantiation order, which is what makes one forward pass enough.
+    const { placer, placements } = recordingPlacer();
+
+    const added = applyOver(
+      entryMap({
+        a: preparedBlock(echoModel),
+        b: preparedBlock(echoModel),
+        c: preparedBlock(echoModel),
+      }),
+      placer,
+      documentOf(entry("a"), entry("b"), entry("c")),
+    );
+
+    expect(placements.map((p) => p.block.id)).toEqual(["block-1", "block-2", "block-3"]);
+    expect(added).toEqual([
+      { templateLocalId: "a", blockId: "block-1" },
+      { templateLocalId: "b", blockId: "block-2" },
+      { templateLocalId: "c", blockId: "block-3" },
+    ]);
+  });
+
+  test("an empty document is a successful apply that creates nothing", () => {
+    // An exported empty project round-trips to an empty project, not to a failure.
+    const { placer, placements } = recordingPlacer();
+
+    expect(applyOver(entryMap({}), placer, documentOf())).toEqual([]);
+    expect(placements).toHaveLength(0);
+  });
+
+  test("the block is placed under the caller's label, in the block's rendering mode", () => {
+    const { placer, placements } = recordingPlacer();
+
+    applyOver(entryMap({ a: preparedBlock(echoModel) }), placer, documentOf(entry("a")));
+
+    expect(placements[0].block).toEqual({
+      id: "block-1",
+      label: "Block a",
+      renderingMode: "Heavy",
+    });
+  });
+
+  test("params the block declines are reported, and nothing is placed", () => {
+    // The expected failure for a hand-written file. The message is the block's own.
+    const { placer, placements } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(
+        entryMap({ a: preparedBlock('() => ({ error: "numbers must not be empty" })') }),
+        placer,
+        documentOf(entry("a", { numbers: [] })),
+      ),
+    );
+
+    expect(rejection.entryId).toBe("a");
+    expect(rejection.message).toBe("numbers must not be empty");
+    expect(placements).toHaveLength(0);
+  });
+
+  test("it stops at the first entry it cannot create, and names it", () => {
+    // Nothing after the failure is attempted: those entries may reference the one that
+    // failed, and the whole apply is discarded anyway.
+    const { placer, placements } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(
+        entryMap({
+          a: preparedBlock(echoModel),
+          b: preparedBlock('() => ({ error: "params rejected" })'),
+          c: preparedBlock(echoModel),
+        }),
+        placer,
+        documentOf(entry("a"), entry("b"), entry("c")),
+      ),
+    );
+
+    expect(rejection.entryId).toBe("b");
+    expect(placements.map((p) => p.block.id)).toEqual(["block-1"]);
+  });
+
+  test("a reference to an entry with no block travels as written, and the block is placed", () => {
+    // The engine cannot see that `b` names nothing yet, so the reference travels as written
+    // and the block is created wired to it. Validation is what rejects such a document.
+    const { placer, placements } = recordingPlacer();
+    const params = { input: toTemplateRef(createPlRef("b", "out")) };
+
+    applyOver(entryMap({ a: preparedBlock(echoModel) }), placer, documentOf(entry("a", params)));
+
+    expect(placements).toHaveLength(1);
+    expect(storageOf(placements[0])).toEqual({ input: createPlRef("b", "out") });
+  });
+
+  test("a block too old to be initialized from params is refused", () => {
+    // It could be added — that is the danger. Creating it would ignore everything the
+    // template said about it and still look like a successful apply.
+    const { placer, placements } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(
+        entryMap({ a: legacyPreparedBlock() }),
+        placer,
+        documentOf(entry("a", { numbers: [1] })),
+      ),
+    );
+
+    expect(rejection.entryId).toBe("a");
+    expect(rejection.message).toBe(
+      "This version of the block is too old to be created from a template. Use a newer " +
+        "version of the block, or remove the pinned block version from this entry so a " +
+        "supported one is chosen automatically.",
+    );
+    expect(placements).toHaveLength(0);
+  });
+
+  test("a block too old for kinds is refused even with no params of its own", () => {
+    // Nothing to ignore here, and it would be created correctly — but every entry names
+    // a kind, and a block predating the facade implements none, so it is not the block
+    // the entry asked for.
+    const { placer } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(entryMap({ a: legacyPreparedBlock() }), placer, documentOf(entry("a"))),
+    );
+
+    expect(rejection.entryId).toBe("a");
+  });
+
+  test("a current block whose model predates the callback reports the model's way out", () => {
+    // A different failure from the one above: the block is on the current facade, its
+    // model just has no params initializer. The message comes from the helper and must
+    // reach the caller as-is.
+    const { placer } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(
+        entryMap({ a: preparedBlock(echoModel, { declareCallback: false }) }),
+        placer,
+        documentOf(entry("a", { numbers: [1] })),
+      ),
+    );
+
+    expect(rejection.message).toBe(
+      "This version of the block cannot be created from a template. Use a newer version " +
+        "of the block, or remove the pinned block version from the template entry so a " +
+        "supported one is chosen automatically.",
+    );
+  });
+
+  test("an entry nothing was prepared for is reported", () => {
+    // Resolution covers every entry or the apply never starts, so this is a caller error —
+    // reported rather than thrown, so it reads like any other bad entry.
+    const { placer } = recordingPlacer();
+
+    const rejection = rejectionFrom(() =>
+      applyOver(entryMap({ a: preparedBlock(echoModel) }), placer, documentOf(entry("ghost"))),
+    );
+
+    expect(rejection.entryId).toBe("ghost");
+    expect(rejection.message).toBe("No block was prepared for entry 'ghost'.");
+  });
+
+  test("a failure to place a block is not swallowed", () => {
+    // Deliberately unlike the failures above. By this point the mutator holds half a
+    // change, so the only safe outcome is to lose the transaction — reporting it would
+    // commit something no one wrote.
+    const { placer } = recordingPlacer("Block a");
+
+    expect(() =>
+      applyOver(entryMap({ a: preparedBlock(echoModel) }), placer, documentOf(entry("a"))),
+    ).toThrow("structure is broken");
+  });
+
+  test("an entry that references a rejected one is never reached", () => {
+    // Why the id map can record an entry before its block is placed: a rejection ends the
+    // apply, so there is no surviving project in which a later entry points at a block that
+    // was never created.
+    const { placer, placements } = recordingPlacer();
+    const params = { input: toTemplateRef(createPlRef("a", "out")) };
+
+    const rejection = rejectionFrom(() =>
+      applyOver(
+        entryMap({
+          a: preparedBlock('() => ({ error: "no" })'),
+          b: preparedBlock(echoModel),
+        }),
+        placer,
+        documentOf(entry("a", {}), entry("b", params)),
+      ),
+    );
+
+    expect(rejection.entryId).toBe("a");
+    expect(placements).toHaveLength(0);
+  });
+});
diff --git a/lib/node/pl-middle-layer/src/mutator/template_construct.ts b/lib/node/pl-middle-layer/src/mutator/template_construct.ts
new file mode 100644
index 0000000000..98d089235a
--- /dev/null
+++ b/lib/node/pl-middle-layer/src/mutator/template_construct.ts
@@ -0,0 +1,141 @@
+import { BLOCK_STORAGE_FACADE_VERSION, extractConfig } from "@platforma-sdk/model";
+import { resolveTemplateRefs, type ProjectTemplateV1 } from "@milaboratories/pl-model-common";
+import type { BlockPackSpecPrepared } from "../model";
+import type { ProjectHelper } from "../model/project_helper";
+import type { AppliedEntry } from "../model/template_apply";
+import { TemplateEntryRejected } from "../model/template_apply";
+import { randomUUID } from "node:crypto";
+import type { Block } from "../model/project_model";
+import type { NewBlockSpec } from "./project";
+
+/** What construction needs to know about one entry, once its block has been located. */
+export type PreparedTemplateEntry = {
+  /** The block pack, already prepared and template-cached. */
+  readonly blockPack: BlockPackSpecPrepared;
+  /**
+   * The label to place the block under: the block package's published title.
+   *
+   * A template names no block instances, so this cannot come from the file — and must
+   * not be derived from it, since an exported template names its entries by the source
+   * project's block ids. It reaches here from resolution, the only stage that talks to
+   * a registry.
+   *
+   * A block whose model derives a title shows that instead (`project_overview.ts`
+   * prefers the derived one), so for most blocks this is invisible. For the ones that
+   * derive none it is the name the user reads.
+   */
+  readonly label: string;
+};
+
+/** The one method construction needs from a project mutator. */
+export type BlockPlacer = {
+  addBlock: (block: Block, spec: NewBlockSpec, before?: string) => void;
+};
+
+/**
+ * Apply a `template-v1` document: create each entry's block, in file order.
+ *
+ * Everything slow is already done by the time this runs: kinds resolved, block packs
+ * prepared and template-cached, the project created and a mutator open. What is left per
+ * entry is in-memory work — assign an id, redirect the entry's references against the ids
+ * already handed out, ask the block's own model for the storage those params imply, and
+ * place the block. All of it inside the caller's single transaction.
+ *
+ * File order is instantiation order, and a reference to a later entry is rejected before
+ * this point, so one forward pass is enough: by the time an entry is created, every entry it
+ * references already exists and already has an id. Blocks are appended in the order they are
+ * added, so nothing here passes a `before`.
+ *
+ * **All or nothing.** An entry this project cannot honour throws
+ * {@link TemplateEntryRejected}, which leaves the caller's transaction uncommitted, so the
+ * project keeps none of the blocks this call placed. A half-applied project is not a useful
+ * result: its tail is missing, so whatever the missing entries were supposed to feed is wired
+ * to nothing, and the user cannot tell which of the blocks present were configured by the
+ * file and which they would have to fix. Failing whole also means the reader gets one
+ * statement about their file rather than a project to reconcile.
+ *
+ * @param entries Prepared entries by template-local id. Resolution covers every entry
+ *   or the apply does not start, so a missing one is a caller error rather than a
+ *   property of the file
+ * @param newBlockId Source of project-local block ids. Defaults to random UUIDs, the same
+ *   ids `Project.addBlock` would have generated on its own; injectable so a test can name
+ *   the ids it expects
+ * @throws {TemplateEntryRejected} for the first entry the file describes unusably
+ */
+export function applyTemplateEntries(deps: {
+  readonly document: ProjectTemplateV1;
+  readonly placer: BlockPlacer;
+  readonly projectHelper: ProjectHelper;
+  readonly entries: ReadonlyMap<string, PreparedTemplateEntry>;
+  readonly newBlockId?: () => string;
+}): AppliedEntry[] {
+  const { document, placer, projectHelper, entries } = deps;
+  const newBlockId = deps.newBlockId ?? randomUUID;
+  const added: AppliedEntry[] = [];
+
+  /**
+   * Template-local entry id → the block id it was given.
+   *
+   * An entry lands in here the moment it is given an id, before its block is placed. That is
+   * safe precisely because the apply is all-or-nothing: there is no surviving project in
+   * which a later entry could point at a block that never got created. It does mean an entry
+   * whose params reference itself is wired to itself rather than left dangling — a document
+   * the reference check rejects before an apply begins.
+   */
+  const blockIds = new Map<string, string>();
+
+  for (const entry of document.blocks) {
+    const prepared = entries.get(entry.id);
+    if (prepared === undefined) {
+      throw new TemplateEntryRejected(entry.id, `No block was prepared for entry '${entry.id}'.`);
+    }
+
+    const blockConfig = extractConfig(prepared.blockPack.config);
+
+    // Only a block on the current storage facade can be told what to initialize itself
+    // with, and it is refused rather than created with its own defaults even when the
+    // entry carries no params: every entry names a kind, and a block predating the
+    // facade implements none, so creating one would honour the entry's pinned version
+    // while contradicting the kind it claims to be. With params it is worse still — a
+    // block that looks applied but ignored everything the template said about it.
+    //
+    // Kind resolution never picks such a block, since declaring a kind requires a
+    // recent SDK. An entry pinning an exact version can name anything ever published,
+    // which is the way this is reached.
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      throw new TemplateEntryRejected(
+        entry.id,
+        "This version of the block is too old to be created from a template. Use a " +
+          "newer version of the block, or remove the pinned block version from this " +
+          "entry so a supported one is chosen automatically.",
+      );
+    }
+
+    const blockId = newBlockId();
+    blockIds.set(entry.id, blockId);
+
+    // Params are a mapping by the time a document exists — the parser reads an omitted key
+    // as `{}` — so every entry goes through the params path and is checked against its kind.
+    const live = resolveTemplateRefs(entry.params, blockIds);
+
+    // The block's own model decides what params mean. Run before anything is
+    // placed, so params it declines cost nothing but the report.
+    const storage = projectHelper.getInitialStorageFromParamsInVM(blockConfig, live);
+    if (storage.error !== undefined) {
+      throw new TemplateEntryRejected(entry.id, storage.error.message);
+    }
+
+    placer.addBlock(
+      { id: blockId, label: prepared.label, renderingMode: blockConfig.renderingMode },
+      {
+        storageMode: "fromModel",
+        blockPack: prepared.blockPack,
+        initialStorage: storage.value,
+      },
+    );
+
+    added.push({ templateLocalId: entry.id, blockId });
+  }
+
+  return added;
+}
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/empty-project.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/empty-project.yaml
new file mode 100644
index 0000000000..b104938267
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/empty-project.yaml
@@ -0,0 +1,2 @@
+schema: template-v1
+blocks: []
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/linear-chain.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/linear-chain.yaml
new file mode 100644
index 0000000000..249e86f5fa
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/linear-chain.yaml
@@ -0,0 +1,23 @@
+schema: template-v1
+blocks:
+  - id: aaaaaaaa-0000-4000-8000-000000000001
+    kind: "@platforma-open/milaboratories.import-fastq.kind@2.1.0"
+    params:
+      dataset: bulk-rna
+  - id: bbbbbbbb-0000-4000-8000-000000000002
+    kind: "@platforma-open/milaboratories.mixcr-clonotyping.kind@3.0.4"
+    params:
+      input:
+        $ref:
+          __isRef: true
+          blockId: aaaaaaaa-0000-4000-8000-000000000001
+          name: reads
+      species: hsa
+  - id: cccccccc-0000-4000-8000-000000000003
+    kind: "@platforma-open/milaboratories.clonotype-browser.kind@1.2.10"
+    params:
+      clonotypes:
+        $ref:
+          __isRef: true
+          blockId: bbbbbbbb-0000-4000-8000-000000000002
+          name: clonotypes
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/minimal.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/minimal.yaml
new file mode 100644
index 0000000000..0eb5c200d5
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/minimal.yaml
@@ -0,0 +1,5 @@
+schema: template-v1
+blocks:
+  - id: 11111111-1111-4111-8111-111111111111
+    kind: "@platforma-open/milaboratories.pool-explorer.kind@1.0.0"
+    params: {}
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/nested-params.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/nested-params.yaml
new file mode 100644
index 0000000000..04dfed9b12
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/nested-params.yaml
@@ -0,0 +1,30 @@
+schema: template-v1
+blocks:
+  - id: dddddddd-0000-4000-8000-000000000004
+    kind: "@platforma-open/milaboratories.import-fastq.kind@2.1.0"
+    params: {}
+  - id: ffffffff-0000-4000-8000-000000000006
+    kind: "@platforma-open/milaboratories.clonotype-clustering.kind@0.4.1"
+    params:
+      thresholds:
+        min: 0.01
+        max: 1
+        exact: 0.5
+      steps:
+        - name: filter
+          enabled: true
+        - name: cluster
+          enabled: false
+          seed: 42
+      inputs:
+        - $ref:
+            __isRef: true
+            blockId: dddddddd-0000-4000-8000-000000000004
+            name: a
+        - $ref:
+            __isRef: true
+            blockId: dddddddd-0000-4000-8000-000000000004
+            name: b
+      advanced: {}
+      tags: []
+      note: null
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/scalar-quoting.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/scalar-quoting.yaml
new file mode 100644
index 0000000000..3432fc81e9
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/scalar-quoting.yaml
@@ -0,0 +1,28 @@
+schema: template-v1
+blocks:
+  - id: eeeeeeee-0000-4000-8000-000000000005
+    kind: "@platforma-open/milaboratories.enter-numbers.kind@1.0.0"
+    params:
+      looksBoolean: "yes"
+      looksBooleanNo: "no"
+      looksBooleanOn: "on"
+      looksBooleanOff: "off"
+      looksBooleanY: "y"
+      looksBooleanN: "n"
+      looksSexagesimal: "1:30"
+      looksBooleanToo: "true"
+      looksNumeric: "1.0"
+      looksOctal: "0755"
+      looksNull: "null"
+      looksEmpty: ""
+      hasColon: "label: value"
+      startsWithAsterisk: "*anchor"
+      startsWithHash: "#not-a-comment"
+      startsWithDash: -dash
+      multiline: |-
+        first
+        second
+      unicode: 受容体 — αβ
+      long: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
+      actuallyBoolean: true
+      actuallyNumeric: 1
diff --git a/lib/node/pl-middle-layer/test_fixtures/template-v1/wrapped-refs.yaml b/lib/node/pl-middle-layer/test_fixtures/template-v1/wrapped-refs.yaml
new file mode 100644
index 0000000000..571e5c5e46
--- /dev/null
+++ b/lib/node/pl-middle-layer/test_fixtures/template-v1/wrapped-refs.yaml
@@ -0,0 +1,15 @@
+schema: template-v1
+blocks:
+  - id: aaaaaaaa-0000-4000-8000-000000000001
+    kind: "@platforma-open/milaboratories.import-fastq.kind@2.1.0"
+    params: {}
+  - id: bbbbbbbb-0000-4000-8000-000000000002
+    kind: "@platforma-open/milaboratories.clonotype-browser.kind@1.2.10"
+    params:
+      anchor:
+        $ref: '{"__isFiltered":true,"axisFilters":[[0,"IGH"]],"source":"{\"__isRef\":true,\"blockId\":\"aaaaaaaa-0000-4000-8000-000000000001\",\"name\":\"clonotypes\"}"}'
+      upstream:
+        $ref:
+          __isRef: true
+          blockId: aaaaaaaa-0000-4000-8000-000000000001
+          name: clonotypes
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index dea1ee2a51..181472aa7d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -375,6 +375,9 @@ importers:
 
   etc/blocks/blob-url-custom-protocol/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-blob-url-custom-protocol.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-blob-url-custom-protocol.model':
         specifier: workspace:*
         version: link:../model
@@ -403,8 +406,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/blob-url-custom-protocol/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/blob-url-custom-protocol/model:
     dependencies:
+      '@milaboratories/milaboratories.test-blob-url-custom-protocol.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -495,6 +526,9 @@ importers:
 
   etc/blocks/download-file/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-download-file.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-download-file.model':
         specifier: workspace:*
         version: link:../model
@@ -523,8 +557,39 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/download-file/kind:
+    dependencies:
+      '@milaboratories/pl-model-common':
+        specifier: workspace:*
+        version: link:../../../../lib/model/common
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/download-file/model:
     dependencies:
+      '@milaboratories/milaboratories.test-download-file.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -616,15 +681,18 @@ importers:
         specifier: 'catalog:'
         version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
 
-  etc/blocks/enter-numbers-v3/block:
+  etc/blocks/enter-numbers/block:
     devDependencies:
-      '@milaboratories/milaboratories.test-enter-numbers-v3.model':
+      '@milaboratories/milaboratories.test-enter-numbers.kind':
+        specifier: workspace:*
+        version: link:../kind
+      '@milaboratories/milaboratories.test-enter-numbers.model':
         specifier: workspace:*
         version: link:../model
-      '@milaboratories/milaboratories.test-enter-numbers-v3.ui':
+      '@milaboratories/milaboratories.test-enter-numbers.ui':
         specifier: workspace:*
         version: link:../ui
-      '@milaboratories/milaboratories.test-enter-numbers-v3.workflow':
+      '@milaboratories/milaboratories.test-enter-numbers.workflow':
         specifier: workspace:*
         version: link:../workflow
       '@milaboratories/ts-builder':
@@ -646,11 +714,11 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
-  etc/blocks/enter-numbers-v3/model:
+  etc/blocks/enter-numbers/kind:
     dependencies:
-      '@platforma-sdk/model':
+      '@platforma-sdk/block-kind':
         specifier: workspace:*
-        version: link:../../../../sdk/model
+        version: link:../../../../sdk/block-kind
       '@types/node':
         specifier: '*'
         version: 24.5.2
@@ -661,89 +729,6 @@ importers:
         specifier: 'catalog:'
         version: 3.25.76
     devDependencies:
-      '@milaboratories/build-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/build-configs
-      '@milaboratories/ts-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-builder
-      '@milaboratories/ts-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-configs
-      '@platforma-sdk/block-tools':
-        specifier: workspace:*
-        version: link:../../../../tools/block-tools
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
-
-  etc/blocks/enter-numbers-v3/ui:
-    dependencies:
-      '@milaboratories/milaboratories.test-enter-numbers-v3.model':
-        specifier: workspace:*
-        version: link:../model
-      '@platforma-sdk/ui-vue':
-        specifier: workspace:*
-        version: link:../../../../sdk/ui-vue
-      '@types/node':
-        specifier: '*'
-        version: 24.5.2
-      typescript:
-        specifier: '*'
-        version: 5.9.3
-      vue:
-        specifier: 'catalog:'
-        version: 3.5.24(typescript@5.9.3)
-    devDependencies:
-      '@faker-js/faker':
-        specifier: 'catalog:'
-        version: 9.2.0
-      '@milaboratories/helpers':
-        specifier: workspace:*
-        version: link:../../../../lib/util/helpers
-      '@milaboratories/ts-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-builder
-      '@milaboratories/ts-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-configs
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
-      zod:
-        specifier: 'catalog:'
-        version: 3.25.76
-
-  etc/blocks/enter-numbers-v3/workflow:
-    dependencies:
-      '@platforma-sdk/workflow-tengo':
-        specifier: workspace:*
-        version: link:../../../../sdk/workflow-tengo
-    devDependencies:
-      '@platforma-sdk/tengo-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/tengo-builder
-      '@platforma-sdk/test':
-        specifier: workspace:*
-        version: link:../../../../sdk/test
-      shx:
-        specifier: 'catalog:'
-        version: 0.4.0
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
-
-  etc/blocks/enter-numbers/block:
-    devDependencies:
-      '@milaboratories/milaboratories.test-enter-numbers.model':
-        specifier: workspace:*
-        version: link:../model
-      '@milaboratories/milaboratories.test-enter-numbers.ui':
-        specifier: workspace:*
-        version: link:../ui
-      '@milaboratories/milaboratories.test-enter-numbers.workflow':
-        specifier: workspace:*
-        version: link:../workflow
       '@milaboratories/ts-builder':
         specifier: workspace:*
         version: link:../../../../tools/ts-builder
@@ -753,18 +738,12 @@ importers:
       '@platforma-sdk/block-tools':
         specifier: workspace:*
         version: link:../../../../tools/block-tools
-      '@platforma-sdk/model':
-        specifier: workspace:*
-        version: link:../../../../sdk/model
-      shx:
-        specifier: 'catalog:'
-        version: 0.4.0
-      typescript:
-        specifier: 'catalog:'
-        version: 5.9.3
 
   etc/blocks/enter-numbers/model:
     dependencies:
+      '@milaboratories/milaboratories.test-enter-numbers.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -852,6 +831,9 @@ importers:
 
   etc/blocks/filter-column-test/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-filter-column.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-filter-column.model':
         specifier: workspace:*
         version: link:../model
@@ -880,8 +862,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/filter-column-test/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/filter-column-test/model:
     dependencies:
+      '@milaboratories/milaboratories.test-filter-column.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -913,12 +923,12 @@ importers:
       '@milaboratories/milaboratories.test-block-table':
         specifier: workspace:*
         version: link:../../table-test/block
-      '@milaboratories/milaboratories.test-enter-numbers-v3':
+      '@milaboratories/milaboratories.test-enter-numbers':
         specifier: workspace:*
-        version: link:../../enter-numbers-v3/block
-      '@milaboratories/milaboratories.test-enter-numbers-v3.model':
+        version: link:../../enter-numbers/block
+      '@milaboratories/milaboratories.test-enter-numbers.model':
         specifier: workspace:*
-        version: link:../../enter-numbers-v3/model
+        version: link:../../enter-numbers/model
       '@milaboratories/milaboratories.test-filter-column.model':
         specifier: workspace:*
         version: link:../model
@@ -994,6 +1004,9 @@ importers:
 
   etc/blocks/model-test/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-block-model.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-block-model.model':
         specifier: workspace:*
         version: link:../model
@@ -1022,8 +1035,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/model-test/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/model-test/model:
     dependencies:
+      '@milaboratories/milaboratories.test-block-model.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1136,6 +1177,9 @@ importers:
 
   etc/blocks/monetization-test/block:
     devDependencies:
+      '@milaboratories/milaboratories.monetization-test.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.monetization-test.model':
         specifier: workspace:*
         version: link:../model
@@ -1164,8 +1208,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/monetization-test/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/monetization-test/model:
     dependencies:
+      '@milaboratories/milaboratories.monetization-test.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1256,6 +1328,9 @@ importers:
 
   etc/blocks/pool-explorer/block:
     devDependencies:
+      '@milaboratories/milaboratories.pool-explorer.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.pool-explorer.model':
         specifier: workspace:*
         version: link:../model
@@ -1284,8 +1359,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/pool-explorer/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/pool-explorer/model:
     dependencies:
+      '@milaboratories/milaboratories.pool-explorer.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1373,6 +1476,9 @@ importers:
 
   etc/blocks/read-logs/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-read-logs.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-read-logs.model':
         specifier: workspace:*
         version: link:../model
@@ -1401,8 +1507,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/read-logs/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/read-logs/model:
     dependencies:
+      '@milaboratories/milaboratories.test-read-logs.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1491,15 +1625,18 @@ importers:
         specifier: 'catalog:'
         version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
 
-  etc/blocks/sum-numbers-v3/block:
+  etc/blocks/sum-numbers/block:
     devDependencies:
-      '@milaboratories/milaboratories.test-sum-numbers-v3.model':
+      '@milaboratories/milaboratories.test-sum-numbers.kind':
+        specifier: workspace:*
+        version: link:../kind
+      '@milaboratories/milaboratories.test-sum-numbers.model':
         specifier: workspace:*
         version: link:../model
-      '@milaboratories/milaboratories.test-sum-numbers-v3.ui':
+      '@milaboratories/milaboratories.test-sum-numbers.ui':
         specifier: workspace:*
         version: link:../ui
-      '@milaboratories/milaboratories.test-sum-numbers-v3.workflow':
+      '@milaboratories/milaboratories.test-sum-numbers.workflow':
         specifier: workspace:*
         version: link:../workflow
       '@milaboratories/ts-builder':
@@ -1521,107 +1658,24 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
-  etc/blocks/sum-numbers-v3/model:
+  etc/blocks/sum-numbers/kind:
     dependencies:
-      '@platforma-sdk/model':
-        specifier: workspace:*
-        version: link:../../../../sdk/model
-      '@types/node':
-        specifier: '*'
-        version: 24.5.2
-      typescript:
-        specifier: '*'
-        version: 5.9.3
-      zod:
-        specifier: 'catalog:'
-        version: 3.25.76
-    devDependencies:
-      '@milaboratories/build-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/build-configs
-      '@milaboratories/ts-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-builder
-      '@milaboratories/ts-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-configs
-      '@platforma-sdk/block-tools':
-        specifier: workspace:*
-        version: link:../../../../tools/block-tools
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
-
-  etc/blocks/sum-numbers-v3/ui:
-    dependencies:
-      '@milaboratories/milaboratories.test-sum-numbers-v3.model':
+      '@milaboratories/pl-model-common':
         specifier: workspace:*
-        version: link:../model
-      '@platforma-sdk/ui-vue':
+        version: link:../../../../lib/model/common
+      '@platforma-sdk/block-kind':
         specifier: workspace:*
-        version: link:../../../../sdk/ui-vue
+        version: link:../../../../sdk/block-kind
       '@types/node':
         specifier: '*'
         version: 24.5.2
       typescript:
         specifier: '*'
         version: 5.9.3
-      vue:
-        specifier: 'catalog:'
-        version: 3.5.24(typescript@5.9.3)
-    devDependencies:
-      '@faker-js/faker':
-        specifier: 'catalog:'
-        version: 9.2.0
-      '@milaboratories/build-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/build-configs
-      '@milaboratories/helpers':
-        specifier: workspace:*
-        version: link:../../../../lib/util/helpers
-      '@milaboratories/ts-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-builder
-      '@milaboratories/ts-configs':
-        specifier: workspace:*
-        version: link:../../../../tools/ts-configs
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
       zod:
         specifier: 'catalog:'
         version: 3.25.76
-
-  etc/blocks/sum-numbers-v3/workflow:
-    dependencies:
-      '@platforma-sdk/workflow-tengo':
-        specifier: workspace:*
-        version: link:../../../../sdk/workflow-tengo
-    devDependencies:
-      '@platforma-sdk/tengo-builder':
-        specifier: workspace:*
-        version: link:../../../../tools/tengo-builder
-      '@platforma-sdk/test':
-        specifier: workspace:*
-        version: link:../../../../sdk/test
-      shx:
-        specifier: 'catalog:'
-        version: 0.4.0
-      vitest:
-        specifier: 'catalog:'
-        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
-
-  etc/blocks/sum-numbers/block:
     devDependencies:
-      '@milaboratories/milaboratories.test-sum-numbers.model':
-        specifier: workspace:*
-        version: link:../model
-      '@milaboratories/milaboratories.test-sum-numbers.ui':
-        specifier: workspace:*
-        version: link:../ui
-      '@milaboratories/milaboratories.test-sum-numbers.workflow':
-        specifier: workspace:*
-        version: link:../workflow
       '@milaboratories/ts-builder':
         specifier: workspace:*
         version: link:../../../../tools/ts-builder
@@ -1631,18 +1685,12 @@ importers:
       '@platforma-sdk/block-tools':
         specifier: workspace:*
         version: link:../../../../tools/block-tools
-      '@platforma-sdk/model':
-        specifier: workspace:*
-        version: link:../../../../sdk/model
-      shx:
-        specifier: 'catalog:'
-        version: 0.4.0
-      typescript:
-        specifier: 'catalog:'
-        version: 5.9.3
 
   etc/blocks/sum-numbers/model:
     dependencies:
+      '@milaboratories/milaboratories.test-sum-numbers.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1733,6 +1781,9 @@ importers:
 
   etc/blocks/table-test/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-block-table.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-block-table.model':
         specifier: workspace:*
         version: link:../model
@@ -1761,8 +1812,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/table-test/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/table-test/model:
     dependencies:
+      '@milaboratories/milaboratories.test-block-table.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1872,6 +1951,9 @@ importers:
 
   etc/blocks/transfer-files/block:
     devDependencies:
+      '@milaboratories/milaboratories.transfer-files.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.transfer-files.model':
         specifier: workspace:*
         version: link:../model
@@ -1900,8 +1982,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/transfer-files/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/transfer-files/model:
     dependencies:
+      '@milaboratories/milaboratories.transfer-files.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -1992,6 +2102,9 @@ importers:
 
   etc/blocks/ui-examples/block:
     devDependencies:
+      '@milaboratories/milaboratories.ui-examples.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.ui-examples.model':
         specifier: workspace:*
         version: link:../model
@@ -2020,8 +2133,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/ui-examples/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/ui-examples/model:
     dependencies:
+      '@milaboratories/milaboratories.ui-examples.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -2130,6 +2271,9 @@ importers:
 
   etc/blocks/upload-file/block:
     devDependencies:
+      '@milaboratories/milaboratories.test-upload-file.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@milaboratories/milaboratories.test-upload-file.model':
         specifier: workspace:*
         version: link:../model
@@ -2158,8 +2302,36 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  etc/blocks/upload-file/kind:
+    dependencies:
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../../../../sdk/block-kind
+      '@types/node':
+        specifier: '*'
+        version: 24.5.2
+      typescript:
+        specifier: '*'
+        version: 5.9.3
+      zod:
+        specifier: 'catalog:'
+        version: 3.25.76
+    devDependencies:
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../../../tools/ts-configs
+      '@platforma-sdk/block-tools':
+        specifier: workspace:*
+        version: link:../../../../tools/block-tools
+
   etc/blocks/upload-file/model:
     dependencies:
+      '@milaboratories/milaboratories.test-upload-file.kind':
+        specifier: workspace:*
+        version: link:../kind
       '@platforma-sdk/model':
         specifier: workspace:*
         version: link:../../../../sdk/model
@@ -3530,6 +3702,33 @@ importers:
         specifier: 'catalog:'
         version: 5.9.3
 
+  sdk/block-kind:
+    devDependencies:
+      '@milaboratories/build-configs':
+        specifier: workspace:*
+        version: link:../../tools/build-configs
+      '@milaboratories/pl-model-common':
+        specifier: workspace:*
+        version: link:../../lib/model/common
+      '@milaboratories/ts-builder':
+        specifier: workspace:*
+        version: link:../../tools/ts-builder
+      '@milaboratories/ts-configs':
+        specifier: workspace:*
+        version: link:../../tools/ts-configs
+      '@types/node':
+        specifier: 'catalog:'
+        version: 24.5.2
+      '@vitest/coverage-istanbul':
+        specifier: 'catalog:'
+        version: 4.1.3(vitest@4.1.3)
+      typescript:
+        specifier: 'catalog:'
+        version: 5.9.3
+      vitest:
+        specifier: 'catalog:'
+        version: 4.1.3(@types/node@24.5.2)(@vitest/coverage-istanbul@4.1.3)(happy-dom@15.11.7)(jsdom@25.0.1)(vite@8.0.6(@types/node@24.5.2)(esbuild@0.27.3)(jiti@2.6.1)(sass@1.83.4)(tsx@4.19.1)(yaml@2.8.0))
+
   sdk/model:
     dependencies:
       '@milaboratories/helpers':
@@ -3584,6 +3783,9 @@ importers:
       '@milaboratories/ts-configs':
         specifier: workspace:*
         version: link:../../tools/ts-configs
+      '@platforma-sdk/block-kind':
+        specifier: workspace:*
+        version: link:../block-kind
       '@vitest/coverage-istanbul':
         specifier: 'catalog:'
         version: 4.1.3(vitest@4.1.3)
@@ -3773,9 +3975,15 @@ importers:
       '@milaboratories/build-configs':
         specifier: workspace:*
         version: link:../../tools/build-configs
+      '@milaboratories/milaboratories.test-block-table':
+        specifier: workspace:*
+        version: link:../../etc/blocks/table-test/block
       '@milaboratories/milaboratories.test-enter-numbers':
         specifier: workspace:*
         version: link:../../etc/blocks/enter-numbers/block
+      '@milaboratories/pl-model-common':
+        specifier: workspace:*
+        version: link:../../lib/model/common
       '@milaboratories/pl-model-middle-layer':
         specifier: workspace:*
         version: link:../../lib/model/middle-layer
@@ -3858,9 +4066,6 @@ importers:
       '@milaboratories/milaboratories.test-enter-numbers':
         specifier: workspace:*
         version: link:../../etc/blocks/enter-numbers/block
-      '@milaboratories/milaboratories.test-enter-numbers-v3':
-        specifier: workspace:*
-        version: link:../../etc/blocks/enter-numbers-v3/block
       '@milaboratories/milaboratories.test-enter-numbers.model':
         specifier: workspace:*
         version: link:../../etc/blocks/enter-numbers/model
@@ -3873,9 +4078,6 @@ importers:
       '@milaboratories/milaboratories.test-sum-numbers':
         specifier: workspace:*
         version: link:../../etc/blocks/sum-numbers/block
-      '@milaboratories/milaboratories.test-sum-numbers-v3':
-        specifier: workspace:*
-        version: link:../../etc/blocks/sum-numbers-v3/block
       '@milaboratories/milaboratories.test-sum-numbers.model':
         specifier: workspace:*
         version: link:../../etc/blocks/sum-numbers/model
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 1a7b71777f..e6b58a33aa 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -61,6 +61,7 @@ packages:
   - sdk/test
   - sdk/ui-vue
   - sdk/eslint-config
+  - sdk/block-kind
 
   # Test blocks
 
@@ -68,79 +69,82 @@ packages:
   - etc/blocks/enter-numbers/model
   - etc/blocks/enter-numbers/ui
   - etc/blocks/enter-numbers/block
-
-  - etc/blocks/enter-numbers-v3/workflow
-  - etc/blocks/enter-numbers-v3/model
-  - etc/blocks/enter-numbers-v3/ui
-  - etc/blocks/enter-numbers-v3/block
+  - etc/blocks/enter-numbers/kind
 
   - etc/blocks/sum-numbers/workflow
   - etc/blocks/sum-numbers/model
   - etc/blocks/sum-numbers/ui
   - etc/blocks/sum-numbers/block
-
-  - etc/blocks/sum-numbers-v3/workflow
-  - etc/blocks/sum-numbers-v3/model
-  - etc/blocks/sum-numbers-v3/ui
-  - etc/blocks/sum-numbers-v3/block
+  - etc/blocks/sum-numbers/kind
 
   - etc/blocks/filter-column-test/workflow
   - etc/blocks/filter-column-test/model
   - etc/blocks/filter-column-test/ui
   - etc/blocks/filter-column-test/block
   - etc/blocks/filter-column-test/test
+  - etc/blocks/filter-column-test/kind
 
   - etc/blocks/upload-file/workflow
   - etc/blocks/upload-file/model
   - etc/blocks/upload-file/ui
   - etc/blocks/upload-file/block
+  - etc/blocks/upload-file/kind
 
   - etc/blocks/blob-url-custom-protocol/workflow
   - etc/blocks/blob-url-custom-protocol/model
   - etc/blocks/blob-url-custom-protocol/ui
   - etc/blocks/blob-url-custom-protocol/block
+  - etc/blocks/blob-url-custom-protocol/kind
 
   - etc/blocks/monetization-test/workflow
   - etc/blocks/monetization-test/model
   - etc/blocks/monetization-test/ui
   - etc/blocks/monetization-test/block
+  - etc/blocks/monetization-test/kind
 
   - etc/blocks/download-file/workflow
   - etc/blocks/download-file/model
   - etc/blocks/download-file/ui
   - etc/blocks/download-file/block
+  - etc/blocks/download-file/kind
 
   - etc/blocks/read-logs/workflow
   - etc/blocks/read-logs/model
   - etc/blocks/read-logs/ui
   - etc/blocks/read-logs/block
+  - etc/blocks/read-logs/kind
 
   - etc/blocks/ui-examples/workflow
   - etc/blocks/ui-examples/model
   - etc/blocks/ui-examples/ui
   - etc/blocks/ui-examples/block
+  - etc/blocks/ui-examples/kind
 
   - etc/blocks/model-test/workflow
   - etc/blocks/model-test/model
   - etc/blocks/model-test/ui
   - etc/blocks/model-test/block
   - etc/blocks/model-test/test
+  - etc/blocks/model-test/kind
 
   - etc/blocks/table-test/workflow
   - etc/blocks/table-test/model
   - etc/blocks/table-test/ui
   - etc/blocks/table-test/block
   - etc/blocks/table-test/test
+  - etc/blocks/table-test/kind
 
   - etc/blocks/pool-explorer/workflow
   - etc/blocks/pool-explorer/model
   - etc/blocks/pool-explorer/ui
   - etc/blocks/pool-explorer/block
+  - etc/blocks/pool-explorer/kind
 
   - etc/blocks/transfer-files/workflow
   - etc/blocks/transfer-files/model
   - etc/blocks/transfer-files/ui
   - etc/blocks/transfer-files/block
+  - etc/blocks/transfer-files/kind
 
   # Tests
 
diff --git a/sdk/block-kind/.oxfmtrc.json b/sdk/block-kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/sdk/block-kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/sdk/block-kind/.oxlintrc.json b/sdk/block-kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/sdk/block-kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/sdk/block-kind/package.json b/sdk/block-kind/package.json
new file mode 100644
index 0000000000..6b5fd05f78
--- /dev/null
+++ b/sdk/block-kind/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "@platforma-sdk/block-kind",
+  "version": "1.0.0",
+  "description": "Block kind definition SDK",
+  "license": "UNLICENSED",
+  "files": [
+    "dist/**/*"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "ts-builder build --target node",
+    "watch": "ts-builder build --target node --watch",
+    "check": "ts-builder check --target node",
+    "formatter:check": "ts-builder formatter --check",
+    "linter:check": "ts-builder linter --check",
+    "types:check": "ts-builder type-check --target node",
+    "test": "vitest run --coverage",
+    "do-pack": "rm -f *.tgz && pnpm pack && mv *.tgz package.tgz",
+    "fmt": "ts-builder format"
+  },
+  "devDependencies": {
+    "@milaboratories/build-configs": "workspace:*",
+    "@milaboratories/pl-model-common": "workspace:*",
+    "@milaboratories/ts-builder": "workspace:*",
+    "@milaboratories/ts-configs": "workspace:*",
+    "@types/node": "catalog:",
+    "@vitest/coverage-istanbul": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}
diff --git a/sdk/block-kind/src/descriptor.ts b/sdk/block-kind/src/descriptor.ts
new file mode 100644
index 0000000000..e36421dfbe
--- /dev/null
+++ b/sdk/block-kind/src/descriptor.ts
@@ -0,0 +1,73 @@
+/**
+ * Compiled block-kind descriptor, schema version 1.
+ *
+ * The `kindSchema` discriminant lets future phases (template engine, sandbox)
+ * introduce a `"v2"` arm; consumers narrow on `kindSchema`, so v1 descriptors
+ * keep compiling untouched.
+ *
+ * `name` is the FULL npm package name of the kind, exactly as the template YAML
+ * writes it (e.g. `@platforma-open/milaboratories.mixcr-clonotyping.kind`). The
+ * S3 `{org, name}` path is always DERIVED from this npm name via the single
+ * `npmNameToKindPath` helper — there is no separate `organization` field.
+ *
+ * A descriptor is not a types-only object: it carries `parseInitializationParams`, the
+ * required runtime check of its params, so a kind package ships executable code.
+ *
+ * `BlockParams` is additionally pinned by a contravariant phantom slot (a
+ * function-parameter position). Under `strictFunctionTypes` this blocks silent
+ * structural widening between kinds of different param shapes: a kind typed for
+ * `{ ref: PlRef; k: number }` is not assignable to one typed for `{ ref: PlRef }`.
+ * The slot carries zero runtime bytes.
+ */
+export interface CompiledBlockKindV1<BlockParams> {
+  readonly kindSchema: "v1";
+  readonly name: string;
+  readonly version: string;
+  /**
+   * Runtime check of the params a block is initialized with, whenever they did not come from
+   * a typed caller. Today that means params read out of a template file someone wrote by
+   * hand, but the slot is not the template engine's: anything that initializes a block from
+   * data it did not type — a wizard, a generated pipeline — arrives the same way.
+   *
+   * REQUIRED. Without it a bad value is not caught at the entry that carries it but
+   * much later, or never — params typed `number[]` arriving as `["3","1","2"]` reach
+   * the block's init and the workflow with no error anywhere, and a numeric sort
+   * silently becomes a lexicographic one. A kind whose params are genuinely empty
+   * still declares a parser; it just rejects everything but `{}`.
+   *
+   * Must THROW to reject, and must RETURN the params to use. Returning rather than
+   * validating in place is what lets a parser strip keys the kind does not declare
+   * and coerce what it chooses to coerce — its output is what the block receives.
+   *
+   * The signature is a plain function, so this package needs no validation library of
+   * its own and a kind author picks their own tool — a hand-written check satisfies it.
+   * zod is what the workspace kinds use, and what the scaffold generates:
+   *
+   * ```ts
+   * const Params = z.object({ numbers: z.array(z.number()).optional() }).strict();
+   * export const kind = defineBlockKind<BlockParams>({
+   *   name, version, parseInitializationParams: (v) => Params.parse(v),
+   * });
+   * ```
+   *
+   * TypeScript checks the parser against the declared type, since it must return
+   * `BlockParams` — so a schema that forgets a required field does not compile. The
+   * reverse (a schema that accepts less than the type allows) is not caught, which is
+   * the honest limit of this slot.
+   *
+   * Params reach it with references already in live `PlRef` form; on the pre-flight
+   * check that happens before any block exists, the reference ids are placeholders,
+   * so a parser must not treat a specific id as meaningful.
+   */
+  readonly parseInitializationParams: (value: unknown) => BlockParams;
+  readonly __PHANTOM_BLOCK_PARAMS__?: (p: BlockParams) => void;
+}
+
+/** Current compiled-kind envelope. A discriminated union once later schemas land. */
+export type CompiledBlockKind<BlockParams> = CompiledBlockKindV1<BlockParams>;
+
+/**
+ * Recover the declared `BlockParams` off a compiled kind object. The contract
+ * the deferred `DataModelBuilder` / `BlockModelV3.create` wiring relies on.
+ */
+export type InferBlockParams<K> = K extends CompiledBlockKind<infer P> ? P : never;
diff --git a/sdk/block-kind/src/index.test.ts b/sdk/block-kind/src/index.test.ts
new file mode 100644
index 0000000000..2a18df9679
--- /dev/null
+++ b/sdk/block-kind/src/index.test.ts
@@ -0,0 +1,35 @@
+import { expect, expectTypeOf, test } from "vitest";
+import type { PlRef } from "@milaboratories/pl-model-common";
+import { defineBlockKind, type InferBlockParams } from "./index";
+
+test("InferBlockParams recovers the declared params", () => {
+  // Identity is the `{ name, version }` the caller passes — a real kind sources
+  // these from its own package.json (`import { name, version } from
+  // "../package.json"`), so the descriptor cannot drift from what npm publishes.
+  const k = defineBlockKind<{ ref: PlRef; n: number }>({
+    name: "@platforma-open/milaboratories.demo.kind",
+    version: "1.0.0",
+    parseInitializationParams: (v) => v as { ref: PlRef; n: number },
+  });
+
+  expect(k.kindSchema).toBe("v1");
+  expect(k.name).toBe("@platforma-open/milaboratories.demo.kind");
+  expect(k.version).toBe("1.0.0");
+  // Carried through, not dropped: a kind ships this check, so a descriptor without one
+  // would leave template params unvalidated at the only point that can catch them.
+  expect(typeof k.parseInitializationParams).toBe("function");
+
+  // Locks the contract the future init/create wiring relies on.
+  expectTypeOf<InferBlockParams<typeof k>>().toEqualTypeOf<{
+    ref: PlRef;
+    n: number;
+  }>();
+});
+
+test("kinds with wider params are not assignable to narrower ones", () => {
+  type Wide = InferBlockParams<ReturnType<typeof defineBlockKind<{ ref: PlRef; k: number }>>>;
+  type Narrow = InferBlockParams<ReturnType<typeof defineBlockKind<{ ref: PlRef }>>>;
+
+  // Contravariant phantom slot blocks silent widening between param shapes.
+  expectTypeOf<Wide>().not.toEqualTypeOf<Narrow>();
+});
diff --git a/sdk/block-kind/src/index.ts b/sdk/block-kind/src/index.ts
new file mode 100644
index 0000000000..ffcece6362
--- /dev/null
+++ b/sdk/block-kind/src/index.ts
@@ -0,0 +1,57 @@
+import type { CompiledBlockKind, CompiledBlockKindV1 } from "./descriptor";
+
+export type { CompiledBlockKind, InferBlockParams } from "./descriptor";
+
+/**
+ * What {@link defineBlockKind} is given: the descriptor minus what a caller does not supply.
+ *
+ * Derived rather than declared, because a copy of the same fields would let the input and the
+ * descriptor drift — and their documentation with them. A field added to the descriptor
+ * therefore has to be supplied here too, which is the right default.
+ *
+ * Two exclusions, and both are things a caller cannot state: `kindSchema` is this package's to
+ * stamp, and `__PHANTOM_BLOCK_PARAMS__` is a type-level slot that never holds a value — the
+ * factory does not copy it, so accepting it would be accepting something that gets dropped.
+ */
+export type BlockKindMeta<BlockParams = unknown> = Omit<
+  CompiledBlockKindV1<BlockParams>,
+  "kindSchema" | "__PHANTOM_BLOCK_PARAMS__"
+>;
+
+/**
+ * Define a block kind.
+ *
+ * `meta` is the kind's identity — its own `{ name, version }`. Source it from
+ * the package's `package.json` rather than hand-typing literals, so the on-wire
+ * `{name}@{version}` cannot drift from what npm publishes and what the S3
+ * manifest records (all read the same `package.json`):
+ *
+ * ```ts
+ * // a kind package's src/index.ts
+ * import { name, version } from "../package.json" with { type: "json" };
+ * export const kind = defineBlockKind<Params>({ name, version });
+ * ```
+ *
+ * rolldown inlines the JSON import (tree-shaken to the two strings) into the
+ * bundled `kind.js`, so no build-time injection is needed.
+ *
+ * A kind must also declare `parseInitializationParams` — the runtime check applied to params
+ * that came from a template file rather than from typed code. See
+ * {@link CompiledBlockKind} for what it must do.
+ *
+ * @typeParam BlockParams - shape of the params a block of this kind reads. Pinned both
+ *   as a type and by `parseInitializationParams`, whose return type is checked against it.
+ */
+export function defineBlockKind<BlockParams>(
+  meta: BlockKindMeta<BlockParams>,
+): CompiledBlockKind<BlockParams> {
+  // Frozen v1 descriptor. The phantom param slot is never assigned. Nothing serializes
+  // this object: only its name and version are read, to compose the `{name}@{version}`
+  // reference, and the parser is called in place.
+  return Object.freeze({
+    kindSchema: "v1" as const,
+    name: meta.name,
+    version: meta.version,
+    parseInitializationParams: meta.parseInitializationParams,
+  });
+}
diff --git a/sdk/block-kind/tsconfig.json b/sdk/block-kind/tsconfig.json
new file mode 100644
index 0000000000..909b413577
--- /dev/null
+++ b/sdk/block-kind/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "@milaboratories/ts-configs/tsconfig.node.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}
diff --git a/sdk/block-kind/vitest.config.mts b/sdk/block-kind/vitest.config.mts
new file mode 100644
index 0000000000..6ed5991d43
--- /dev/null
+++ b/sdk/block-kind/vitest.config.mts
@@ -0,0 +1,4 @@
+import { createVitestConfig } from "@milaboratories/build-configs";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig(createVitestConfig());
diff --git a/sdk/model/package.json b/sdk/model/package.json
index 605277390b..c88f98c942 100644
--- a/sdk/model/package.json
+++ b/sdk/model/package.json
@@ -55,6 +55,7 @@
     "@milaboratories/pf-spec-driver": "workspace:*",
     "@milaboratories/ts-builder": "workspace:*",
     "@milaboratories/ts-configs": "workspace:*",
+    "@platforma-sdk/block-kind": "workspace:*",
     "@vitest/coverage-istanbul": "catalog:",
     "fast-json-patch": "catalog:",
     "typescript": "catalog:",
diff --git a/sdk/model/src/block_migrations.ts b/sdk/model/src/block_migrations.ts
index 5a5db49d38..d700799ba8 100644
--- a/sdk/model/src/block_migrations.ts
+++ b/sdk/model/src/block_migrations.ts
@@ -1,10 +1,29 @@
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
+import { formatKindRef } from "@milaboratories/pl-model-common";
+import type { CompiledBlockKind } from "@platforma-sdk/block-kind";
 import { DATA_MODEL_LEGACY_VERSION } from "./block_storage";
 
 export type DataVersionKey = string;
 export type DataMigrateFn<From, To> = (prev: Readonly<From>) => To;
-export type DataCreateFn<T> = () => T;
+/**
+ * Initial-data factory. Object-arg so future inputs (services, resolved refs)
+ * can extend it without a signature break. `Params` carries the block's
+ * kind-declared params type; `never` means the block reads no params yet.
+ */
+export type DataCreateFn<T, Params = never> = (args: { params?: Params }) => T;
 export type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;
 
+/**
+ * The compiled block-kind object a block declares — exactly the output of
+ * `defineBlockKind` from `@platforma-sdk/block-kind`, consumed type-only.
+ *
+ * The kind object carries no reference field: the `{name}@{version}` reference
+ * is derived from it internally (via `formatKindRef`) at the point the builder
+ * and `BlockModelV3.create` need it. Aliased here so `DataModelBuilder` /
+ * `create` signatures directly accept `defineBlockKind`'s output.
+ */
+export type BlockKind<Params = never> = CompiledBlockKind<Params>;
+
 /**
  * Minimal interface that .transfer() accepts. PluginInstance implements this.
  * Defined here to avoid circular dependency with plugin_model.ts.
@@ -89,23 +108,42 @@ const FROM_BUILDER = Symbol("fromBuilder");
 /** Legacy V1 model state shape: { args, uiState } */
 export type LegacyV1State<Args, UiState> = { args: Args; uiState: UiState };
 
-/** Internal state passed from builder to DataModel */
-type BuilderState<S> = {
-  versionChain: DataVersionKey[];
-  steps: MigrationStep[];
-  transferSteps: TransferStep[];
-  initialDataFn: () => S;
-  recoverFn?: (version: DataVersionKey, data: unknown) => unknown;
-  /** Index of the first step to run after recovery. Equals the number of steps
-   *  present at the time recover() was called. */
-  recoverFromIndex?: number;
+/**
+ * The kind a chain belongs to, threaded unchanged from the builder into `DataModel`.
+ *
+ * Named because every constructor in this file carries exactly this pair, and they travel
+ * together by construction: a reference with no parser could not check the params it names,
+ * and a parser with no reference would have nothing to check them against.
+ */
+type KindWiring = {
+  /** Reference to the block kind this data model belongs to, if declared. */
+  kindRef?: BlockKindReference;
+  /** The kind's runtime params check, threaded with {@link KindWiring.kindRef}. */
+  parseInitializationParams?: (value: unknown) => unknown;
 };
 
 type RecoverState = {
   recoverFn?: (version: DataVersionKey, data: unknown) => unknown;
+  /** Index of the first step to run after recovery. Equals the number of steps
+   *  present at the time recover() was called. */
   recoverFromIndex?: number;
 };
 
+/** Internal state passed from builder to DataModel */
+type BuilderState<S> = KindWiring &
+  RecoverState & {
+    versionChain: DataVersionKey[];
+    steps: MigrationStep[];
+    transferSteps: TransferStep[];
+    /**
+     * The params type is erased to `unknown` here: the builder checks the block's
+     * factory against its kind's params, but a caller that supplies params carries them as
+     * data it did not type — parsed file content, today — and cannot state the type. The
+     * kind's own parser is what recovers it.
+     */
+    initialDataFn: DataCreateFn<S, unknown>;
+  };
+
 /**
  * Abstract base for both migration chain types.
  * Holds shared state, buildStep() helper, and init().
@@ -115,19 +153,31 @@ type RecoverState = {
  *
  * @internal
  */
-abstract class MigrationChainBase<Current, Transfers extends Record<string, unknown> = {}> {
+abstract class MigrationChainBase<
+  Current,
+  Transfers extends Record<string, unknown> = {},
+  Params = never,
+> {
   protected readonly versionChain: DataVersionKey[];
   protected readonly migrationSteps: MigrationStep[];
   protected readonly transferSteps: TransferStep[];
-
-  protected constructor(state: {
-    versionChain: DataVersionKey[];
-    steps: MigrationStep[];
-    transferSteps?: TransferStep[];
-  }) {
+  /** Kind reference seeded by the builder, threaded through the chain into init(). */
+  protected readonly kindRef?: BlockKindReference;
+  /** The kind's runtime params check, carried for `init()` to hand to the DataModel. */
+  protected readonly parseInitializationParams?: (value: unknown) => unknown;
+
+  protected constructor(
+    state: KindWiring & {
+      versionChain: DataVersionKey[];
+      steps: MigrationStep[];
+      transferSteps?: TransferStep[];
+    },
+  ) {
     this.versionChain = state.versionChain;
     this.migrationSteps = state.steps;
     this.transferSteps = state.transferSteps ?? [];
+    this.kindRef = state.kindRef;
+    this.parseInitializationParams = state.parseInitializationParams;
   }
 
   /** Appends a migration step and returns the new versionChain and steps arrays. */
@@ -178,12 +228,14 @@ abstract class MigrationChainBase<Current, Transfers extends Record<string, unkn
    * @param initialData - Factory function returning the initial state
    * @returns Finalized DataModel instance
    */
-  init(initialData: DataCreateFn<Current>): DataModel<Current, Transfers> {
-    return DataModel[FROM_BUILDER]<Current, Transfers>({
+  init(initialData: DataCreateFn<Current, Params>): DataModel<Current, Params, Transfers> {
+    return DataModel[FROM_BUILDER]<Current, Params, Transfers>({
       versionChain: this.versionChain,
       steps: this.migrationSteps,
       transferSteps: this.transferSteps,
-      initialDataFn: initialData,
+      initialDataFn: initialData as DataCreateFn<Current, unknown>,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
       ...this.recoverState(),
     });
   }
@@ -201,18 +253,20 @@ abstract class MigrationChainBase<Current, Transfers extends Record<string, unkn
 class DataModelMigrationChainWithRecover<
   Current,
   Transfers extends Record<string, unknown> = {},
-> extends MigrationChainBase<Current, Transfers> {
+  Params = never,
+> extends MigrationChainBase<Current, Transfers, Params> {
   private readonly recoverFn?: (version: DataVersionKey, data: unknown) => unknown;
   private readonly recoverFromIndex?: number;
 
   /** @internal */
-  constructor(state: {
-    versionChain: DataVersionKey[];
-    steps: MigrationStep[];
-    transferSteps?: TransferStep[];
-    recoverFn?: (version: DataVersionKey, data: unknown) => unknown;
-    recoverFromIndex?: number;
-  }) {
+  constructor(
+    state: KindWiring &
+      RecoverState & {
+        versionChain: DataVersionKey[];
+        steps: MigrationStep[];
+        transferSteps?: TransferStep[];
+      },
+  ) {
     super(state);
     this.recoverFn = state.recoverFn;
     this.recoverFromIndex = state.recoverFromIndex;
@@ -232,12 +286,14 @@ class DataModelMigrationChainWithRecover<
   migrate<Next>(
     nextVersion: string,
     fn: DataMigrateFn<Current, Next>,
-  ): DataModelMigrationChainWithRecover<Next, Transfers> {
+  ): DataModelMigrationChainWithRecover<Next, Transfers, Params> {
     const { versionChain, steps } = this.buildStep(nextVersion, fn);
-    return new DataModelMigrationChainWithRecover<Next, Transfers>({
+    return new DataModelMigrationChainWithRecover<Next, Transfers, Params>({
       versionChain,
       steps,
       transferSteps: this.transferSteps,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
       recoverFn: this.recoverFn,
       recoverFromIndex: this.recoverFromIndex,
     });
@@ -251,12 +307,14 @@ class DataModelMigrationChainWithRecover<
   transfer<Id extends string, L>(
     target: TransferTarget<Id & (Id extends keyof Transfers ? never : string), L>,
     extract: (data: Current) => L,
-  ): DataModelMigrationChainWithRecover<Current, Transfers & Record<Id, L>> {
+  ): DataModelMigrationChainWithRecover<Current, Transfers & Record<Id, L>, Params> {
     const { transferSteps } = this.buildTransfer(target, extract);
-    return new DataModelMigrationChainWithRecover<Current, Transfers & Record<Id, L>>({
+    return new DataModelMigrationChainWithRecover<Current, Transfers & Record<Id, L>, Params>({
       versionChain: this.versionChain,
       steps: this.migrationSteps,
       transferSteps,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
       recoverFn: this.recoverFn,
       recoverFromIndex: this.recoverFromIndex,
     });
@@ -276,18 +334,21 @@ class DataModelMigrationChainWithRecover<
 class DataModelMigrationChain<
   Current,
   Transfers extends Record<string, unknown> = {},
-> extends MigrationChainBase<Current, Transfers> {
+  Params = never,
+> extends MigrationChainBase<Current, Transfers, Params> {
   /** @internal */
   constructor({
     versionChain,
     steps = [],
     transferSteps = [],
-  }: {
+    kindRef,
+    parseInitializationParams,
+  }: KindWiring & {
     versionChain: DataVersionKey[];
     steps?: MigrationStep[];
     transferSteps?: TransferStep[];
   }) {
-    super({ versionChain, steps, transferSteps });
+    super({ versionChain, steps, transferSteps, kindRef, parseInitializationParams });
   }
 
   /**
@@ -304,12 +365,14 @@ class DataModelMigrationChain<
   migrate<Next>(
     nextVersion: string,
     fn: DataMigrateFn<Current, Next>,
-  ): DataModelMigrationChain<Next, Transfers> {
+  ): DataModelMigrationChain<Next, Transfers, Params> {
     const { versionChain, steps } = this.buildStep(nextVersion, fn);
-    return new DataModelMigrationChain<Next, Transfers>({
+    return new DataModelMigrationChain<Next, Transfers, Params>({
       versionChain,
       steps,
       transferSteps: this.transferSteps,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
     });
   }
 
@@ -329,12 +392,14 @@ class DataModelMigrationChain<
   transfer<Id extends string, L>(
     target: TransferTarget<Id & (Id extends keyof Transfers ? never : string), L>,
     extract: (data: Current) => L,
-  ): DataModelMigrationChain<Current, Transfers & Record<Id, L>> {
+  ): DataModelMigrationChain<Current, Transfers & Record<Id, L>, Params> {
     const { transferSteps } = this.buildTransfer(target, extract);
-    return new DataModelMigrationChain<Current, Transfers & Record<Id, L>>({
+    return new DataModelMigrationChain<Current, Transfers & Record<Id, L>, Params>({
       versionChain: this.versionChain,
       steps: this.migrationSteps,
       transferSteps,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
     });
   }
 
@@ -361,11 +426,15 @@ class DataModelMigrationChain<
    *   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
    *   .init(() => ({ count: 0, label: "", description: "" }));
    */
-  recover(fn: DataRecoverFn<Current>): DataModelMigrationChainWithRecover<Current, Transfers> {
-    return new DataModelMigrationChainWithRecover<Current, Transfers>({
+  recover(
+    fn: DataRecoverFn<Current>,
+  ): DataModelMigrationChainWithRecover<Current, Transfers, Params> {
+    return new DataModelMigrationChainWithRecover<Current, Transfers, Params>({
       versionChain: this.versionChain,
       steps: this.migrationSteps,
       transferSteps: this.transferSteps,
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
       recoverFn: fn as (version: DataVersionKey, data: unknown) => unknown,
       recoverFromIndex: this.migrationSteps.length,
     });
@@ -384,7 +453,8 @@ class DataModelMigrationChain<
 class DataModelInitialChain<
   Current,
   Transfers extends Record<string, unknown> = {},
-> extends DataModelMigrationChain<Current, Transfers> {
+  Params = never,
+> extends DataModelMigrationChain<Current, Transfers, Params> {
   /**
    * Handle legacy V1 model state ({ args, uiState }) when upgrading a block from
    * BlockModel V1 to BlockModelV3.
@@ -421,7 +491,7 @@ class DataModelInitialChain<
    */
   upgradeLegacy<Args, UiState = unknown>(
     fn: (legacy: LegacyV1State<Args, UiState>) => Current,
-  ): DataModelMigrationChainWithRecover<Current, Transfers> {
+  ): DataModelMigrationChainWithRecover<Current, Transfers, Params> {
     const wrappedFn = (data: unknown): unknown => {
       if (data !== null && typeof data === "object" && "args" in data) {
         return fn(data as LegacyV1State<Args, UiState>);
@@ -437,9 +507,11 @@ class DataModelInitialChain<
       toVersion: initialVersion,
       migrate: wrappedFn,
     };
-    return new DataModelMigrationChainWithRecover<Current, Transfers>({
+    return new DataModelMigrationChainWithRecover<Current, Transfers, Params>({
       versionChain: [DATA_MODEL_LEGACY_VERSION, ...this.versionChain],
       steps: [step, ...this.migrationSteps],
+      kindRef: this.kindRef,
+      parseInitializationParams: this.parseInitializationParams,
       // Shift transfer indices to account for the prepended legacy step
       transferSteps: this.transferSteps.map((t) => ({
         ...t,
@@ -495,7 +567,29 @@ class DataModelInitialChain<
  *   }))
  *   .init(() => ({ inputFile: '', selectedTab: 'main' }));
  */
-export class DataModelBuilder {
+export class DataModelBuilder<Params = never> {
+  readonly #kindRef?: BlockKindReference;
+  readonly #parseInitializationParams?: (value: unknown) => Params;
+
+  /**
+   * @param opts.kind - The block kind this data model implements. Its reference
+   *   is captured and baked into the config so the manifest can advertise which
+   *   kind the block satisfies, and its `Params` type flows into `.init()`.
+   *   Optional during the transition window while existing V3 blocks are
+   *   migrated to kind-carrying builders; a kind-less builder simply carries no
+   *   reference and the reconciler can't project it yet. Object form mirrors
+   *   `BlockModelV3.create({ dataModel, kind })`.
+   */
+  constructor(opts?: { kind?: BlockKind<Params> }) {
+    // Derive the on-wire `{name}@{version}` reference from the compiled kind;
+    // the kind object itself has no reference field.
+    this.#kindRef = opts?.kind ? formatKindRef(opts.kind) : undefined;
+    // Carried alongside the reference, and for the same reason: the kind object is
+    // not kept, but two things off it are needed later — how to name the kind, and
+    // how to check params claimed to be of it.
+    this.#parseInitializationParams = opts?.kind?.parseInitializationParams;
+  }
+
   /**
    * Start the migration chain with the given initial data type and version key.
    *
@@ -503,8 +597,14 @@ export class DataModelBuilder {
    * @param initialVersion - Version key string (e.g. "v1")
    * @returns Migration chain builder
    */
-  from<T>(initialVersion: string): DataModelInitialChain<T> {
-    return new DataModelInitialChain<T>({ versionChain: [initialVersion] });
+  from<T>(initialVersion: string): DataModelInitialChain<T, {}, Params> {
+    return new DataModelInitialChain<T, {}, Params>({
+      versionChain: [initialVersion],
+      kindRef: this.#kindRef,
+      parseInitializationParams: this.#parseInitializationParams as
+        | ((value: unknown) => unknown)
+        | undefined,
+    });
   }
 }
 
@@ -527,9 +627,12 @@ export class DataModelBuilder {
  *   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
  *   .init(() => ({ count: 0, label: "", description: "" }));
  */
-export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
+export class DataModel<State, Params = never, Transfers extends Record<string, unknown> = {}> {
   /** @internal Phantom field to anchor the Transfers type parameter. */
   declare readonly __transfers?: Transfers;
+  /** @internal Phantom field to anchor the Params type parameter (drives the
+   *  compile-time kind cross-check in `BlockModelV3.create`). */
+  declare readonly __params?: Params;
 
   /** Latest version key — O(1) access for the common "already current" check. */
   private readonly latestVersion: DataVersionKey;
@@ -537,15 +640,21 @@ export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
   private readonly stepsByFromVersion: ReadonlyMap<DataVersionKey, number>;
   private readonly steps: MigrationStep[];
   private readonly transferSteps: TransferStep[];
-  private readonly initialDataFn: () => State;
+  private readonly initialDataFn: DataCreateFn<State, unknown>;
   private readonly recoverFn: (version: DataVersionKey, data: unknown) => unknown;
   private readonly recoverFromIndex: number;
+  /** Reference to the block kind this data model was built for, if any. */
+  private readonly _kindRef?: BlockKindReference;
+  /** The kind's runtime params check, if it declares one. */
+  private readonly _parseInitializationParams?: (value: unknown) => unknown;
 
   private constructor({
     versionChain,
     steps,
     transferSteps = [],
     initialDataFn,
+    kindRef,
+    parseInitializationParams,
     recoverFn = defaultRecover,
     recoverFromIndex,
   }: BuilderState<State>) {
@@ -557,6 +666,8 @@ export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
     this.steps = steps;
     this.transferSteps = transferSteps;
     this.initialDataFn = initialDataFn;
+    this._kindRef = kindRef;
+    this._parseInitializationParams = parseInitializationParams;
     this.recoverFn = recoverFn;
     this.recoverFromIndex = recoverFromIndex ?? steps.length;
   }
@@ -566,10 +677,31 @@ export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
    * Uses Symbol key to prevent external access.
    * @internal
    */
-  static [FROM_BUILDER]<S, T extends Record<string, unknown> = {}>(
+  static [FROM_BUILDER]<S, P = never, T extends Record<string, unknown> = {}>(
     state: BuilderState<S>,
-  ): DataModel<S, T> {
-    return new DataModel<S, T>(state);
+  ): DataModel<S, P, T> {
+    return new DataModel<S, P, T>(state);
+  }
+
+  /**
+   * Reference to the block kind this data model was built for, or `undefined`
+   * for a kind-less builder. Used by `BlockModelV3.create` to cross-check that
+   * the kind handed to the builder matches the kind handed to `create`.
+   * @internal
+   */
+  get kindRef(): BlockKindReference | undefined {
+    return this._kindRef;
+  }
+
+  /**
+   * The kind's runtime params check, or `undefined` if the kind declares none (or
+   * there is no kind). Read by `BlockModelV3.done()` to register the check, and
+   * carried here rather than only on the model because `init` — the one place params
+   * are consumed — lives on this side.
+   * @internal
+   */
+  get templateParamsParser(): ((value: unknown) => unknown) | undefined {
+    return this._parseInitializationParams;
   }
 
   /**
@@ -583,7 +715,7 @@ export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
    * Get a fresh copy of the initial data.
    */
   initialData(): State {
-    return this.initialDataFn();
+    return this.initialDataFn({});
   }
 
   /**
@@ -591,7 +723,25 @@ export class DataModel<State, Transfers extends Record<string, unknown> = {}> {
    * Used when creating new blocks or resetting to defaults.
    */
   getDefaultData(): DataVersioned<State> {
-    return makeVersionedData(this.latestVersion, this.initialDataFn());
+    return makeVersionedData(this.latestVersion, this.initialDataFn({}));
+  }
+
+  /**
+   * Get initial data built from params, wrapped with current version.
+   *
+   * The counterpart of {@link getDefaultData} for a block created from a template
+   * entry: the factory receives the entry's params instead of nothing. A factory
+   * that ignores its argument produces the same result as `getDefaultData`, which
+   * is why the two are separate methods rather than one optional argument — the
+   * caller decides which contract it is asking for, and a block that cannot honour
+   * params must not silently look like one that can.
+   *
+   * References inside `params` are already resolved to the target project's
+   * concrete ids by the time they get here; the factory never sees a
+   * template-local one.
+   */
+  getDataFromParams(params: unknown): DataVersioned<State> {
+    return makeVersionedData(this.latestVersion, this.initialDataFn({ params }));
   }
 
   private recoverFrom(data: unknown, version: DataVersionKey): DataVersioned<State> {
diff --git a/sdk/model/src/block_model.ts b/sdk/model/src/block_model.ts
index 58996bd6cc..96b710a408 100644
--- a/sdk/model/src/block_model.ts
+++ b/sdk/model/src/block_model.ts
@@ -5,10 +5,11 @@ import type {
   PlRef,
   BlockCodeKnownFeatureFlags,
   BlockConfigContainer,
+  BlockKindReference,
 } from "@milaboratories/pl-model-common";
-import { REQUIRES_PFRAMES_VERSION } from "@milaboratories/pl-model-common";
+import { REQUIRES_PFRAMES_VERSION, formatKindRef } from "@milaboratories/pl-model-common";
 import { getPlatformaInstance, isInUI, createAndRegisterRenderLambda } from "./internal";
-import type { DataModel } from "./block_migrations";
+import type { BlockKind, DataModel } from "./block_migrations";
 import type { PlatformaV3 } from "./platforma";
 import type { BlockDefaultUiServices } from "./services/service_resolve";
 import { BLOCK_SERVICE_FLAGS } from "./services/block_services";
@@ -30,8 +31,11 @@ import {
   getStorageDebugView,
   migrateStorage,
   createInitialStorage,
+  createInitialStorageFromParams,
+  validateTemplateParamsJson,
   deriveArgsFromStorage,
   derivePrerunArgsFromStorage,
+  deriveTemplateParamsFromStorage,
 } from "./block_storage_callbacks";
 import { type PluginName } from "./block_storage";
 import type {
@@ -108,9 +112,13 @@ interface BlockModelV3Config<
   Data,
   Plugins extends Record<string, PluginRecord> = {},
   Transfers extends Record<string, unknown> = {},
+  Params = unknown,
 > {
   renderingMode: BlockRenderingMode;
-  dataModel: DataModel<Data, Transfers>;
+  dataModel: DataModel<Data, Params, Transfers>;
+  /** Reference to the block kind this model implements, in `{name}@{version}` form. */
+  // @todo: use blockKind, `kind` super comman word
+  kind: BlockKindReference | undefined;
   outputs: OutputsCfg;
   sections: ConfigRenderLambda;
   title: ConfigRenderLambda | undefined;
@@ -118,8 +126,17 @@ interface BlockModelV3Config<
   tags: ConfigRenderLambda | undefined;
   enrichmentTargets: ConfigRenderLambda | undefined;
   featureFlags: BlockCodeKnownFeatureFlags;
-  argsFunction: ((data: unknown) => unknown) | undefined;
-  prerunArgsFunction: ((data: unknown) => unknown) | undefined;
+  deriveArgs: ((data: unknown) => unknown) | undefined;
+  derivePrerunArgs: ((data: unknown) => unknown) | undefined;
+  /** Projects block data back to this kind's params for template export. */
+  deriveTemplateParams: ((data: Data) => Params) | undefined;
+  /**
+   * The kind's runtime check for params supplied by a template. Read off the compiled
+   * kind rather than declared per block: the params contract belongs to the kind, and
+   * two blocks implementing it must not be able to disagree about what a valid params
+   * object is. Always present — a kind cannot omit it, and a block cannot omit a kind.
+   */
+  parseInitializationParams: (value: unknown) => unknown;
   plugins: Plugins;
 }
 
@@ -134,9 +151,10 @@ export class BlockModelV3<
   Href extends `/${string}` = "/",
   Plugins extends Record<string, PluginRecord> = {},
   Transfers extends Record<string, unknown> = {},
+  Params = unknown,
 > {
   private constructor(
-    private readonly config: BlockModelV3Config<OutputsCfg, Data, Plugins, Transfers>,
+    private readonly config: BlockModelV3Config<OutputsCfg, Data, Plugins, Transfers, Params>,
   ) {}
 
   public static readonly FEATURE_FLAGS = {
@@ -153,27 +171,55 @@ export class BlockModelV3<
   public static readonly INITIAL_BLOCK_FEATURE_FLAGS = BlockModelV3.FEATURE_FLAGS;
 
   /**
-   * Creates a new BlockModelV3 builder with the specified data model.
+   * Creates a new BlockModelV3 builder bound to a data model and a block kind.
+   *
+   * The `kind` argument is cross-checked against the kind handed to the
+   * builder: its `Params` type must match at compile time (via
+   * `BlockKind<Params>`), and its reference value must match at runtime. The
+   * reference is baked into the config so the published manifest can advertise
+   * which kind the block implements.
    *
    * @example
-   * const dataModel = new DataModelBuilder()
+   * const dataModel = new DataModelBuilder({ kind })
    *   .from<BlockData>("v1")
-   *   .init(() => ({ numbers: [], labels: [] }));
+   *   .init(({ params }) => params ?? { numbers: [], labels: [] });
    *
-   * BlockModelV3.create(dataModel)
+   * BlockModelV3.create({ dataModel, kind })
    *   .args((data) => ({ numbers: data.numbers }))
    *   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])
    *   .done();
-   *
-   * @param dataModel The data model that defines initial data and migrations
    */
   public static create<
     Data extends Record<string, unknown>,
+    Params = never,
     Transfers extends Record<string, unknown> = {},
-  >(dataModel: DataModel<Data, Transfers>): BlockModelV3<NoOb, {}, Data, "/", {}, Transfers> {
-    return new BlockModelV3<NoOb, {}, Data, "/", {}, Transfers>({
+  >(args: {
+    dataModel: DataModel<Data, Params, Transfers>;
+    kind: BlockKind<Params>;
+  }): BlockModelV3<NoOb, {}, Data, "/", {}, Transfers, Params> {
+    const { dataModel, kind } = args;
+    // Derive the on-wire reference from the compiled kind; the kind object has
+    // no reference field of its own.
+    const kindRef = formatKindRef(kind);
+
+    // Runtime guard: the kind handed to the builder must match the kind handed to
+    // create(). Nothing ties them together at the type level — they arrive as two
+    // separately-passed objects — so a mismatch is only visible here. The builder's own
+    // reference is still optional, because a PLUGIN data model is built without a kind
+    // and has none to compare.
+    if (dataModel.kindRef && dataModel.kindRef !== kindRef) {
+      throw new Error(
+        `Block kind mismatch: data model built for '${dataModel.kindRef}' but create() got '${kindRef}'`,
+      );
+    }
+
+    return new BlockModelV3<NoOb, {}, Data, "/", {}, Transfers, Params>({
       renderingMode: "Heavy",
       dataModel,
+      kind: kindRef,
+      // Read off the kind, which cannot omit it — not off the data model. The two
+      // are cross-checked above, so there is one source, not a precedence order.
+      parseInitializationParams: kind.parseInitializationParams,
       outputs: {},
       sections: createAndRegisterRenderLambda({ handle: "sections", lambda: () => [] }, true),
       title: undefined,
@@ -181,8 +227,9 @@ export class BlockModelV3<
       tags: undefined,
       enrichmentTargets: undefined,
       featureFlags: { ...BlockModelV3.FEATURE_FLAGS },
-      argsFunction: undefined,
-      prerunArgsFunction: undefined,
+      deriveArgs: undefined,
+      derivePrerunArgs: undefined,
+      deriveTemplateParams: undefined,
       plugins: {},
     });
   }
@@ -209,7 +256,8 @@ export class BlockModelV3<
     Data,
     Href,
     Plugins,
-    Transfers
+    Transfers,
+    Params
   >;
   /**
    * Add output cell to the configuration
@@ -231,13 +279,14 @@ export class BlockModelV3<
     Data,
     Href,
     Plugins,
-    Transfers
+    Transfers,
+    Params
   >;
   public output(
     key: string,
     cfgOrRf: RenderFunction<Args, Data, unknown>,
     flags: ConfigRenderLambdaFlags = {},
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
     return new BlockModelV3({
       ...this.config,
       outputs: {
@@ -266,7 +315,8 @@ export class BlockModelV3<
     Data,
     Href,
     Plugins,
-    Transfers
+    Transfers,
+    Params
   > {
     return this.output(key, rf, { retentive: true });
   }
@@ -294,10 +344,10 @@ export class BlockModelV3<
    */
   public args<A>(
     lambda: (data: Data) => A,
-  ): BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
-      argsFunction: lambda as (data: unknown) => unknown,
+      deriveArgs: lambda as (data: unknown) => unknown,
     });
   }
 
@@ -323,10 +373,47 @@ export class BlockModelV3<
    */
   public prerunArgs(
     fn: (data: Data) => unknown,
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
-      prerunArgsFunction: fn as (data: unknown) => unknown,
+      derivePrerunArgs: fn as (data: unknown) => unknown,
+    });
+  }
+
+  /**
+   * Sets the function that projects block data back to this kind's params, for
+   * exporting the project as a template.
+   *
+   * The inverse of the data model's `init`: `init` builds data from `params`, this
+   * recovers the `params` that would rebuild the current data. Return only params
+   * — runtime and derived state is dropped, and the exporter supplies the rest of
+   * the entry (`id`, `kind`), which this lambda cannot set.
+   *
+   * References are returned as ordinary `PlRef`s; the SDK rewrites them into
+   * template-local form on the way out, so a block never deals with the file
+   * representation.
+   *
+   * Required: `done()` throws without it. A block whose state cannot be reduced to
+   * params returns `{}` and says so explicitly, rather than exporting an entry with
+   * no params that silently applies as a default-initialized block.
+   *
+   * The return type is the kind's `Params`, so a block whose projection drifts
+   * from its own init contract fails to compile. Available only on a
+   * kind-carrying model — `create(dataModel)` without a kind leaves `Params` as
+   * `unknown` and this method cannot be type-checked against anything.
+   *
+   * @example
+   * BlockModelV3.create({ dataModel, kind })
+   *   .args((data) => ({ numbers: data.numbers }))
+   *   .templateParams((data) => ({ sources: data.sources }))
+   *   .done();
+   */
+  public templateParams(
+    fn: (data: Data) => Params,
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
+      ...this.config,
+      deriveTemplateParams: fn,
     });
   }
 
@@ -334,27 +421,35 @@ export class BlockModelV3<
   public sections<
     const Ret extends SectionsExpectedType,
     const RF extends RenderFunction<Args, Data, Ret>,
-  >(rf: RF): BlockModelV3<Args, OutputsCfg, Data, DeriveHref<ReturnType<RF>>, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, DeriveHref<ReturnType<RF>>, Plugins, Transfers>(
-      {
-        ...this.config,
-        // Replace the default sections callback with the user-provided one
-        sections: createAndRegisterRenderLambda(
-          {
-            handle: "sections",
-            lambda: () => rf(new BlockRenderCtx<Args, Data>()),
-          },
-          true,
-        ),
-      },
-    );
+  >(
+    rf: RF,
+  ): BlockModelV3<Args, OutputsCfg, Data, DeriveHref<ReturnType<RF>>, Plugins, Transfers, Params> {
+    return new BlockModelV3<
+      Args,
+      OutputsCfg,
+      Data,
+      DeriveHref<ReturnType<RF>>,
+      Plugins,
+      Transfers,
+      Params
+    >({
+      ...this.config,
+      // Replace the default sections callback with the user-provided one
+      sections: createAndRegisterRenderLambda(
+        {
+          handle: "sections",
+          lambda: () => rf(new BlockRenderCtx<Args, Data>()),
+        },
+        true,
+      ),
+    });
   }
 
   /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
   public title(
     rf: RenderFunction<Args, Data, string>,
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
       title: createAndRegisterRenderLambda({
         handle: "title",
@@ -365,8 +460,8 @@ export class BlockModelV3<
 
   public subtitle(
     rf: RenderFunction<Args, Data, string>,
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
       subtitle: createAndRegisterRenderLambda({
         handle: "subtitle",
@@ -377,8 +472,8 @@ export class BlockModelV3<
 
   public tags(
     rf: RenderFunction<Args, Data, string[]>,
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
       tags: createAndRegisterRenderLambda({
         handle: "tags",
@@ -390,8 +485,8 @@ export class BlockModelV3<
   /** Sets or overrides feature flags for the block. */
   public withFeatureFlags(
     flags: Partial<BlockCodeKnownFeatureFlags>,
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
       featureFlags: { ...this.config.featureFlags, ...flags },
     });
@@ -403,8 +498,8 @@ export class BlockModelV3<
    */
   public enriches(
     lambda: (args: Args) => PlRef[],
-  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers> {
-    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers>({
+  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params> {
+    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params>({
       ...this.config,
       enrichmentTargets: createAndRegisterRenderLambda({
         handle: "enrichmentTargets",
@@ -475,7 +570,8 @@ export class BlockModelV3<
         PluginUiServices
       >;
     },
-    Omit<Transfers, PluginId>
+    Omit<Transfers, PluginId>,
+    Params
   >;
   public plugin(
     instance: PluginInstanceClass,
@@ -486,7 +582,8 @@ export class BlockModelV3<
     Data,
     Href,
     Record<string, PluginRecord>,
-    Record<string, unknown>
+    Record<string, unknown>,
+    Params
   > {
     const pluginId = instance.id;
     const plugin = instance[CREATE_PLUGIN_MODEL]();
@@ -532,7 +629,13 @@ export class BlockModelV3<
       BlockDefaultUiServices
     >
   > {
-    if (this.config.argsFunction === undefined) throw new Error("Args rendering function not set.");
+    if (this.config.deriveArgs === undefined) throw new Error("Args rendering function not set.");
+    if (this.config.deriveTemplateParams === undefined)
+      throw new Error(
+        "templateParams() not set. Every block must project its state back to its kind's params, " +
+          "so a project can be exported as a template and re-applied; a block whose state carries " +
+          "nothing worth restoring returns {}.",
+      );
 
     const apiVersion = 3;
 
@@ -544,7 +647,13 @@ export class BlockModelV3<
       pluginRegistry[handle] = plugins[handle].model.name;
     }
 
-    const { dataModel, argsFunction, prerunArgsFunction } = this.config;
+    const {
+      dataModel,
+      deriveArgs,
+      derivePrerunArgs,
+      deriveTemplateParams,
+      parseInitializationParams,
+    } = this.config;
 
     function getPlugin(handle: PluginHandle): PluginRecord {
       const plugin = plugins[handle];
@@ -573,9 +682,23 @@ export class BlockModelV3<
           createPluginData: (handle) => getPlugin(handle).model.getDefaultData(),
         }),
       [BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) =>
-        deriveArgsFromStorage(storageJson, argsFunction),
+        deriveArgsFromStorage(storageJson, deriveArgs),
       [BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) =>
-        derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction),
+        derivePrerunArgsFromStorage(storageJson, deriveArgs, derivePrerunArgs),
+      [BlockStorageFacadeCallbacks.InitializationParamsDerive]: (storageJson) =>
+        deriveTemplateParamsFromStorage(
+          storageJson,
+          deriveTemplateParams as (data: unknown) => unknown,
+        ),
+      [BlockStorageFacadeCallbacks.StorageInitialFromParams]: (paramsJson) =>
+        createInitialStorageFromParams(paramsJson, {
+          getBlockDataFromParams: (params) => dataModel.getDataFromParams(params),
+          getPluginRegistry: () => pluginRegistry,
+          createPluginData: (handle) => getPlugin(handle).model.getDefaultData(),
+          parseInitializationParams,
+        }),
+      [BlockStorageFacadeCallbacks.InitializationParamsValidate]: (paramsJson) =>
+        validateTemplateParamsJson(paramsJson, parseInitializationParams),
     });
 
     // Register plugin input and output lambdas
@@ -620,6 +743,11 @@ export class BlockModelV3<
           blockLifecycleCallbacks: { ...BlockStorageFacadeHandles },
         },
 
+        // Block-kind identity, baked at the container level beside `code`
+        // (orthogonal to which render envelope applies). Rides into model.json
+        // via the JSON.stringify(config) in build-model.ts — no write-path change.
+        kind: this.config.kind,
+
         // fields below are added to allow previous desktop versions read generated configs
         sdkVersion: PlatformaSDKVersion,
         renderingMode: this.config.renderingMode,
@@ -698,9 +826,12 @@ type _ConfigTest = Expect<
     BlockModelV3Config<_TestOutputs, _TestData>,
     {
       renderingMode: BlockRenderingMode;
-      argsFunction: ((data: unknown) => unknown) | undefined;
-      prerunArgsFunction: ((data: unknown) => unknown) | undefined;
-      dataModel: DataModel<_TestData, {}>;
+      deriveArgs: ((data: unknown) => unknown) | undefined;
+      derivePrerunArgs: ((data: unknown) => unknown) | undefined;
+      deriveTemplateParams: ((data: _TestData) => unknown) | undefined;
+      parseInitializationParams: (value: unknown) => unknown;
+      dataModel: DataModel<_TestData, unknown, {}>;
+      kind: BlockKindReference | undefined;
       outputs: _TestOutputs;
       sections: ConfigRenderLambda;
       title: ConfigRenderLambda | undefined;
diff --git a/sdk/model/src/block_storage_callbacks.ts b/sdk/model/src/block_storage_callbacks.ts
index 7371b74816..5566f2952c 100644
--- a/sdk/model/src/block_storage_callbacks.ts
+++ b/sdk/model/src/block_storage_callbacks.ts
@@ -25,7 +25,11 @@ import {
 } from "./block_storage";
 import type { PluginHandle } from "./plugin_handle";
 
-import { stringifyJson, type StringifiedJson } from "@milaboratories/pl-model-common";
+import {
+  stringifyJson,
+  wrapTemplateRefs,
+  type StringifiedJson,
+} from "@milaboratories/pl-model-common";
 import type { DataVersioned, TransferRecord } from "./block_migrations";
 import type { StorageDebugView } from "@milaboratories/pl-model-middle-layer";
 
@@ -237,7 +241,20 @@ export function migrateStorage(
  * @throws If initialDataFn or createPluginData throws
  */
 export function createInitialStorage(hooks: InitialStorageHooks): StringifiedJson<BlockStorage> {
-  const blockDefault = hooks.getDefaultBlockData();
+  return assembleStorage(hooks.getDefaultBlockData(), hooks);
+}
+
+/**
+ * Wraps freshly created block data and freshly created plugin data into storage.
+ *
+ * Shared by the two ways a block's first storage comes into being — from defaults
+ * and from template params. Only the block's own data differs between them:
+ * plugins have no params channel, so they are always created at their defaults.
+ */
+function assembleStorage(
+  blockData: DataVersioned<unknown>,
+  hooks: Omit<InitialStorageHooks, "getDefaultBlockData">,
+): StringifiedJson<BlockStorage> {
   const pluginRegistry = hooks.getPluginRegistry();
 
   const plugins: Record<PluginHandle, VersionedData<unknown>> = {};
@@ -248,14 +265,185 @@ export function createInitialStorage(hooks: InitialStorageHooks): StringifiedJso
 
   const storage: BlockStorage = {
     [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,
-    __dataVersion: blockDefault.version,
-    __data: blockDefault.data,
+    __dataVersion: blockData.version,
+    __data: blockData.data,
     __pluginRegistry: pluginRegistry,
     __plugins: plugins,
   };
   return stringifyJson(storage);
 }
 
+/** Dependencies for creating storage from a template entry's params. */
+export interface ParamsStorageHooks extends Omit<InitialStorageHooks, "getDefaultBlockData"> {
+  /** The block's init factory, called with the entry's params. */
+  getBlockDataFromParams: (params: unknown) => DataVersioned<unknown>;
+  /**
+   * The kind's runtime params check. Applied before the factory sees anything, and its
+   * output is what the factory gets.
+   */
+  parseInitializationParams: (value: unknown) => unknown;
+}
+
+/** Result of checking params against their kind: the params to use, or why they lost. */
+export type TemplateParamsValidationResult =
+  | { error: string }
+  | { error?: undefined; value: unknown };
+
+/**
+ * Check params against their kind's declared shape.
+ *
+ * The kind owns this rather than the block because the params contract belongs to the
+ * kind: many block versions implement one kind, and a per-block check would let them
+ * drift from each other and from the type.
+ *
+ * A parser rejects by throwing and accepts by returning the params to use, so its
+ * output — not the input — is what flows onward. That is what lets a kind strip keys
+ * it does not declare, which is the difference between a typo being ignored and a typo
+ * being reported.
+ *
+ * Every kind declares a parser, so every set of params that reaches here is checked;
+ * there is no pass-through path.
+ *
+ * @param value The params to check, references already in live form
+ * @param parseInitializationParams The kind's parser
+ */
+export function validateTemplateParams(
+  value: unknown,
+  parseInitializationParams: (value: unknown) => unknown,
+): TemplateParamsValidationResult {
+  try {
+    return { value: parseInitializationParams(value) };
+  } catch (e) {
+    // A rejection is an expected outcome for a hand-written file, so it is reported,
+    // not thrown.
+    return { error: `params do not match this block's kind: ${describeRejection(e)}` };
+  }
+}
+
+/** One `{ path, message }` entry of a schema library's error. */
+type IssueLike = { path?: unknown; message?: unknown };
+
+/**
+ * Render whatever a parser threw as one readable line.
+ *
+ * An error carrying an `issues` array is unpacked rather than printed: that is the
+ * shape zod (and several others) use, and its `message` is the whole issue list as
+ * JSON — technically complete and unreadable in a dialog. Duck-typed on purpose, since
+ * this package prescribes no schema library and takes no dependency on one; anything
+ * else falls back to its own message.
+ */
+function describeRejection(e: unknown): string {
+  const issues = (e as { issues?: unknown }).issues;
+  if (!Array.isArray(issues) || issues.length === 0) return messageOf(e);
+
+  return issues
+    .map((issue) => {
+      const { path, message } = issue as IssueLike;
+      const what = typeof message === "string" ? message : "is invalid";
+      const where = Array.isArray(path) ? formatPath(path) : "";
+      return where === "" ? what : `${where}: ${what}`;
+    })
+    .join("; ");
+}
+
+/** `["numbers", 0]` → `numbers[0]` — how the params are written, not how they parse. */
+function formatPath(path: readonly unknown[]): string {
+  return path.reduce<string>((acc, segment) => {
+    if (typeof segment === "number") return `${acc}[${segment}]`;
+    return acc === "" ? String(segment) : `${acc}.${String(segment)}`;
+  }, "");
+}
+
+/**
+ * Result of the `__pl_params_validate` callback.
+ *
+ * Carries no params back. The check is a pre-flight — its answer is "may this entry be
+ * applied", and the params that actually reach the block are produced by
+ * {@link createInitialStorageFromParams}, which parses again. One authoritative
+ * producer, rather than two values that could differ.
+ */
+export type InitializationParamsValidateCallbackResult = { error: string } | { error?: undefined };
+
+/**
+ * Check params that crossed into the model VM as text.
+ *
+ * The pre-flight entry point: a caller asks this before creating anything, once per
+ * template entry, so params a kind rejects are reported while there is still no
+ * project to half-build.
+ *
+ * @param paramsJson The entry's params as JSON string
+ * @param parseInitializationParams The kind's parser
+ */
+export function validateTemplateParamsJson(
+  paramsJson: string,
+  parseInitializationParams: (value: unknown) => unknown,
+): InitializationParamsValidateCallbackResult {
+  let params: unknown;
+  try {
+    params = JSON.parse(paramsJson);
+  } catch (e) {
+    return { error: `params are not valid JSON: ${messageOf(e)}` };
+  }
+
+  const result = validateTemplateParams(params, parseInitializationParams);
+  if (result.error !== undefined) return { error: result.error };
+  return {};
+}
+
+function messageOf(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+/**
+ * Result of building initial storage from params.
+ * Returned by the `__pl_storage_initialFromParams` callback.
+ */
+export type ParamsStorageResult =
+  | { error: string }
+  | { error?: undefined; storageJson: StringifiedJson<BlockStorage> };
+
+/**
+ * Creates complete initial storage for a block being created from template params.
+ *
+ * The inverse of {@link deriveTemplateParamsFromStorage}: that projects storage
+ * into params, this builds storage from them. The params are handed to the block's
+ * init factory, whose output is versioned and wrapped exactly as
+ * {@link createInitialStorage} wraps the defaults — so a block created from a
+ * template is indistinguishable from one created in the UI and then edited.
+ *
+ * Params arrive as JSON text because this runs across the model-VM boundary, where
+ * only strings pass. Anything the factory rejects is returned as an error rather
+ * than thrown: applying a hand-written template is expected to surface bad params,
+ * and the applier reports every entry's problem in one pass.
+ *
+ * @param paramsJson - The entry's params as JSON string, with references resolved
+ * @param hooks - The block's init factory plus plugin creation
+ * @returns The storage to write, or why the params could not produce any
+ */
+export function createInitialStorageFromParams(
+  paramsJson: string,
+  hooks: ParamsStorageHooks,
+): ParamsStorageResult {
+  let params: unknown;
+  try {
+    params = JSON.parse(paramsJson);
+  } catch (e) {
+    return { error: `params are not valid JSON: ${messageOf(e)}` };
+  }
+
+  // Checked here too, not only in the caller's pre-flight pass. The pre-flight is
+  // about reporting every bad entry before anything is created; this is about the
+  // factory never being handed a value the kind rejects, whichever path got here.
+  const checked = validateTemplateParams(params, hooks.parseInitializationParams);
+  if (checked.error !== undefined) return { error: checked.error };
+
+  try {
+    return { storageJson: assembleStorage(hooks.getBlockDataFromParams(checked.value), hooks) };
+  } catch (e) {
+    return { error: `init() threw on the given params: ${messageOf(e)}` };
+  }
+}
+
 // =============================================================================
 // Args Derivation from Storage
 // =============================================================================
@@ -271,19 +459,19 @@ export type ArgsDeriveResult = { error: string } | { error?: undefined; value: u
  * This extracts data from storage and passes it to the block's args() function.
  *
  * @param storageJson - Storage as JSON string
- * @param argsFunction - The block's args derivation function
+ * @param deriveArgs - The block's args derivation function
  * @returns ArgsDeriveResult with derived args or error
  */
 export function deriveArgsFromStorage(
   storageJson: string,
-  argsFunction: (data: unknown) => unknown,
+  deriveArgs: (data: unknown) => unknown,
 ): ArgsDeriveResult {
   // Extract data from storage
   const { data } = normalizeStorage(storageJson);
 
   // Call the args function with extracted data
   try {
-    const result = argsFunction(data);
+    const result = deriveArgs(data);
     return { value: result };
   } catch (e) {
     const errorMsg = e instanceof Error ? e.message : String(e);
@@ -293,25 +481,25 @@ export function deriveArgsFromStorage(
 
 /**
  * Derives prerunArgs from storage.
- * Uses prerunArgsFunction if provided, otherwise falls back to argsFunction.
+ * Uses derivePrerunArgs if provided, otherwise falls back to deriveArgs.
  *
  * @param storageJson - Storage as JSON string
- * @param argsFunction - The block's args derivation function (fallback)
- * @param prerunArgsFunction - Optional prerun args derivation function
+ * @param deriveArgs - The block's args derivation function (fallback)
+ * @param derivePrerunArgs - Optional prerun args derivation function
  * @returns ArgsDeriveResult with derived prerunArgs or error
  */
 export function derivePrerunArgsFromStorage(
   storageJson: string,
-  argsFunction: (data: unknown) => unknown,
-  prerunArgsFunction?: (data: unknown) => unknown,
+  deriveArgs: (data: unknown) => unknown,
+  derivePrerunArgs?: (data: unknown) => unknown,
 ): ArgsDeriveResult {
   // Extract data from storage
   const { data } = normalizeStorage(storageJson);
 
   // Try prerunArgs function first if available
-  if (prerunArgsFunction) {
+  if (derivePrerunArgs) {
     try {
-      const result = prerunArgsFunction(data);
+      const result = derivePrerunArgs(data);
       return { value: result };
     } catch (e) {
       const errorMsg = e instanceof Error ? e.message : String(e);
@@ -321,7 +509,7 @@ export function derivePrerunArgsFromStorage(
 
   // Fall back to args function
   try {
-    const result = argsFunction(data);
+    const result = deriveArgs(data);
     return { value: result };
   } catch (e) {
     const errorMsg = e instanceof Error ? e.message : String(e);
@@ -329,5 +517,42 @@ export function derivePrerunArgsFromStorage(
   }
 }
 
+// =============================================================================
+// Template Entry Derivation from Storage
+// =============================================================================
+
+/**
+ * Derives this block's template-entry params from storage.
+ *
+ * The inverse of the data model's `init`: `init` turns `params` into data, this
+ * turns data back into the params that would recreate it.
+ *
+ * The lambda returns ordinary live params — references as `PlRef`s, column identifiers as
+ * they are stored — and `wrapTemplateRefs` then marks each identifier in them as a reference
+ * the template engine may redirect. That step belongs here, in the block's own bundle: it is
+ * the last place that knows the reference system, and past it nothing looks inside a wrapper
+ * again.
+ *
+ * Every block declares the lambda, so every export produces params; a block with
+ * nothing worth restoring returns `{}` rather than declining.
+ *
+ * @param storageJson - Storage as JSON string
+ * @param deriveTemplateParams - The block's templateParams lambda
+ * @returns ArgsDeriveResult holding the params with every identifier wrapped
+ */
+export function deriveTemplateParamsFromStorage<TP extends (data: unknown) => unknown>(
+  storageJson: string,
+  deriveTemplateParams: TP,
+): ArgsDeriveResult {
+  const { data } = normalizeStorage(storageJson);
+
+  try {
+    return { value: wrapTemplateRefs(deriveTemplateParams(data)) };
+  } catch (e) {
+    const errorMsg = e instanceof Error ? e.message : String(e);
+    return { error: `templateParams() threw: ${errorMsg}` };
+  }
+}
+
 // Export discriminator key and schema version for external checks
 export { BLOCK_STORAGE_KEY, BLOCK_STORAGE_SCHEMA_VERSION };
diff --git a/sdk/model/src/block_storage_facade.ts b/sdk/model/src/block_storage_facade.ts
index e8f4ae8ea9..3da218d11b 100644
--- a/sdk/model/src/block_storage_facade.ts
+++ b/sdk/model/src/block_storage_facade.ts
@@ -82,6 +82,9 @@ export const BlockStorageFacadeCallbacks = {
   ArgsDerive: "__pl_args_derive",
   PrerunArgsDerive: "__pl_prerunArgs_derive",
   StorageInitial: "__pl_storage_initial",
+  InitializationParamsDerive: "__pl_initializationParams_derive",
+  StorageInitialFromParams: "__pl_storage_initialFromParams",
+  InitializationParamsValidate: "__pl_initializationParams_validate",
 } as const;
 
 /**
@@ -189,6 +192,84 @@ export interface BlockStorageFacade {
    * @returns Initial storage as JSON string
    */
   [BlockStorageFacadeCallbacks.StorageInitial]: () => StringifiedJson;
+
+  /**
+   * Derive this block's template entry params from storage.
+   * Called when exporting the project as a template.
+   *
+   * Every V3 block declares `.templateParams()` — the model does not build without
+   * it — so every export produces params. A block whose state carries nothing worth
+   * restoring returns `{}`, which is written out and used as-is by init.
+   *
+   * The returned params carry every column identifier wrapped as a `{ $ref: … }`, which is
+   * the only structure the template engine reads — what is inside a wrapper it stores and
+   * redirects without parsing. The caller supplies everything
+   * else in the entry — `id`, `kind` — so the lambda cannot set them.
+   *
+   * @param storageJson - Storage as JSON string
+   * @returns Either an error, or the params to write
+   */
+  [BlockStorageFacadeCallbacks.InitializationParamsDerive]: (
+    storageJson: StringifiedJson,
+  ) => { error: string } | { error?: undefined; value: unknown };
+
+  /**
+   * Get initial storage JSON for a block created from params.
+   * Called when applying a template, once per entry that carries `params`.
+   *
+   * The mirror image of {@link BlockStorageFacadeCallbacks.InitializationParamsDerive}:
+   * that one turns storage into params, this one turns params into storage. Every
+   * applied entry comes through here, including one whose file omitted `params` —
+   * an omitted key is read as `{}` and checked like any other value, so no entry
+   * reaches a block without passing its kind's contract.
+   * {@link BlockStorageFacadeCallbacks.StorageInitial} stays the UI-creation path,
+   * where there are genuinely no params.
+   *
+   * Separate from `StorageInitial` rather than an optional argument to it,
+   * deliberately: a block bundled with an older SDK does not register this
+   * callback at all, so the caller sees it missing and can say so. Widening
+   * `StorageInitial` would instead have that block silently ignore the params and
+   * produce a default-initialized block that looks successfully applied.
+   *
+   * The params arrive as ordinary live params — references are `PlRef`s, already
+   * pointing at the ids the target project just assigned. Resolution happens in
+   * the engine, before this call, so a block's init factory never handles a
+   * template-local reference.
+   *
+   * Errors are returned, not thrown: a factory rejecting params it cannot use is
+   * an expected outcome for a hand-written template file, and every entry's
+   * problem is reported together.
+   *
+   * @param paramsJson - The entry's params as JSON string
+   * @returns Either an error, or the initial storage as JSON string
+   */
+  [BlockStorageFacadeCallbacks.StorageInitialFromParams]: (
+    paramsJson: StringifiedJson,
+  ) => { error: string } | { error?: undefined; storageJson: StringifiedJson };
+
+  /**
+   * Check params against this block's kind, creating nothing.
+   *
+   * Called once per entry before a template is applied, so params a kind rejects are
+   * reported against the entry that carries them while there is still no project — the
+   * same reason references and ids are checked before construction starts. Applying
+   * without this call is safe but worse: `StorageInitialFromParams` runs the same check
+   * and refuses, by which point earlier entries have already been created.
+   *
+   * A pass carries nothing back but its own absence of error: every kind declares a
+   * parser, so a pass means the params were checked against the contract, not merely
+   * that they were valid JSON.
+   *
+   * Reference ids inside the params may be placeholders at this point: the check runs
+   * before blocks exist, so what is verified is the shape of the params, not what they
+   * point at.
+   *
+   * @param paramsJson The entry's params as JSON string
+   * @returns Why the params were rejected, or nothing
+   */
+  [BlockStorageFacadeCallbacks.InitializationParamsValidate]: (
+    paramsJson: StringifiedJson,
+  ) => { error: string } | { error?: undefined };
 }
 
 /** Register all facade callbacks at once. Ensures all required callbacks are provided. */
diff --git a/sdk/model/src/kind_reference.test.ts b/sdk/model/src/kind_reference.test.ts
new file mode 100644
index 0000000000..4ae194981f
--- /dev/null
+++ b/sdk/model/src/kind_reference.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import type { BlockConfigContainer, BlockKindReference } from "@milaboratories/pl-model-common";
+import {
+  ProjectTemplateV1EntrySchema,
+  kindReferenceToSelectorReference,
+} from "@milaboratories/pl-model-common";
+import { extractConfig } from "./bconfig/normalization";
+import { BlockModelV3 } from "./block_model";
+import { DataModelBuilder } from "./block_migrations";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+
+// Template export needs one fact to hold at runtime: the kind reference a block
+// declared at build time is still readable from its config, and reaches a
+// template entry unchanged.
+//
+// No new code is needed for that read — `BlockConfigContainer.kind` is already
+// typed `BlockKindReference | undefined`, so the middle layer's read is the
+// property access `bp.info.config.kind`, and the widen to an entry's selector
+// form already exists. What did not exist is proof that the path holds end to
+// end, which is what this suite is: bake -> read -> widen -> entry, inside one
+// package, with no backend.
+
+type Params = { label: string };
+type BlockData = { label: string };
+
+const KIND_NAME = "@platforma-open/milaboratories.demo.kind";
+const KIND_VERSION = "1.4.2";
+const KIND_REF = `${KIND_NAME}@${KIND_VERSION}`;
+
+const kind = defineBlockKind<Params>({
+  name: KIND_NAME,
+  version: KIND_VERSION,
+  parseInitializationParams: (value) => value as Params,
+});
+
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(({ params }) => ({ label: params?.label ?? "" }));
+
+/**
+ * The config container `build-model` serializes into model.json.
+ *
+ * `done()` returns it whenever the model is not running in a UI — `isInUI()`
+ * checks for a `platforma` global, absent under vitest — which is exactly the
+ * path the build takes.
+ */
+function containerOf(model: unknown): BlockConfigContainer {
+  return (model as { config: BlockConfigContainer }).config;
+}
+
+const kindfulContainer = () =>
+  containerOf(
+    BlockModelV3.create({ dataModel, kind })
+      .args((data) => ({ label: data.label }))
+      .templateParams((data) => ({ label: data.label }))
+      .done(),
+  );
+
+describe("reading the kind reference back at runtime", () => {
+  test("done() bakes the declared kind at the container level", () => {
+    // Beside `code`, orthogonal to the render envelope — a future v5 envelope
+    // would not move it.
+    expect(kindfulContainer().kind).toBe(KIND_REF);
+  });
+
+  test("the NORMALIZED config does not carry it — the container is the read point", () => {
+    // extractConfig normalizes the render envelope and returns only envelope
+    // fields, so the `cfg` every getBlockPackInfo caller holds is kind-blind by
+    // construction (lib/node/pl-middle-layer/src/middle_layer/util.ts). An
+    // exporter that goes looking there finds nothing and must read
+    // `info.config.kind` instead. Pinned so that stays true, or fails loudly.
+    expect("kind" in extractConfig(kindfulContainer())).toBe(false);
+  });
+
+  test("the authoring API can no longer produce a kind-less block", () => {
+    const kindlessDataModel = new DataModelBuilder().from<BlockData>("v1").init(() => ({
+      label: "",
+    }));
+
+    // The kind-less `create(dataModel)` overload is gone: a kind is mandatory, so there
+    // is no longer a way to author a block whose container carries no kind reference.
+    // @ts-expect-error - create takes { dataModel, kind }; a bare DataModel is not it
+    expect(() => BlockModelV3.create(kindlessDataModel)).toThrow();
+  });
+
+  test("the READ side stays optional — already-published blocks carry no kind", () => {
+    // `BlockConfigContainer.kind` is `BlockKindReference | undefined` and must stay that
+    // way: every block published before kinds existed is in that state, and the middle
+    // layer reads those configs. What the exporter should DO with such a block is
+    // decided — a template entry's `kind` is required, so there is no legal entry to
+    // write and the export fails naming the block (`template_serializer.ts`).
+    const container = kindfulContainer();
+
+    expect(container.kind).toBe(KIND_REF);
+    expectTypeOf(container.kind).toEqualTypeOf<BlockKindReference | undefined>();
+  });
+});
+
+describe("the reference as a template entry's kind", () => {
+  test("it widens to the exact tier, string unchanged", () => {
+    // An entry's kind is the exact version the block implements, `{name}@X.Y.Z`,
+    // read from the model's embedded kind reference. Widening changes the brand,
+    // not the string — export never loosens to a `~` or `^` tier.
+    expect(kindReferenceToSelectorReference(kindfulContainer().kind!)).toBe(KIND_REF);
+  });
+
+  test("the org-scoped name survives the split", () => {
+    // The kind name itself starts with `@`, so splitting on the FIRST `@` would
+    // truncate it to the empty name. block_kind_ref.ts owns that rule by
+    // splitting on the last `@`; this pins that a reference a real block
+    // declares round-trips through it intact.
+    const widened = kindReferenceToSelectorReference(kindfulContainer().kind!);
+    expect(widened.startsWith("@platforma-open/")).toBe(true);
+  });
+
+  test("the widened reference is accepted as a template-v1 entry's kind", () => {
+    const blockId = "3f1c2b7a-0000-4000-8000-000000000001";
+
+    const entry = ProjectTemplateV1EntrySchema.parse({
+      id: blockId,
+      kind: kindReferenceToSelectorReference(kindfulContainer().kind!),
+    });
+
+    // The whole path, end to end: what the block declared is what the file
+    // carries. `id` is the block's project-local UUID, reused verbatim, and `params` is the
+    // empty mapping the parser settles an omitted key to.
+    expect(entry).toEqual({ id: blockId, kind: KIND_REF, params: {} });
+
+    // No `block` override: a block implements exactly one kind version, so
+    // export has nothing to pin.
+    expect(entry.block).toBeUndefined();
+  });
+});
diff --git a/sdk/model/src/template_init.test.ts b/sdk/model/src/template_init.test.ts
new file mode 100644
index 0000000000..72fb9d1432
--- /dev/null
+++ b/sdk/model/src/template_init.test.ts
@@ -0,0 +1,342 @@
+import { describe, expect, test } from "vitest";
+import type { PlRef } from "@milaboratories/pl-model-common";
+import { createPlRef, stringifyJson } from "@milaboratories/pl-model-common";
+import type { PluginHandle } from "./plugin_handle";
+import type { PluginName } from "./block_storage";
+import { BLOCK_STORAGE_KEY, createBlockStorage, isBlockStorage } from "./block_storage";
+import {
+  createInitialStorage,
+  createInitialStorageFromParams,
+  deriveTemplateParamsFromStorage,
+  validateTemplateParams,
+  validateTemplateParamsJson,
+} from "./block_storage_callbacks";
+import { DataModelBuilder } from "./block_migrations";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+
+/**
+ * The apply half of the template contract: params in, storage out.
+ *
+ * `template_params.test.ts` covers the export direction. These cover the inverse,
+ * plus the one property that ties the two together — params that survive a round
+ * trip through storage.
+ */
+
+type Params = { sources?: PlRef[]; label: string };
+
+/**
+ * Deliberately permissive: these tests are about what the apply path does with params
+ * the kind already accepted, so the parser here only carries the shape through. The
+ * rejection behaviour is covered by the `validateTemplateParams` cases below, which
+ * supply their own strict parsers.
+ */
+const passThrough = (value: unknown) => value as Params;
+
+const kind = defineBlockKind<Params>({
+  name: "@platforma-open/milaboratories.demo.kind",
+  version: "1.0.0",
+  parseInitializationParams: passThrough,
+});
+
+type BlockData = { sources: PlRef[]; label: string; scratch: number };
+
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(({ params }) => ({
+  sources: params?.sources ?? [],
+  label: params?.label ?? "",
+  scratch: 0,
+}));
+
+const upstream = "3f1c2b7a-0000-4000-8000-000000000001";
+
+/** Hooks for a block with no plugins — the common case. */
+const noPlugins = {
+  getPluginRegistry: () => ({}),
+  createPluginData: () => {
+    throw new Error("no plugins registered");
+  },
+};
+
+const fromParams = (params: unknown) =>
+  createInitialStorageFromParams(JSON.stringify(params), {
+    getBlockDataFromParams: (p) => dataModel.getDataFromParams(p),
+    parseInitializationParams: passThrough,
+    ...noPlugins,
+  });
+
+/** Storage the callback produced, parsed back. Fails the test if it errored. */
+function storageOf(result: ReturnType<typeof fromParams>) {
+  if (result.error !== undefined) throw new Error(`expected storage, got: ${result.error}`);
+  return JSON.parse(result.storageJson) as Record<string, unknown>;
+}
+
+describe("createInitialStorageFromParams", () => {
+  test("the block's init factory receives the entry's params", () => {
+    const storage = storageOf(fromParams({ label: "run 1" }));
+
+    expect(storage.__data).toEqual({ sources: [], label: "run 1", scratch: 0 });
+  });
+
+  test("references arrive as PlRefs and land in data untouched", () => {
+    // The engine resolves template-local references before this point, so what the
+    // factory sees is an ordinary live reference to a block that already exists.
+    const ref = createPlRef(upstream, "reads");
+    const storage = storageOf(fromParams({ label: "wired", sources: [ref] }));
+
+    expect((storage.__data as BlockData).sources).toEqual([ref]);
+  });
+
+  test("the result is well-formed storage at the current data version", () => {
+    const storage = storageOf(fromParams({ label: "x" }));
+
+    expect(isBlockStorage(storage)).toBe(true);
+    expect(storage[BLOCK_STORAGE_KEY]).toBeDefined();
+    expect(storage.__dataVersion).toBe(dataModel.version);
+  });
+
+  test("a block created from params is shaped exactly like one created from defaults", () => {
+    // Same envelope, only `__data` differs — which is what lets an applied block be
+    // read, migrated and edited by every path that never heard of templates.
+    const fromDefaults = JSON.parse(
+      createInitialStorage({
+        getDefaultBlockData: () => dataModel.getDefaultData(),
+        getPluginRegistry: noPlugins.getPluginRegistry,
+        createPluginData: noPlugins.createPluginData,
+      }),
+    ) as Record<string, unknown>;
+    const applied = storageOf(fromParams({ label: "x" }));
+
+    expect(Object.keys(applied).sort()).toEqual(Object.keys(fromDefaults).sort());
+    expect({ ...applied, __data: null }).toEqual({ ...fromDefaults, __data: null });
+  });
+
+  test("empty params are used as-is, not treated as absent", () => {
+    // An entry with `params: {}` says "initialize from nothing in particular";
+    // the factory's own fallbacks fill in, and the applier never substitutes
+    // defaults on the block's behalf.
+    expect(storageOf(fromParams({})).__data).toEqual({ sources: [], label: "", scratch: 0 });
+  });
+
+  test("params that are not valid JSON are reported", () => {
+    const result = createInitialStorageFromParams("{not json", {
+      getBlockDataFromParams: (p) => dataModel.getDataFromParams(p),
+      parseInitializationParams: passThrough,
+      ...noPlugins,
+    });
+
+    expect(result.error).toMatch(/params are not valid JSON/);
+  });
+
+  test("a factory that rejects the params is reported, not propagated", () => {
+    // The expected failure mode for a hand-written template file: params the block
+    // cannot make sense of. It must come back as a problem the applier can attach
+    // to an entry, not as a throw that aborts the whole apply.
+    const result = createInitialStorageFromParams(JSON.stringify({ label: "" }), {
+      getBlockDataFromParams: () => {
+        throw new Error("label must not be empty");
+      },
+      parseInitializationParams: passThrough,
+      ...noPlugins,
+    });
+
+    expect(result).toEqual({ error: "init() threw on the given params: label must not be empty" });
+  });
+
+  test("plugins are created at their defaults, never from params", () => {
+    // Params belong to the block's kind; a plugin has no params channel, so it is
+    // initialized the same way whether the block came from a template or the UI.
+    const handle = "p1" as PluginHandle;
+    const result = createInitialStorageFromParams(JSON.stringify({ label: "x" }), {
+      getBlockDataFromParams: (p) => dataModel.getDataFromParams(p),
+      parseInitializationParams: passThrough,
+      getPluginRegistry: () => ({ [handle]: "demoPlugin" as PluginName }),
+      createPluginData: (h) => {
+        expect(h).toBe(handle);
+        return { version: "v1", data: { items: [] } };
+      },
+    });
+
+    expect(storageOf(result).__plugins).toEqual({
+      [handle]: { __dataVersion: "v1", __data: { items: [] } },
+    });
+  });
+});
+
+describe("DataModel.getDataFromParams", () => {
+  test("a factory that ignores params matches getDefaultData", () => {
+    const paramless = new DataModelBuilder().from<{ n: number }>("v1").init(() => ({ n: 7 }));
+
+    expect(paramless.getDataFromParams({ n: 99 })).toEqual(paramless.getDefaultData());
+  });
+
+  test("undefined params are what a factory sees from getDefaultData", () => {
+    // The two entry points must not diverge on the "no params" case: an entry
+    // without params goes through StorageInitial, and a factory written against
+    // `params?.x ?? default` has to behave identically either way.
+    expect(dataModel.getDataFromParams(undefined)).toEqual(dataModel.getDefaultData());
+  });
+});
+
+describe("params round trip", () => {
+  test("init then templateParams returns the params it started from", () => {
+    // The closest thing to an export→import round trip available without the
+    // engine: params → storage → params. References come back in template form,
+    // since that is what the export side writes to the file.
+    const params = { label: "run 1", sources: [createPlRef(upstream, "reads")] };
+
+    const storageJson = stringifyJson(
+      createBlockStorage(storageOf(fromParams(params)).__data as BlockData),
+    );
+    const derived = deriveTemplateParamsFromStorage(storageJson, (data) => {
+      const d = data as BlockData;
+      return { sources: d.sources, label: d.label };
+    });
+
+    expect(derived).toEqual({
+      value: { label: "run 1", sources: [{ $ref: createPlRef(upstream, "reads") }] },
+    });
+  });
+});
+
+describe("validateTemplateParams", () => {
+  test("the parser's output is what flows on, not its input", () => {
+    // This is what makes a schema able to strip keys the kind does not declare, which
+    // is the difference between a typo being ignored and a typo being caught.
+    const result = validateTemplateParams({ label: "x", stray: 1 }, () => ({ label: "x" }));
+
+    expect(result).toEqual({ value: { label: "x" } });
+  });
+
+  test("there is no unchecked pass", () => {
+    // Every kind declares a parser, so the result carries no "was this checked" flag:
+    // a pass means the params were held to the contract. A parser is the only way a
+    // value gets through, and one that rejects everything is still a parser.
+    expect(
+      validateTemplateParams({ anything: true }, () => {
+        throw new Error("this kind takes no params");
+      }).error,
+    ).toMatch(/do not match this block's kind/);
+  });
+});
+
+describe("params reaching init", () => {
+  test("init sees what the parser returned", () => {
+    const storage = storageOf(
+      createInitialStorageFromParams(JSON.stringify({ label: "raw", stray: 1 }), {
+        getBlockDataFromParams: (p) => dataModel.getDataFromParams(p),
+        parseInitializationParams: () => ({ label: "parsed" }),
+        ...noPlugins,
+      }),
+    );
+
+    expect((storage.__data as BlockData).label).toBe("parsed");
+  });
+
+  test("params the kind rejects never reach init", () => {
+    // Checked here as well as in the caller's pre-flight: the pre-flight exists to
+    // report every bad entry before anything is created, this exists so the factory is
+    // never handed a value the kind refused, whichever path got here.
+    let reached = false;
+    const result = createInitialStorageFromParams(JSON.stringify({ label: "" }), {
+      getBlockDataFromParams: (p) => {
+        reached = true;
+        return dataModel.getDataFromParams(p);
+      },
+      parseInitializationParams: () => {
+        throw new Error("label must not be empty");
+      },
+      ...noPlugins,
+    });
+
+    expect(reached).toBe(false);
+    expect(result.error).toMatch(/do not match this block's kind/);
+  });
+});
+
+describe("validateTemplateParamsJson", () => {
+  test("valid params against a real schema", () => {
+    expect(validateTemplateParamsJson(JSON.stringify({ n: 1 }), (v) => v)).toEqual({});
+  });
+
+  test("a rejection comes back as a message, not a throw", () => {
+    const result = validateTemplateParamsJson(JSON.stringify({}), () => {
+      throw new Error("n: Required");
+    });
+
+    expect(result.error).toContain("n: Required");
+  });
+
+  test("params that are not JSON are reported", () => {
+    expect(validateTemplateParamsJson("{oops", (v) => v).error).toMatch(/not valid JSON/);
+  });
+});
+
+describe("the kind carries the check", () => {
+  test("a kind's parser reaches the data model that declared it", () => {
+    // The threading that makes any of this work: the kind object is not kept, but the
+    // parser is lifted off it beside the kind reference, so `done()` can register it.
+    const parse = (v: unknown) => v as Params;
+    const checkedKind = defineBlockKind<Params>({
+      name: "@platforma-open/milaboratories.checked.kind",
+      version: "1.0.0",
+      parseInitializationParams: parse,
+    });
+    const model = new DataModelBuilder({ kind: checkedKind })
+      .from<BlockData>("v1")
+      .init(() => ({ sources: [], label: "", scratch: 0 }));
+
+    expect(model.templateParamsParser).toBe(parse);
+  });
+
+  test("a kind-less data model carries no parser — the plugin case", () => {
+    // The only remaining way this slot is empty. A BLOCK data model always has a kind,
+    // and a kind always supplies a parser; a PLUGIN data model is built with no kind at
+    // all, because a plugin has no params channel of its own. Such a model can no longer
+    // reach `BlockModelV3.create`, so nothing reads this as a block's parser.
+    const pluginDataModel = new DataModelBuilder()
+      .from<BlockData>("v1")
+      .init(() => ({ sources: [], label: "", scratch: 0 }));
+
+    expect(pluginDataModel.templateParamsParser).toBeUndefined();
+  });
+});
+
+describe("how a rejection reads", () => {
+  test("a schema library's issue list is unpacked, not dumped as JSON", () => {
+    // A zod error's own `message` is the entire issue array as JSON. Complete, and
+    // unreadable in the dialog this ends up in. The shape is duck-typed because this
+    // package prescribes no schema library.
+    const zodLike = Object.assign(new Error("[{...}]"), {
+      issues: [
+        { code: "invalid_type", path: ["numbers", 0], message: "Expected number, received string" },
+        { code: "unrecognized_keys", path: [], message: "Unrecognized key(s) in object: 'colour'" },
+      ],
+    });
+
+    const result = validateTemplateParams({}, () => {
+      throw zodLike;
+    });
+
+    expect(result.error).toBe(
+      "params do not match this block's kind: numbers[0]: Expected number, received string; " +
+        "Unrecognized key(s) in object: 'colour'",
+    );
+  });
+
+  test("a path is written the way the params are written", () => {
+    const result = validateTemplateParams({}, () => {
+      throw Object.assign(new Error("x"), {
+        issues: [{ path: ["steps", 2, "name"], message: "Required" }],
+      });
+    });
+
+    expect(result.error).toContain("steps[2].name: Required");
+  });
+
+  test("a plain error keeps its own words", () => {
+    const result = validateTemplateParams({}, () => {
+      throw new Error("numbers must not be empty");
+    });
+
+    expect(result.error).toBe("params do not match this block's kind: numbers must not be empty");
+  });
+});
diff --git a/sdk/model/src/template_params.test.ts b/sdk/model/src/template_params.test.ts
new file mode 100644
index 0000000000..651f835fe1
--- /dev/null
+++ b/sdk/model/src/template_params.test.ts
@@ -0,0 +1,134 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import type { PlRef } from "@milaboratories/pl-model-common";
+import { createPlRef, stringifyJson } from "@milaboratories/pl-model-common";
+import { createBlockStorage } from "./block_storage";
+import { deriveTemplateParamsFromStorage } from "./block_storage_callbacks";
+import { BlockModelV3 } from "./block_model";
+import { DataModelBuilder } from "./block_migrations";
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+
+// A kind whose params carry a reference — the case that exercises the rewrite.
+type Params = { sources?: PlRef[]; label: string };
+
+const kind = defineBlockKind<Params>({
+  name: "@platforma-open/milaboratories.demo.kind",
+  version: "1.0.0",
+  // These tests are about the export direction, so the parser only carries the shape
+  // through; rejection behaviour lives in `template_init.test.ts`.
+  parseInitializationParams: (value) => value as Params,
+});
+
+type BlockData = { sources: PlRef[]; label: string; scratch: number };
+
+const dataModel = new DataModelBuilder({ kind }).from<BlockData>("v1").init(({ params }) => ({
+  sources: params?.sources ?? [],
+  label: params?.label ?? "",
+  // Derived/runtime state — must NOT survive into a template entry.
+  scratch: 0,
+}));
+
+const upstream = "3f1c2b7a-0000-4000-8000-000000000001";
+
+const storageOf = (data: BlockData) => stringifyJson(createBlockStorage(data));
+
+describe("deriveTemplateParamsFromStorage", () => {
+  test("projects data back to params, with each reference marked", () => {
+    const result = deriveTemplateParamsFromStorage(
+      storageOf({ sources: [createPlRef(upstream, "reads")], label: "run 1", scratch: 42 }),
+      (data) => {
+        const d = data as BlockData;
+        return { sources: d.sources, label: d.label };
+      },
+    );
+
+    // `scratch` is dropped because the lambda does not return it; the `PlRef` was wrapped
+    // without the lambda doing anything, which is the point — marking references is the
+    // SDK's job, not a block author's.
+    expect(result).toEqual({
+      value: { sources: [{ $ref: createPlRef(upstream, "reads") }], label: "run 1" },
+    });
+  });
+
+  test("a block with nothing to project yields empty params, not absent ones", () => {
+    // Every block declares the lambda, so there is no "no params" outcome to test for.
+    // A block whose state carries nothing worth restoring returns `{}`, and `{}` is what
+    // gets written — the entry is still checked against the kind on the way back in.
+    expect(
+      deriveTemplateParamsFromStorage(
+        storageOf({ sources: [], label: "", scratch: 0 }),
+        () => ({}),
+      ),
+    ).toEqual({ value: {} });
+  });
+
+  test("a throwing lambda is reported, not propagated", () => {
+    const result = deriveTemplateParamsFromStorage(
+      storageOf({ sources: [], label: "", scratch: 0 }),
+      () => {
+        throw new Error("not exportable yet");
+      },
+    );
+
+    expect(result).toEqual({ error: "templateParams() threw: not exportable yet" });
+  });
+});
+
+describe("BlockModelV3.templateParams", () => {
+  test("the lambda's return type is the kind's params", () => {
+    const model = BlockModelV3.create({ dataModel, kind })
+      .args((data) => ({ label: data.label }))
+      .templateParams((data) => ({ sources: data.sources, label: data.label }));
+
+    expectTypeOf(model.templateParams).parameter(0).toEqualTypeOf<(data: BlockData) => Params>();
+  });
+
+  test("a projection that drifts from the kind's params does not compile", () => {
+    const builder = BlockModelV3.create({ dataModel, kind }).args((data) => ({
+      label: data.label,
+    }));
+
+    // @ts-expect-error - `label` is required by Params
+    builder.templateParams((data) => ({ sources: data.sources }));
+    // @ts-expect-error - wrong type for a declared param
+    builder.templateParams(() => ({ label: 42 }));
+  });
+
+  test("KNOWN HOLE: an extra field the kind does not declare is not rejected", () => {
+    const builder = BlockModelV3.create({ dataModel, kind }).args((data) => ({
+      label: data.label,
+    }));
+
+    // No `@ts-expect-error` here, and that is the point: TypeScript does not
+    // apply excess-property checks to an object literal returned from a
+    // contextually-typed arrow, so `scratch` type-checks and would be written
+    // into the exported file. The kind's parser does not catch it either — that runs
+    // on params coming IN, and nothing runs on what the projection hands back. The
+    // asymmetry is real: such a file is written happily and rejected on re-import by
+    // the same kind that would have caught it here. This test pins current behaviour.
+    builder.templateParams((data) => ({
+      label: data.label,
+      sources: data.sources,
+      scratch: data.scratch,
+    }));
+  });
+
+  test("a model that declares it builds", () => {
+    expect(() =>
+      BlockModelV3.create({ dataModel, kind })
+        .args((data) => ({ label: data.label }))
+        .templateParams((data) => ({ sources: data.sources, label: data.label }))
+        .done(),
+    ).not.toThrow();
+  });
+
+  test("a model that omits it does not build", () => {
+    // The projection is not optional. Without this gate a block exports an entry with
+    // no params, which applies as a default-initialized block that looks restored — so
+    // the failure has to land on whoever wrote the model, at build.
+    expect(() =>
+      BlockModelV3.create({ dataModel, kind })
+        .args((data) => ({ label: data.label }))
+        .done(),
+    ).toThrow(/templateParams\(\) not set/);
+  });
+});
diff --git a/tests/block-repo/package.json b/tests/block-repo/package.json
index 313d522ee6..a925bef979 100644
--- a/tests/block-repo/package.json
+++ b/tests/block-repo/package.json
@@ -9,7 +9,9 @@
   },
   "devDependencies": {
     "@milaboratories/build-configs": "workspace:*",
+    "@milaboratories/milaboratories.test-block-table": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers": "workspace:*",
+    "@milaboratories/pl-model-common": "workspace:*",
     "@milaboratories/pl-model-middle-layer": "workspace:*",
     "@milaboratories/ts-builder": "workspace:*",
     "@milaboratories/ts-configs": "workspace:*",
diff --git a/tests/block-repo/src/kind-lifecycle.test.ts b/tests/block-repo/src/kind-lifecycle.test.ts
new file mode 100644
index 0000000000..b23c9c1ebf
--- /dev/null
+++ b/tests/block-repo/src/kind-lifecycle.test.ts
@@ -0,0 +1,93 @@
+import {
+  BlockRegistryV2,
+  storageByUrl,
+  publishBlock,
+  readFacadeKindDependency,
+  resolveFacadeKind,
+  resolveKind,
+  KindOverview,
+  kindOverviewPath,
+  npmNameToKindPath,
+} from "@platforma-sdk/block-tools";
+import { BlockPackManifest, StableChannel } from "@milaboratories/pl-model-middle-layer";
+import { BlockPointer } from "@milaboratories/milaboratories.test-block-table";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { regTest } from "./test_utils";
+
+/**
+ * L1 lifecycle test (design `01-kind-and-lifecycle.md` → Testing strategy,
+ * step 4): the whole kind loop — build → publish (kind-first) → reconcile →
+ * resolve — headless on a `file:` registry (FSStorage), no CI, no AWS. Modeled
+ * on `simple.test.ts`. The block is `etc/blocks/table-test`, built and packed by
+ * the turbo dependency graph before this test runs.
+ */
+regTest(
+  "kind lifecycle: publish (kind-first) -> reconcile -> resolve on a file: registry",
+  async ({ expect, tmpFolder }) => {
+    const registryUrl = `file:${tmpFolder}`;
+    const storage = storageByUrl(registryUrl);
+    const registry = new BlockRegistryV2(storage);
+
+    // Locate the built block through its BlockPointer: packUrl -> block-pack
+    // (manifest + file reader root), rootUrl -> facade package root (holds the
+    // package.json with the direct kind dependency).
+    const packDir = fileURLToPath(BlockPointer.packUrl);
+    const facadeDir = fileURLToPath(BlockPointer.rootUrl);
+    const manifest = BlockPackManifest.parse(
+      JSON.parse(await fsp.readFile(path.join(packDir, "manifest.json"), { encoding: "utf-8" })),
+    );
+
+    // The block declares a kind, and it resolves to concrete artifacts.
+    const facadeDep = readFacadeKindDependency(facadeDir);
+    expect(facadeDep).toBeDefined();
+    const kindNpmName = facadeDep!.npmName;
+    const resolvedKind = await resolveFacadeKind(facadeDir, kindNpmName);
+    const kindVersion = resolvedKind.manifest.kind.version;
+
+    // --- Publish, kind-first: version-match gate -> publishKind -> publishPackage.
+    await publishBlock(registry, manifest, facadeDir, async (file) =>
+      Buffer.from(await fsp.readFile(path.resolve(packDir, file))),
+    );
+    await registry.addPackageToChannel(manifest.description.id, StableChannel);
+    await registry.updateIfNeeded();
+
+    // --- Reconcile produced the per-kind overview projection (single pass, no
+    // separate kind reconciler).
+    const overviewPath = kindOverviewPath(npmNameToKindPath(kindNpmName));
+    const overviewRaw = await storage.getFile(overviewPath);
+    expect(overviewRaw, `kind overview missing at ${overviewPath}`).toBeDefined();
+    const overview = KindOverview.parse(JSON.parse(overviewRaw!.toString()));
+    expect(overview.implementers).toHaveLength(1);
+    expect(overview.implementers[0].id).toStrictEqual(manifest.description.id);
+    expect(overview.implementers[0].channels).toStrictEqual([StableChannel]);
+
+    // --- Resolution: exact / minor-float / patch-float all pick the stable block.
+    for (const selector of [kindVersion, `^${kindVersion}`, `~${kindVersion}`]) {
+      const r = resolveKind(overview, selector, { allowUnstable: false });
+      expect(r, `selector ${selector}`).toStrictEqual({
+        ok: true,
+        blockId: manifest.description.id,
+        channel: StableChannel,
+      });
+    }
+
+    // A selector matching no kind version fails cleanly.
+    expect(resolveKind(overview, "99.0.0", { allowUnstable: false })).toStrictEqual({
+      ok: false,
+      reason: "no-matching-kind-version",
+    });
+
+    // --- Source-hash immutability guard + idempotent republish.
+    // Identical content -> idempotent no-op (must not throw).
+    await registry.publishKind(resolvedKind.manifest, resolvedKind.fileReader);
+    // Same version, different source content -> hard fail.
+    await expect(
+      registry.publishKind(
+        { ...resolvedKind.manifest, sourceHash: "0".repeat(64) },
+        resolvedKind.fileReader,
+      ),
+    ).rejects.toThrow(/different content/i);
+  },
+);
diff --git a/tests/block-repo/src/kind-publication.test.ts b/tests/block-repo/src/kind-publication.test.ts
new file mode 100644
index 0000000000..247acd3d26
--- /dev/null
+++ b/tests/block-repo/src/kind-publication.test.ts
@@ -0,0 +1,209 @@
+import {
+  BlockRegistryV2,
+  KindManifest,
+  KindOverview,
+  RegistryV2Reader,
+  folderReaderByUrl,
+  kindContentPrefix,
+  kindOverviewPath,
+  npmNameToKindPath,
+  publishBlock,
+  readFacadeKindDependency,
+  resolveFacadeKind,
+  storageByUrl,
+} from "@platforma-sdk/block-tools";
+import {
+  AnyChannel,
+  BlockPackManifest,
+  overrideManifestVersion,
+  StableChannel,
+} from "@milaboratories/pl-model-middle-layer";
+import { formatKindRef } from "@milaboratories/pl-model-common";
+import { BlockPointer } from "@milaboratories/milaboratories.test-block-table";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { regTest } from "./test_utils";
+
+/**
+ * Publishing a kind, on the same axes block publishing is covered on.
+ *
+ * `simple.test.ts` takes a real built block through publish → reconcile → channel
+ * add → read back → channel remove → read back, at two versions, and asserts what
+ * landed in the registry each time. This is that test for the `kinds/` tree, and it
+ * exists because the kind side had a different shape of coverage: `kind-lifecycle.test.ts`
+ * proves the immutability guard and the selector tiers on **one** kind version with
+ * **one** implementer in **one** channel, reading the projection straight out of
+ * storage rather than through the reader the middle layer actually calls.
+ *
+ * What is added here, in the order the test does it:
+ *
+ *   - the exact set of files a kind publish writes under its version folder;
+ *   - the projection as a **derived** view — `implementers` and `kindVersions` — not
+ *     just its existence;
+ *   - resolution through `RegistryV2Reader.resolveKind`, the entry point the middle
+ *     layer uses, rather than the pure resolver underneath it;
+ *   - a **second kind version with its own implementing block**, which is what makes
+ *     the selector tiers mean anything: with one version on the registry every
+ *     selector picks the same block whether or not the ranges are right;
+ *   - a channel change after the fact, proving the projection is re-derived rather
+ *     than written once at publish time.
+ *
+ * Headless on a `file:` registry, like the tests it mirrors — no backend, no AWS.
+ * The block is `etc/blocks/table-test`, built and packed by the turbo graph before
+ * this runs.
+ */
+regTest(
+  "kind publication: publish -> reconcile -> resolve, across two kind versions and a channel change",
+  async ({ expect, tmpFolder }) => {
+    const registryUrl = `file:${tmpFolder}`;
+    const storage = storageByUrl(registryUrl);
+    const registry = new BlockRegistryV2(storage);
+
+    const packDir = fileURLToPath(BlockPointer.packUrl);
+    const facadeDir = fileURLToPath(BlockPointer.rootUrl);
+    const readPackFile = async (file: string) =>
+      Buffer.from(await fsp.readFile(path.resolve(packDir, file)));
+
+    const manifestV1 = BlockPackManifest.parse(
+      JSON.parse(await fsp.readFile(path.join(packDir, "manifest.json"), { encoding: "utf-8" })),
+    );
+    const blockV1 = manifestV1.description.id;
+
+    const facadeDep = readFacadeKindDependency(facadeDir);
+    expect(facadeDep).toBeDefined();
+    const resolvedKind = await resolveFacadeKind(facadeDir, facadeDep!.npmName);
+    const kindName = resolvedKind.manifest.kind.name;
+    const kindV1 = resolvedKind.manifest.kind.version;
+    const kindLoc = npmNameToKindPath(kindName);
+
+    // --- Publish the first version, through the real entry point ------------
+
+    await publishBlock(registry, manifestV1, facadeDir, readPackFile);
+    await registry.addPackageToChannel(blockV1, StableChannel);
+    await registry.updateIfNeeded();
+
+    // Every file the manifest declares, plus the manifest itself as the commit
+    // marker — and nothing else. The block side asserts its content folder the same
+    // way; without it a publish that silently dropped an artifact would still pass
+    // every resolution assertion below, because resolution only reads the projection.
+    const contentFiles = await storage.listFiles(`${kindContentPrefix(kindName, kindV1)}/`);
+    expect(contentFiles.sort()).toStrictEqual(
+      [...resolvedKind.manifest.files.map((f) => f.name), "manifest.json"].sort(),
+    );
+
+    // The stored manifest is the built one plus the registry's own upload stamp.
+    const storedManifest = KindManifest.parse(
+      JSON.parse(
+        (await storage.getFile(`${kindContentPrefix(kindName, kindV1)}/manifest.json`))!.toString(),
+      ),
+    );
+    expect(storedManifest.sourceHash).toStrictEqual(resolvedKind.manifest.sourceHash);
+    expect(storedManifest.firstUploadTimestamp).toBeDefined();
+
+    // The projection, both halves: the flat implementer list the reconciler rewrites,
+    // and the per-kind-version view a reader resolves against.
+    const afterV1 = await readProjection();
+    expect(afterV1.implementers).toStrictEqual([
+      { id: blockV1, kindVersion: kindV1, channels: [StableChannel] },
+    ]);
+    expect(afterV1.kindVersions).toHaveLength(1);
+    expect(afterV1.kindVersions[0].kindVersion).toStrictEqual(kindV1);
+    expect(afterV1.kindVersions[0].latestByChannel[StableChannel]).toStrictEqual(blockV1);
+    expect(afterV1.kindVersions[0].latestByChannel[AnyChannel]).toStrictEqual(blockV1);
+
+    // Resolution through the reader the middle layer calls, not the resolver beneath it.
+    const reader = new RegistryV2Reader(folderReaderByUrl(registryUrl));
+    expect(await resolve(kindV1)).toMatchObject({
+      type: "from-registry-v2",
+      id: blockV1,
+      channel: StableChannel,
+    });
+
+    // --- A second kind version, with its own implementing block ------------
+
+    // Same content at a new version: the immutability guard is per version, and what
+    // is under test here is the version axis, not the bytes.
+    const kindV2 = "1.1.0";
+    await registry.publishKind(
+      { ...resolvedKind.manifest, kind: { ...resolvedKind.manifest.kind, version: kindV2 } },
+      resolvedKind.fileReader,
+    );
+
+    // The block that implements it. Published at the primitive level rather than
+    // through `publishBlock`, because that gate compares the model's compiled kind
+    // reference against the facade's — and this block was built against `kindV1`.
+    // What the projection reads is the stored manifest's `kind`, which is what this
+    // patches.
+    const bumped = overrideManifestVersion(manifestV1, bumpPatch(blockV1.version));
+    const manifestV2 = BlockPackManifest.parse({
+      ...bumped,
+      description: {
+        ...bumped.description,
+        kind: formatKindRef({ name: kindName, version: kindV2 }),
+      },
+    });
+    const blockV2 = manifestV2.description.id;
+
+    await registry.publishPackage(manifestV2, readPackFile);
+    await registry.addPackageToChannel(blockV2, StableChannel);
+    await registry.updateIfNeeded();
+
+    const afterV2 = await readProjection();
+    expect(afterV2.implementers).toStrictEqual([
+      { id: blockV1, kindVersion: kindV1, channels: [StableChannel] },
+      { id: blockV2, kindVersion: kindV2, channels: [StableChannel] },
+    ]);
+    expect(afterV2.kindVersions.map((v) => v.kindVersion).sort()).toStrictEqual([kindV1, kindV2]);
+
+    // The tiers, now that there is something for them to choose between. Exact and
+    // patch-floor stay on the kind version whose behavior the params were written
+    // against; the minor floor moves to the newer one.
+    expect(await resolve(kindV1)).toMatchObject({ id: blockV1 });
+    expect(await resolve(`~${kindV1}`)).toMatchObject({ id: blockV1 });
+    expect(await resolve(`^${kindV1}`)).toMatchObject({ id: blockV2 });
+
+    // --- A channel change after the fact ----------------------------------
+
+    // The projection is derived from block manifests and channel membership on every
+    // reconcile, so taking the newer implementation out of `stable` has to change what
+    // a floating selector resolves to — nothing republished the kind.
+    await registry.removePackageFromChannel(blockV2, StableChannel);
+    await registry.updateIfNeeded();
+
+    const afterUnstable = await readProjection();
+    expect(
+      afterUnstable.implementers.find((i) => i.id.version === blockV2.version)?.channels,
+    ).toStrictEqual([]);
+
+    // The kind version still matches; what is missing is a stable block implementing
+    // it. Those are different failures and the reader keeps them apart.
+    await expect(resolve(`^${kindV1}`)).rejects.toThrow(/no-stable-implementation/);
+    expect(await resolve(`^${kindV1}`, { allowUnstable: true })).toMatchObject({ id: blockV2 });
+
+    // And the frozen selector is untouched by any of it.
+    expect(await resolve(`~${kindV1}`)).toMatchObject({ id: blockV1, channel: StableChannel });
+
+    // A selector matching no published kind version is a different failure again.
+    await expect(resolve("99.0.0")).rejects.toThrow(/no-matching-kind-version/);
+
+    async function readProjection(): Promise<KindOverview> {
+      const raw = await storage.getFile(kindOverviewPath(kindLoc));
+      expect(raw, `kind overview missing at ${kindOverviewPath(kindLoc)}`).toBeDefined();
+      return KindOverview.parse(JSON.parse(raw!.toString()));
+    }
+
+    async function resolve(selector: string, options?: { allowUnstable: boolean }) {
+      return await reader.resolveKind(`${kindName}@${selector}` as never, {
+        allowUnstable: options?.allowUnstable ?? false,
+      });
+    }
+  },
+);
+
+/** Next patch version, for publishing a second version of the same package. */
+function bumpPatch(version: string): string {
+  const parts = version.split(".");
+  if (parts.length !== 3) throw new Error(`Malformed version: ${version}`);
+  return `${parts[0]}.${parts[1]}.${Number(parts[2]) + 1}`;
+}
diff --git a/tests/drivers-ml-blocks-integration/package.json b/tests/drivers-ml-blocks-integration/package.json
index 93b8ca5c55..20c9cc92f4 100644
--- a/tests/drivers-ml-blocks-integration/package.json
+++ b/tests/drivers-ml-blocks-integration/package.json
@@ -18,12 +18,10 @@
     "@milaboratories/milaboratories.test-download-file": "workspace:*",
     "@milaboratories/milaboratories.test-download-file.model": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers": "workspace:*",
-    "@milaboratories/milaboratories.test-enter-numbers-v3": "workspace:*",
     "@milaboratories/milaboratories.test-enter-numbers.model": "workspace:*",
     "@milaboratories/milaboratories.test-read-logs": "workspace:*",
     "@milaboratories/milaboratories.test-read-logs.model": "workspace:*",
     "@milaboratories/milaboratories.test-sum-numbers": "workspace:*",
-    "@milaboratories/milaboratories.test-sum-numbers-v3": "workspace:*",
     "@milaboratories/milaboratories.test-sum-numbers.model": "workspace:*",
     "@milaboratories/milaboratories.test-upload-file": "workspace:*",
     "@milaboratories/milaboratories.test-upload-file.model": "workspace:*",
diff --git a/tests/drivers-ml-blocks-integration/src/migrations.test.ts b/tests/drivers-ml-blocks-integration/src/migrations.test.ts
index 1f2335dc51..b3fb3ea7d5 100644
--- a/tests/drivers-ml-blocks-integration/src/migrations.test.ts
+++ b/tests/drivers-ml-blocks-integration/src/migrations.test.ts
@@ -1,12 +1,5 @@
-import { BlockPointer } from "@milaboratories/milaboratories.test-enter-numbers-v3";
+import { BlockPointer } from "@milaboratories/milaboratories.test-enter-numbers";
 import { fileURLToPath } from "node:url";
-
-// Every migration test exercises the block-pack update flow (triggerBlockPackUpdate
-// touches the dev-folder model.json), which needs the dev-folder watcher — a static
-// from-pack-v2 pack can't drive it. Build a dev-v2 pointer from the facade root the
-// from-pack-v2 BlockPointer exposes as `rootUrl` (exactly the dev block folder); dev-v2
-// `folder` is a path, so convert the file: URL at this edge.
-const enterNumberSpec = { type: "dev-v2" as const, folder: fileURLToPath(BlockPointer.rootUrl) };
 import type { Project, StorageDebugView } from "@milaboratories/pl-middle-layer";
 import { parseJson } from "@milaboratories/pl-model-common";
 import { createBlockStorage, isBlockStorage, deriveDataFromStorage } from "@platforma-sdk/model";
@@ -18,6 +11,13 @@ import { createProjectWatcher } from "./test-helpers";
 import type { BlockDumpUnified } from "./unified-state-schema";
 import { BlockDumpArraySchemaUnified } from "./unified-state-schema";
 
+// Every migration test exercises the block-pack update flow (triggerBlockPackUpdate
+// touches the dev-folder model.json), which needs the dev-folder watcher — a static
+// from-pack-v2 pack can't drive it. Build a dev-v2 pointer from the facade root the
+// from-pack-v2 BlockPointer exposes as `rootUrl` (exactly the dev block folder); dev-v2
+// `folder` is a path, so convert the file: URL at this edge.
+const enterNumberSpec = { type: "dev-v2" as const, folder: fileURLToPath(BlockPointer.rootUrl) };
+
 /**
  * Creates a raw BlockStorage JSON string with the given data and version.
  * This simulates storage in the old format before a migration.
@@ -32,14 +32,14 @@ function createRawBlockStorage(data: unknown, dataVersion: string): string {
  */
 async function triggerBlockPackUpdate(prj: Project): Promise<void> {
   await fs.promises.appendFile(
-    path.resolve("..", "..", "etc", "blocks", "enter-numbers-v3", "model", "dist", "model.json"),
+    path.resolve("..", "..", "etc", "blocks", "enter-numbers", "model", "dist", "model.json"),
     " ",
   );
   await prj.overview.refreshState();
 }
 
 // =============================================================================
-// Migration Tests for enter-numbers-v3 block
+// Migration Tests for enter-numbers block
 //
 // Block has 2 migrations:
 //   - migration[0]: v1 → v2 (adds labels field)
@@ -354,7 +354,7 @@ test("v3: migration failure prevents block pack update", async ({ expect }) => {
   // This test verifies that when a migration throws an exception,
   // the block pack update is rejected — the block stays on the old version
   // and user data is preserved.
-  // The enter-numbers-v3 migration[0] throws if numbers contain 666.
+  // The enter-numbers migration[0] throws if numbers contain 666.
   await withMl(async (ml, workFolder) => {
     const prj1Id = await ml.createProject({ label: "Migration Failure Test" });
     await ml.openProject(prj1Id);
diff --git a/tests/drivers-ml-blocks-integration/src/ml-legacy.test.ts b/tests/drivers-ml-blocks-integration/src/ml-legacy.test.ts
deleted file mode 100644
index d22f6154b7..0000000000
--- a/tests/drivers-ml-blocks-integration/src/ml-legacy.test.ts
+++ /dev/null
@@ -1,1540 +0,0 @@
-import { BlockPointer as downloadBlobURLSpec } from "@milaboratories/milaboratories.test-blob-url-custom-protocol";
-import type { platforma as downloadBlobURLModel } from "@milaboratories/milaboratories.test-blob-url-custom-protocol.model";
-import { BlockPointer as downloadFileSpec } from "@milaboratories/milaboratories.test-download-file";
-import type { platforma as downloadFileModel } from "@milaboratories/milaboratories.test-download-file.model";
-import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers";
-import { BlockPointer as readLogsSpec } from "@milaboratories/milaboratories.test-read-logs";
-import type { platforma as readLogsModel } from "@milaboratories/milaboratories.test-read-logs.model";
-import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers";
-import { BlockPointer as uploadFileSpec } from "@milaboratories/milaboratories.test-upload-file";
-import type { platforma as uploadFileModel } from "@milaboratories/milaboratories.test-upload-file.model";
-import { BlockPointer as transferFilesSpec } from "@milaboratories/milaboratories.transfer-files";
-import type { platforma as transferFilesModel } from "@milaboratories/milaboratories.transfer-files.model";
-import { DisconnectedError } from "@milaboratories/pl-client";
-import {
-  type FolderURL,
-  type ImportFileHandle,
-  type InferBlockState,
-  InitialBlockSettings,
-  type LocalBlobHandleAndSize,
-  type PlRef,
-  type RangeBytes,
-  type RemoteBlobHandleAndSize,
-} from "@milaboratories/pl-middle-layer";
-import type { MiddleLayer } from "@milaboratories/pl-middle-layer";
-import { awaitStableState, blockTest } from "@platforma-sdk/test";
-import { deriveDataFromStorage } from "@platforma-sdk/model";
-import fs from "node:fs";
-import { createHash } from "node:crypto";
-import * as fsp from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { assert, test } from "vitest";
-import { compareBuffersInChunks, computeHashIncremental, shuffleInPlace } from "./imports";
-import { isObject } from "@milaboratories/ts-helpers";
-import { withMl, withMlAndProxy } from "./with-ml";
-import { awaitBlockDone } from "./test-helpers";
-
-// oxlint-disable-next-line jest/no-disabled-tests
-test.skip("disconnect:runBlock throws DisconnectedError when connection drops mid-operation", async ({
-  expect,
-}) => {
-  await expect(() =>
-    withMlAndProxy(async (ml, _wd, proxy) => {
-      const prj1Id = await ml.createProject({ label: "Project 1" });
-      await ml.openProject(prj1Id);
-      const prj = ml.getOpenedProject(prj1Id);
-
-      expect(await prj.overview.awaitStableValue()).toMatchObject({
-        meta: { label: "Project 1" },
-        blocks: [],
-      });
-
-      const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-      const block2Id = await prj.addBlock("Block 2", sumNumbersSpec);
-
-      await prj.setBlockArgs(block1Id, { numbers: [1, 2, 3] });
-
-      await prj.setBlockArgs(block2Id, {
-        sources: [outputRef(block1Id, "numbers")],
-      });
-
-      // Start transaction without awaiting, disconnect while in-flight, then await result.
-      const result = prj.runBlock(block2Id);
-
-      await proxy.disconnectAll();
-
-      await result;
-      await awaitBlockDone(prj, block2Id);
-    }),
-  ).rejects.toThrow(DisconnectedError);
-});
-
-test("project list manipulations test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-
-    expect(await projectList.awaitStableValue()).toEqual([]);
-
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-
-    expect(await projectList.getValue()).toMatchObject([
-      {
-        id: prj1Id,
-        meta: { label: "Project 1" },
-        opened: false,
-      },
-    ]);
-
-    await ml.setProjectMeta(prj1Id, { label: "Project 1A" });
-
-    const listSnapshot1 = await projectList.getValue();
-    expect(listSnapshot1).toMatchObject([
-      {
-        id: prj1Id,
-        meta: { label: "Project 1A" },
-        opened: false,
-      },
-    ]);
-    expect(listSnapshot1![0].lastModified.valueOf()).toBeGreaterThan(
-      listSnapshot1![0].created.valueOf(),
-    );
-
-    await ml.openProject(prj1Id);
-
-    expect(await projectList.getValue()).toMatchObject([
-      {
-        id: prj1Id,
-        meta: { label: "Project 1A" },
-        opened: true,
-      },
-    ]);
-
-    await ml.closeProject(prj1Id);
-
-    expect(await projectList.getValue()).toMatchObject([
-      {
-        id: prj1Id,
-        meta: { label: "Project 1A" },
-        opened: false,
-      },
-    ]);
-
-    await ml.deleteProject(prj1Id);
-
-    expect(await projectList.awaitStableValue()).toEqual([]);
-  });
-});
-
-test("duplicate project test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-
-    // Create source project
-    const srcPrjId = await ml.createProject({ label: "Source Project" });
-    await ml.openProject(srcPrjId);
-    const srcPrj = ml.getOpenedProject(srcPrjId);
-
-    // Add blocks with args
-    const block1Id = await srcPrj.addBlock("Enter Numbers", enterNumberSpec);
-    const block2Id = await srcPrj.addBlock("Sum Numbers", sumNumbersSpec);
-
-    await srcPrj.setBlockArgs(block1Id, { numbers: [10, 20, 30] });
-    await srcPrj.setBlockArgs(block2Id, {
-      sources: [outputRef(block1Id, "numbers")],
-    });
-
-    await ml.closeProject(srcPrjId);
-
-    // Duplicate with rename lambda
-    const prjDupId = await ml.duplicateProject(srcPrjId, (prevLabel, existingLabels) => {
-      expect(existingLabels).toContain("Source Project");
-      let candidate = `${prevLabel} (Copy)`;
-      let i = 2;
-      while (existingLabels.includes(candidate)) {
-        candidate = `${prevLabel} (Copy ${i})`;
-        i++;
-      }
-      return candidate;
-    });
-
-    // Verify project list has both projects
-    const list = await projectList.getValue();
-    assert(list);
-    expect(list).toHaveLength(2);
-
-    const srcEntry = list.find((p) => p.id === srcPrjId);
-    const dupEntry = list.find((p) => p.id === prjDupId);
-    assert(srcEntry);
-    assert(dupEntry);
-    expect(srcEntry.meta.label).toBe("Source Project");
-    expect(dupEntry.meta.label).toBe("Source Project (Copy)");
-
-    // Duplicate has different rid and fresh timestamps
-    expect(prjDupId).not.toBe(srcPrjId);
-    expect(dupEntry.created.valueOf()).toBeGreaterThanOrEqual(srcEntry.created.valueOf());
-
-    // Open duplicate and verify structure
-    await ml.openProject(prjDupId);
-    const dupPrj = ml.getOpenedProject(prjDupId);
-
-    const dupOverview = await dupPrj.overview.awaitStableValue();
-    expect(dupOverview.meta.label).toBe("Source Project (Copy)");
-    expect(dupOverview.blocks).toHaveLength(2);
-    expect(dupOverview.blocks[0].title).toBeDefined();
-    expect(dupOverview.blocks[1].title).toBeDefined();
-
-    // Verify source project is unchanged
-    await ml.openProject(srcPrjId);
-    const srcPrj2 = ml.getOpenedProject(srcPrjId);
-    const srcOverview = await srcPrj2.overview.awaitStableValue();
-    expect(srcOverview.meta.label).toBe("Source Project");
-    expect(srcOverview.blocks).toHaveLength(2);
-
-    // Cleanup
-    await ml.closeProject(prjDupId);
-    await ml.closeProject(srcPrjId);
-    await ml.deleteProject(prjDupId);
-    await ml.deleteProject(srcPrjId);
-
-    expect(await projectList.awaitStableValue()).toEqual([]);
-  });
-});
-
-test("duplicate project - name deduplication test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-
-    // Create two projects with names that would conflict
-    const prj1Id = await ml.createProject({ label: "My Analysis" });
-    const prj2Id = await ml.createProject({ label: "My Analysis (Copy)" });
-
-    // Duplicate with dedup logic - should skip "My Analysis (Copy)" since it exists
-    const prjDupId = await ml.duplicateProject(prj1Id, (prevLabel, existingLabels) => {
-      let candidate = `${prevLabel} (Copy)`;
-      let i = 2;
-      while (existingLabels.includes(candidate)) {
-        candidate = `${prevLabel} (Copy ${i})`;
-        i++;
-      }
-      return candidate;
-    });
-
-    const list = await projectList.getValue();
-    assert(list);
-    expect(list).toHaveLength(3);
-    const dupEntry = list.find((p) => p.id === prjDupId);
-    assert(dupEntry);
-    expect(dupEntry.meta.label).toBe("My Analysis (Copy 2)");
-
-    // Cleanup
-    await ml.deleteProject(prjDupId);
-    await ml.deleteProject(prj2Id);
-    await ml.deleteProject(prj1Id);
-  });
-});
-
-test("simple project manipulations test", { timeout: 30000, retry: 3 }, async ({ expect }) => {
-  // Baseline stat:
-  // (1a) {"committed":{"txCount":41,"rootsCreated":0,"structsCreated":18,"structsCreatedDataBytes":487161,"ephemeralsCreated":125,"ephemeralsCreatedDataBytes":3033,"valuesCreated":113,"valuesCreatedDataBytes":574938,"kvSetRequests":33,"kvSetBytes":33,"inputsLocked":79,"outputsLocked":59,"fieldsCreated":439,"fieldsSet":516,"fieldsGet":3,"rGetDataCacheHits":180,"rGetDataCacheFields":0,"rGetDataCacheBytes":160264,"rGetDataNetRequests":129,"rGetDataNetFields":578,"rGetDataNetBytes":478364,"kvListRequests":121,"kvListEntries":283,"kvListBytes":19773,"kvGetRequests":75,"kvGetBytes":5212},"conflict":{"txCount":1,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":24,"ephemeralsCreatedDataBytes":630,"valuesCreated":4,"valuesCreatedDataBytes":86,"kvSetRequests":1,"kvSetBytes":1,"inputsLocked":10,"outputsLocked":6,"fieldsCreated":26,"fieldsSet":40,"fieldsGet":0,"rGetDataCacheHits":21,"rGetDataCacheFields":0,"rGetDataCacheBytes":434,"rGetDataNetRequests":4,"rGetDataNetFields":31,"rGetDataNetBytes":0,"kvListRequests":1,"kvListEntries":9,"kvListBytes":703,"kvGetRequests":5,"kvGetBytes":427},"error":{"txCount":0,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":0,"ephemeralsCreatedDataBytes":0,"valuesCreated":0,"valuesCreatedDataBytes":0,"kvSetRequests":0,"kvSetBytes":0,"inputsLocked":0,"outputsLocked":0,"fieldsCreated":0,"fieldsSet":0,"fieldsGet":0,"rGetDataCacheHits":0,"rGetDataCacheFields":0,"rGetDataCacheBytes":0,"rGetDataNetRequests":0,"rGetDataNetFields":0,"rGetDataNetBytes":0,"kvListRequests":0,"kvListEntries":0,"kvListBytes":0,"kvGetRequests":0,"kvGetBytes":0}}
-  // (2a) {"committed":{"txCount":41,"rootsCreated":0,"structsCreated":18,"structsCreatedDataBytes":487161,"ephemeralsCreated":113,"ephemeralsCreatedDataBytes":2718,"valuesCreated":111,"valuesCreatedDataBytes":574895,"kvSetRequests":32,"kvSetBytes":32,"inputsLocked":74,"outputsLocked":56,"fieldsCreated":432,"fieldsSet":496,"fieldsGet":3,"rGetDataCacheHits":180,"rGetDataCacheFields":0,"rGetDataCacheBytes":160269,"rGetDataNetRequests":128,"rGetDataNetFields":573,"rGetDataNetBytes":478364,"kvListRequests":120,"kvListEntries":284,"kvListBytes":19830,"kvGetRequests":75,"kvGetBytes":5212},"conflict":{"txCount":1,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":0,"ephemeralsCreatedDataBytes":0,"valuesCreated":1,"valuesCreatedDataBytes":14,"kvSetRequests":2,"kvSetBytes":2,"inputsLocked":0,"outputsLocked":0,"fieldsCreated":0,"fieldsSet":7,"fieldsGet":2,"rGetDataCacheHits":34,"rGetDataCacheFields":0,"rGetDataCacheBytes":158963,"rGetDataNetRequests":1,"rGetDataNetFields":34,"rGetDataNetBytes":0,"kvListRequests":1,"kvListEntries":9,"kvListBytes":703,"kvGetRequests":5,"kvGetBytes":427},"error":{"txCount":0,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":0,"ephemeralsCreatedDataBytes":0,"valuesCreated":0,"valuesCreatedDataBytes":0,"kvSetRequests":0,"kvSetBytes":0,"inputsLocked":0,"outputsLocked":0,"fieldsCreated":0,"fieldsSet":0,"fieldsGet":0,"rGetDataCacheHits":0,"rGetDataCacheFields":0,"rGetDataCacheBytes":0,"rGetDataNetRequests":0,"rGetDataNetFields":0,"rGetDataNetBytes":0,"kvListRequests":0,"kvListEntries":0,"kvListBytes":0,"kvGetRequests":0,"kvGetBytes":0}}
-  // (1b) {"committed":{"txCount":41,"rootsCreated":0,"structsCreated":18,"structsCreatedDataBytes":487161,"ephemeralsCreated":113,"ephemeralsCreatedDataBytes":2718,"valuesCreated":111,"valuesCreatedDataBytes":574895,"kvSetRequests":32,"kvSetBytes":32,"inputsLocked":71,"outputsLocked":53,"fieldsCreated":377,"fieldsSet":441,"fieldsGet":3,"rGetDataCacheHits":180,"rGetDataCacheFields":0,"rGetDataCacheBytes":160269,"rGetDataNetRequests":127,"rGetDataNetFields":569,"rGetDataNetBytes":478364,"kvListRequests":118,"kvListEntries":284,"kvListBytes":19830,"kvGetRequests":75,"kvGetBytes":5212},"conflict":{"txCount":3,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":24,"ephemeralsCreatedDataBytes":630,"valuesCreated":6,"valuesCreatedDataBytes":119,"kvSetRequests":4,"kvSetBytes":4,"inputsLocked":10,"outputsLocked":6,"fieldsCreated":26,"fieldsSet":48,"fieldsGet":2,"rGetDataCacheHits":67,"rGetDataCacheFields":0,"rGetDataCacheBytes":159215,"rGetDataNetRequests":4,"rGetDataNetFields":72,"rGetDataNetBytes":0,"kvListRequests":3,"kvListEntries":27,"kvListBytes":2109,"kvGetRequests":15,"kvGetBytes":1281},"error":{"txCount":0,"rootsCreated":0,"structsCreated":0,"structsCreatedDataBytes":0,"ephemeralsCreated":0,"ephemeralsCreatedDataBytes":0,"valuesCreated":0,"valuesCreatedDataBytes":0,"kvSetRequests":0,"kvSetBytes":0,"inputsLocked":0,"outputsLocked":0,"fieldsCreated":0,"fieldsSet":0,"fieldsGet":0,"rGetDataCacheHits":0,"rGetDataCacheFields":0,"rGetDataCacheBytes":0,"rGetDataNetRequests":0,"rGetDataNetFields":0,"rGetDataNetBytes":0,"kvListRequests":0,"kvListEntries":0,"kvListBytes":0,"kvGetRequests":0,"kvGetBytes":0}}
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-    expect(await projectList.awaitStableValue()).toEqual([]);
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    const projectListValue1 = await projectList.getValue();
-    expect(projectListValue1).toMatchObject([
-      {
-        id: prj1Id,
-        meta: { label: "Project 1" },
-        opened: false,
-      },
-    ]);
-
-    const lastModInitial = projectListValue1![0].lastModified.valueOf();
-
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    expect(await prj.overview.awaitStableValue()).toMatchObject({
-      meta: { label: "Project 1" },
-      authorMarker: undefined,
-      blocks: [],
-    });
-    await ml.setProjectMeta(
-      prj1Id,
-      { label: "New Project Label" },
-      { authorId: "test_author", localVersion: 1 },
-    );
-    await prj.overview.refreshState();
-    expect(await prj.overview.awaitStableValue()).toMatchObject({
-      meta: { label: "New Project Label" },
-      authorMarker: { authorId: "test_author", localVersion: 1 },
-      blocks: [],
-    });
-
-    const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-    const block2Id = await prj.addBlock("Block 2", enterNumberSpec);
-    const block3Id = await prj.addBlock("Block 3", sumNumbersSpec);
-
-    expect(await prj.overview.awaitStableValue()).toMatchObject({
-      meta: { label: "New Project Label" },
-      authorMarker: undefined,
-    });
-
-    const overviewSnapshot0 = await prj.overview.awaitStableValue();
-
-    overviewSnapshot0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-      expect(block.navigationState).toStrictEqual({ href: "/" });
-    });
-
-    const _block1StableState0 = await prj.getBlockState(block1Id).awaitStableValue();
-    const _block2StableState0 = await prj.getBlockState(block2Id).awaitStableValue();
-    const _block3StableState0 = await prj.getBlockState(block3Id).awaitStableValue();
-
-    expect(_block1StableState0.outputs!["activeArgs"]).toStrictEqual({
-      ok: true,
-      value: undefined,
-      stable: true,
-    });
-
-    await prj.setNavigationState(block1Id, { href: "/section1" });
-    await prj.setBlockArgs(block1Id, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(block2Id, { numbers: [3, 4, 5] });
-    await prj.setBlockArgs(block3Id, {
-      sources: [outputRef(block1Id, "numbers"), outputRef(block2Id, "numbers")],
-    });
-    await prj.runBlock(block3Id);
-    await awaitBlockDone(prj, block3Id);
-    const overviewSnapshot1 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot1.lastModified.valueOf()).toBeGreaterThan(lastModInitial);
-
-    overviewSnapshot1.blocks.forEach((block) => {
-      expect(block.settings).toMatchObject(InitialBlockSettings);
-      expect(block.sections).toBeDefined();
-      expect(block.outputsError).toBeUndefined();
-      expect(block.exportsError).toBeUndefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.stale).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-      if (block.id === block1Id) expect(block.navigationState).toStrictEqual({ href: "/section1" });
-      else expect(block.navigationState).toStrictEqual({ href: "/" });
-    });
-    // console.dir(overviewSnapshot1, { depth: 5 });
-    const block1StableFrontend = await prj.getBlockFrontend(block1Id).awaitStableValue();
-    expect(block1StableFrontend.url).toBeDefined();
-    expect(block1StableFrontend.sdkVersion).toBeDefined();
-    const block2StableFrontend = await prj.getBlockFrontend(block2Id).awaitStableValue();
-    expect(block2StableFrontend.url).toMatch(/^block-ui:\/\//);
-    expect(block2StableFrontend.sdkVersion).toBeDefined();
-    const block3StableFrontend = await prj.getBlockFrontend(block3Id).awaitStableValue();
-    expect(block3StableFrontend.url).toBeDefined();
-    expect(block3StableFrontend.sdkVersion).toBeDefined();
-    // console.dir({ block1StableFrontend, block2StableFrontend, block3StableFrontend }, { depth: 5 });
-
-    const block1StableState1 = await prj.getBlockState(block1Id).awaitStableValue();
-    const _block2StableState1 = await prj.getBlockState(block2Id).awaitStableValue();
-    const block3StableState1 = await prj.getBlockState(block3Id).awaitStableValue();
-    expect(block1StableState1.navigationState).toStrictEqual({ href: "/section1" });
-    expect(_block2StableState1.navigationState).toStrictEqual({ href: "/" });
-    expect(block3StableState1.navigationState).toStrictEqual({ href: "/" });
-    console.dir(block1StableState1, { depth: 5 });
-    console.dir(_block2StableState1, { depth: 5 });
-    console.dir(block3StableState1, { depth: 5 });
-
-    expect(block1StableState1.outputs!["activeArgs"]).toStrictEqual({
-      ok: true,
-      value: { numbers: [1, 2, 3] },
-      stable: true,
-    });
-
-    expect(block3StableState1.outputs!["sum"]).toStrictEqual({
-      ok: true,
-      value: 18,
-      stable: true,
-    });
-
-    const overviewSnapshot3 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot3.blocks.find((b) => b.id === block3Id)?.stale).toEqual(false);
-    expect(overviewSnapshot3.blocks.find((b) => b.id === block2Id)?.stale).toEqual(false);
-
-    await prj.setBlockArgs(block2Id, { numbers: [3, 4, 5], __ignored_field: "test" });
-
-    const overviewSnapshot4 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot4.blocks.find((b) => b.id === block3Id)?.stale).toEqual(false);
-    expect(overviewSnapshot4.blocks.find((b) => b.id === block2Id)?.stale).toEqual(false);
-
-    await prj.resetBlockArgsAndUiState(block2Id);
-    await prj.setBlockSettings(block2Id, { versionLock: "patch" });
-
-    const block2State = await prj.getBlockState(block2Id).getValue();
-    expect(deriveDataFromStorage(block2State.blockStorage)).toStrictEqual({
-      args: { numbers: [] },
-      uiState: {},
-    });
-
-    const overviewSnapshot2 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot2.blocks.find((b) => b.id === block3Id)?.canRun).toEqual(false);
-    expect(overviewSnapshot2.blocks.find((b) => b.id === block3Id)?.stale).toEqual(true);
-    expect(overviewSnapshot2.blocks.find((b) => b.id === block2Id)?.stale).toEqual(true);
-    expect(overviewSnapshot2.blocks.find((b) => b.id === block2Id)?.settings).toEqual({
-      versionLock: "patch",
-    });
-  });
-});
-
-test("reorder & rename blocks", { timeout: 20000 }, async ({ expect }) => {
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-    expect(await projectList.awaitStableValue()).toEqual([]);
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-    const block2Id = await prj.addBlock("Block 2", enterNumberSpec);
-    const block3Id = await prj.addBlock("Block 3", sumNumbersSpec);
-
-    const overviewSnapshot0 = await prj.overview.awaitStableValue();
-
-    overviewSnapshot0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-      expect(block.navigationState).toStrictEqual({ href: "/" });
-    });
-
-    await prj.setNavigationState(block1Id, { href: "/section1" });
-    await prj.setBlockArgs(block1Id, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(block2Id, { numbers: [3, 4, 5] });
-    await prj.setBlockArgs(block3Id, {
-      sources: [outputRef(block1Id, "numbers"), outputRef(block2Id, "numbers")],
-    });
-    await prj.runBlock(block3Id);
-    await awaitBlockDone(prj, block3Id);
-
-    const overviewSnapshot1 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot1).toMatchObject({
-      blocks: [
-        { id: block1Id, calculationStatus: "Done" },
-        { id: block2Id, calculationStatus: "Done" },
-        { id: block3Id, calculationStatus: "Done" },
-      ],
-    });
-
-    await prj.reorderBlocks([block2Id, block3Id, block1Id]);
-
-    const overviewSnapshot2 = await prj.overview.awaitStableValue();
-    expect(overviewSnapshot2).toMatchObject({
-      blocks: [
-        { id: block2Id, calculationStatus: "Done" },
-        { id: block3Id, calculationStatus: "Limbo" },
-        { id: block1Id, calculationStatus: "Done" },
-      ],
-    });
-  });
-});
-
-test("dependency test", { timeout: 20000 }, async ({ expect }) => {
-  await withMl(async (ml) => {
-    const projectList = ml.projectList;
-    expect(await projectList.awaitStableValue()).toEqual([]);
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-    const block2Id = await prj.addBlock("Block 2", enterNumberSpec);
-    const block3Id = await prj.addBlock("Block 3", sumNumbersSpec);
-    const block4Id = await prj.addBlock("Block 4", sumNumbersSpec);
-    const block5Id = await prj.addBlock("Block 5", sumNumbersSpec);
-
-    const overviewSnapshot0 = await prj.overview.awaitStableValue();
-
-    overviewSnapshot0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-      expect(block.navigationState).toStrictEqual({ href: "/" });
-    });
-
-    await prj.setNavigationState(block1Id, { href: "/section1" });
-    await prj.setBlockArgs(block1Id, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(block2Id, { numbers: [3, 4, 5] });
-    await prj.setBlockArgs(block3Id, {
-      sources: [outputRef(block1Id, "numbers"), outputRef(block2Id, "numbers")],
-    });
-    await prj.setBlockArgs(block4Id, {
-      sources: [outputRef(block1Id, "numbers"), outputRef(block2Id, "numbers")],
-    });
-    await prj.setBlockArgs(block5Id, {
-      sources: [outputRef(block1Id, "numbers"), outputRef(block2Id, "numbers")],
-    });
-    const overviewSnapshot1 = await prj.overview.awaitStableValue();
-
-    expect(overviewSnapshot1.blocks).toMatchObject([
-      { upstreams: [], downstreams: [block3Id, block4Id, block5Id] },
-      { upstreams: [], downstreams: [block3Id, block4Id, block5Id] },
-      { upstreams: [block1Id, block2Id], downstreams: [] },
-      { upstreams: [block1Id, block2Id], downstreams: [] },
-      { upstreams: [block1Id, block2Id], downstreams: [] },
-    ]);
-
-    await prj.setBlockArgs(block3Id, {
-      sources: [outputRef(block1Id, "numbers", true), outputRef(block2Id, "numbers", true)],
-    });
-    await prj.setBlockArgs(block4Id, {
-      sources: [outputRef(block2Id, "numbers", true)],
-    });
-    await prj.setBlockArgs(block5Id, {
-      sources: [outputRef(block1Id, "numbers", true)],
-    });
-    const overviewSnapshot2 = await prj.overview.awaitStableValue();
-
-    expect(
-      overviewSnapshot2.blocks.map((b) => ({
-        upstreams: new Set(b.upstreams),
-        downstreams: new Set(b.downstreams),
-      })),
-    ).toMatchObject([
-      { upstreams: new Set(), downstreams: new Set([block3Id, block5Id]) },
-      { upstreams: new Set(), downstreams: new Set([block3Id, block4Id, block5Id]) },
-      { upstreams: new Set([block1Id, block2Id]), downstreams: new Set([block5Id]) },
-      { upstreams: new Set([block2Id]), downstreams: new Set() },
-      { upstreams: new Set([block1Id, block2Id, block3Id]), downstreams: new Set() },
-    ]);
-  });
-});
-
-test("limbo test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-    const block2Id = await prj.addBlock("Block 2", sumNumbersSpec);
-
-    const overview0 = await prj.overview.awaitStableValue();
-    overview0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.setBlockArgs(block1Id, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(block2Id, {
-      sources: [outputRef(block1Id, "numbers")],
-    });
-
-    const overview1 = await prj.overview.awaitStableValue();
-    overview1.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(true);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.runBlock(block2Id);
-    await awaitBlockDone(prj, block2Id);
-
-    const block2StableState1 = await prj.getBlockState(block2Id).getValue();
-    expect(block2StableState1.outputs!["sum"]).toStrictEqual({
-      ok: true,
-      value: 6,
-      stable: true,
-    });
-
-    const overview2 = await prj.overview.awaitStableValue();
-    overview2.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.calculationStatus).toEqual("Done");
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.setBlockArgs(block1Id, { numbers: [2, 3] });
-    await prj.runBlock(block1Id);
-    await awaitBlockDone(prj, block1Id);
-
-    const overview3 = await prj.overview.awaitStableValue();
-    const [overview3Block1, overview3Block2] = overview3.blocks;
-    expect(overview3Block1.calculationStatus).toEqual("Done");
-    expect(overview3Block2.calculationStatus).toEqual("Limbo");
-
-    await prj.runBlock(block2Id);
-    await awaitBlockDone(prj, block2Id);
-
-    const block2StableState2 = await prj.getBlockState(block2Id).getValue();
-    expect(block2StableState2.outputs!["sum"]).toStrictEqual({
-      ok: true,
-      value: 5,
-      stable: true,
-    });
-
-    const overview4 = await prj.overview.awaitStableValue();
-    const [overview4Block1, overview4Block2] = overview4.blocks;
-    expect(overview4Block1.calculationStatus).toEqual("Done");
-    expect(overview4Block2.calculationStatus).toEqual("Done");
-  });
-});
-
-test("error propagation", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    const block1Id = await prj.addBlock("Block 1", enterNumberSpec);
-
-    const overview0 = await prj.overview.awaitStableValue();
-    overview0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.setBlockArgs(block1Id, { numbers: [1] });
-
-    const block1StableState1 = await prj.getBlockState(block1Id).awaitStableValue();
-    expect(block1StableState1.outputs!["errorIfNumberIs999"]).toStrictEqual({
-      ok: true,
-      value: [1],
-      stable: true,
-    });
-
-    await prj.setBlockArgs(block1Id, { numbers: [999] });
-
-    const block1StableState2 = await prj.getBlockState(block1Id).awaitStableValue();
-
-    const result = block1StableState2.outputs!["errorIfNumberIs999"];
-
-    expect(result.ok).toBe(false);
-
-    if (result.ok) {
-      throw new Error("Result is ok (unexpected)");
-    }
-
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].name).toBe("WrongResourceTypeError");
-  });
-});
-
-test("block duplication test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    // Create original block with some configuration
-    const originalBlockId = await prj.addBlock("Original Block", enterNumberSpec);
-    await prj.setBlockArgs(originalBlockId, { numbers: [1, 2, 3] });
-    await prj.setUiState(originalBlockId, { testUiState: "some ui data" });
-    await prj.setBlockSettings(originalBlockId, { versionLock: "patch" });
-
-    // Get initial overview
-    const overviewBefore = await prj.overview.awaitStableValue();
-    expect(overviewBefore.blocks).toHaveLength(1);
-    expect(overviewBefore.blocks[0].label).toBe("Original Block");
-
-    // Duplicate the block
-    const duplicatedBlockId = await prj.duplicateBlock(originalBlockId);
-
-    // Verify the duplicated block exists
-    const overviewAfter = await prj.overview.awaitStableValue();
-    expect(overviewAfter.blocks).toHaveLength(2);
-
-    const originalBlock = overviewAfter.blocks.find((b) => b.id === originalBlockId);
-    const duplicatedBlock = overviewAfter.blocks.find((b) => b.id === duplicatedBlockId);
-
-    expect(originalBlock).toBeDefined();
-    expect(duplicatedBlock).toBeDefined();
-
-    // Verify block structure is copied
-    expect(duplicatedBlock!.label).toBe("Original Block");
-    expect(duplicatedBlock!.currentBlockPack).toEqual(originalBlock!.currentBlockPack);
-    expect(duplicatedBlock!.settings).toEqual(originalBlock!.settings);
-
-    // Verify block state is copied
-    const originalState = await prj.getBlockState(originalBlockId).awaitStableValue();
-    const duplicatedState = await prj.getBlockState(duplicatedBlockId).awaitStableValue();
-
-    expect(deriveDataFromStorage(duplicatedState.blockStorage)).toEqual(
-      deriveDataFromStorage(originalState.blockStorage),
-    );
-
-    // Verify they are independent - changing one shouldn't affect the other
-    await prj.setBlockArgs(originalBlockId, { numbers: [4, 5, 6] });
-
-    const originalStateAfter = await prj.getBlockState(originalBlockId).awaitStableValue();
-    const duplicatedStateAfter = await prj.getBlockState(duplicatedBlockId).awaitStableValue();
-
-    const orig = deriveDataFromStorage(originalStateAfter.blockStorage);
-    const dup = deriveDataFromStorage(duplicatedStateAfter.blockStorage);
-
-    if (!(isObject(orig) && "args" in orig)) {
-      throw new Error("s1 is not an object");
-    }
-
-    if (!(isObject(dup) && "args" in dup)) {
-      throw new Error("s2 is not an object");
-    }
-
-    expect(orig.args).toEqual({ numbers: [4, 5, 6] });
-    expect(dup.args).toEqual({ numbers: [1, 2, 3] }); // unchanged
-  });
-});
-
-test("block update test", async ({ expect }) => {
-  await withMl(async (ml, workFolder) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    const tmpDevBlockFolder = path.resolve(workFolder, "dev");
-    await fs.promises.mkdir(tmpDevBlockFolder, { recursive: true });
-
-    // Build a dev-v2 pointer from the from-pack-v2 BlockPointer's `rootUrl` (the facade
-    // root is exactly the dev block folder) so the block-pack update watcher
-    // (dev-folder) drives updatedBlockPack; dev-v2 `folder` is a path, so convert the
-    // file: URL at this edge.
-    const enterNumberDevSpec = {
-      type: "dev-v2" as const,
-      folder: fileURLToPath(enterNumberSpec.rootUrl),
-    };
-    const block1Id = await prj.addBlock("Block 1", enterNumberDevSpec);
-
-    const overview0 = await prj.overview.awaitStableValue();
-    expect(overview0.blocks[0].updatedBlockPack).toBeUndefined();
-
-    // touch
-    await fs.promises.appendFile(
-      path.resolve("..", "..", "etc", "blocks", "enter-numbers", "model", "dist", "model.json"),
-      " ",
-    );
-
-    // await update watcher
-    await prj.overview.refreshState();
-    const overview1 = await prj.overview.awaitStableValue();
-    expect(overview1.blocks[0].updatedBlockPack).toBeDefined();
-
-    await prj.updateBlockPack(block1Id, overview1.blocks[0].updatedBlockPack!);
-
-    const overview2 = await prj.overview.awaitStableValue();
-    expect(overview2.blocks[0].currentBlockPack).toStrictEqual(
-      overview1.blocks[0].updatedBlockPack,
-    );
-    expect(overview2.blocks[0].updatedBlockPack).toBeUndefined();
-  });
-});
-
-test("project open and close test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    let prj = ml.getOpenedProject(prj1Id);
-
-    const blockId = await prj.addBlock("Test Block", enterNumberSpec);
-    await prj.setBlockArgs(blockId, { numbers: [1, 2, 3] });
-    const overview1 = await prj.overview.awaitStableValue();
-    expect(overview1.blocks[0].canRun).toEqual(true);
-
-    ml.closeProject(prj1Id);
-    await ml.openProject(prj1Id);
-    prj = ml.getOpenedProject(prj1Id);
-
-    const overview2 = await prj.overview.awaitStableValue();
-    expect(overview2.blocks[0].canRun).toEqual(true);
-  });
-});
-
-test("block error test", async ({ expect }) => {
-  await withMl(async (ml) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    expect(await prj.overview.awaitStableValue()).toMatchObject({
-      meta: { label: "Project 1" },
-      blocks: [],
-    });
-
-    const block3Id = await prj.addBlock("Block 3", sumNumbersSpec);
-
-    await prj.setBlockArgs(block3Id, {
-      sources: [], // empty reference list should produce an error
-    });
-
-    await prj.runBlock(block3Id);
-    await awaitBlockDone(prj, block3Id);
-
-    const overviewSnapshot1 = await prj.overview.awaitStableValue();
-
-    overviewSnapshot1.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-    });
-    expect(overviewSnapshot1.blocks[0].outputErrors).toStrictEqual(true);
-
-    const block3StableState = await prj.getBlockState(block3Id).getValue();
-
-    const sum = block3StableState.outputs!["sum"];
-    expect(sum.ok).toStrictEqual(false);
-    if (!sum.ok) {
-      console.log("ml, block error test, the error:");
-      console.dir(sum.errors[0], { depth: 150 });
-      expect(typeof sum.errors[0] == "string" ? sum.errors[0] : sum.errors[0].message).toContain(
-        "At least 1 data source must be set. It's needed in 'block error test'",
-      );
-    }
-  });
-});
-
-blockTest(
-  "should create download-file block, render it and gets outputs from its config",
-  async ({ rawPrj: project, ml, expect }) => {
-    const blockId = await project.addBlock("DownloadFile", downloadFileSpec);
-
-    const inputHandle = await lsDriverGetFileHandleFromAssets(
-      ml,
-      expect,
-      "answer_to_the_ultimate_question.txt",
-    );
-
-    await project.setBlockArgs(blockId, { inputHandle });
-
-    await project.runBlock(blockId);
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        25000,
-      )) as InferBlockState<typeof downloadFileModel>;
-      // console.dir(state, { depth: 5 });
-
-      const blockFrontend = await project.getBlockFrontend(blockId).awaitStableValue();
-      expect(blockFrontend).toBeDefined();
-      console.dir(blockFrontend, { depth: 5 });
-
-      const outputs = state.outputs;
-
-      if (outputs.contentAsString.ok) {
-        expect(outputs.contentAsString.value).toStrictEqual("42\n");
-        expect((outputs.contentAsString1 as any).value).toStrictEqual("42\n42\n");
-        expect((outputs.contentAsStringRange as any).value).toStrictEqual("2");
-        expect((outputs.contentAsStringRange1 as any).value).toStrictEqual("22");
-
-        expect((outputs.contentAsJson as any).value).toStrictEqual(42);
-        const localBlob = (outputs.downloadedBlobContent as any).value as LocalBlobHandleAndSize;
-        const remoteBlob = (outputs.onDemandBlobContent as any).value as RemoteBlobHandleAndSize;
-        const quickJsRemoteBlob = (outputs.onDemandBlobContent1 as any)
-          .value as RemoteBlobHandleAndSize;
-
-        expect(
-          Buffer.from(await ml.driverKit.blobDriver.getContent(localBlob.handle)).toString("utf-8"),
-        ).toEqual("42\n");
-
-        expect(
-          Buffer.from(await ml.driverKit.blobDriver.getContent(remoteBlob.handle)).toString(
-            "utf-8",
-          ),
-        ).toEqual("42\n");
-
-        expect(
-          Buffer.from(
-            await ml.driverKit.blobDriver.getContent(remoteBlob.handle, { from: 1, to: 2 }),
-          ).toString("utf-8"),
-        ).toEqual("2");
-
-        expect(
-          Buffer.from(
-            await ml.driverKit.blobDriver.getContent(quickJsRemoteBlob.handle, { from: 1, to: 2 }),
-          ).toString("utf-8"),
-        ).toEqual("2");
-
-        return;
-      }
-    }
-  },
-);
-
-blockTest(
-  "transfer-files concurrent downloads",
-  { timeout: 600000 },
-  async ({ rawPrj: project, ml, tmpFolder, expect }) => {
-    const blockId = await project.addBlock("TransferFiles", transferFilesSpec);
-
-    // Create test files with known content (text and binary)
-    const testFiles: Array<{ name: string; buffer: Buffer }> = [
-      {
-        name: "test_small_text.txt",
-        buffer: Buffer.from(
-          "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-        ),
-      },
-      {
-        name: "test_medium_text.txt",
-        buffer: Buffer.from(
-          "Lazy dog jumps over the lazy fox. And the quick brown fox jumps over the lazy dog.",
-        ),
-      },
-      {
-        name: "test_json.json",
-        buffer: Buffer.from(JSON.stringify({ message: "Hello from JSON", value: 42 })),
-      },
-    ];
-
-    const inputHandles: ImportFileHandle[] = [];
-    const originalBuffers: Buffer[] = [];
-
-    // Create temporary files and get their handles
-    const storages = await ml.driverKit.lsDriver.getStorageList();
-    const local = storages.find((s) => s.name == "local");
-    expect(local).not.toBeUndefined();
-
-    const testDir = path.join(tmpFolder, "test-files");
-    await fsp.mkdir(testDir, { recursive: true });
-    console.log("Created test directory:", testDir);
-
-    for (const testFile of testFiles) {
-      const filePath = path.join(testDir, testFile.name);
-      await fsp.writeFile(filePath, testFile.buffer);
-      console.log(`Created test file: ${testFile.name} (${testFile.buffer.length} bytes)`);
-      originalBuffers.push(testFile.buffer);
-
-      const files = await ml.driverKit.lsDriver.listFiles(local!.handle, testDir);
-      const ourFile = files.entries.find((f) => f.name == testFile.name);
-      expect(ourFile).not.toBeUndefined();
-      expect(ourFile?.type).toBe("file");
-
-      inputHandles.push((ourFile as any).handle);
-    }
-
-    await project.setBlockArgs(blockId, { inputHandles });
-    await project.runBlock(blockId);
-
-    async function testChunkedDownload(
-      originalBuffer: Buffer,
-      exportedBlob: RemoteBlobHandleAndSize,
-      chunkSize: number,
-    ) {
-      console.log("  Test: Chunked download with hash verification, chunkSize", chunkSize);
-
-      const totalChunks = Math.ceil(originalBuffer.length / chunkSize);
-
-      console.log(
-        `    - Downloading ${originalBuffer.length} bytes in ${totalChunks} chunks of ${chunkSize} bytes`,
-      );
-
-      const downloadedChunks: Buffer[] = [];
-      let downloadedBytes = 0;
-
-      const startTime = Date.now();
-
-      const tasks = [] as { chunkIndex: number; range: RangeBytes }[];
-
-      for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
-        const from = chunkIndex * chunkSize;
-        const to = Math.min(from + chunkSize, exportedBlob.size);
-        tasks.push({
-          chunkIndex,
-          range: { from, to },
-        });
-      }
-
-      shuffleInPlace(tasks);
-
-      const results = await Promise.all(
-        tasks.map(async ({ chunkIndex }) => {
-          const from = chunkIndex * chunkSize;
-          const to = Math.min(from + chunkSize, exportedBlob.size);
-          const expectedChunkSize = to - from;
-
-          const chunk = await ml.driverKit.blobDriver.getContent(exportedBlob.handle, { from, to });
-          const chunkBuffer = Buffer.from(chunk);
-
-          // Verify chunk size
-          if (chunkBuffer.length !== expectedChunkSize) {
-            console.error(
-              `    ❌ Chunk ${chunkIndex}: size mismatch! Expected ${expectedChunkSize}, got ${chunkBuffer.length}`,
-            );
-            console.error(`       Range: from=${from}, to=${to}`);
-          }
-
-          // Verify chunk content against original
-          const originalChunk = originalBuffer.subarray(from, to);
-          if (!chunkBuffer.equals(originalChunk)) {
-            console.error(`    ❌ Chunk ${chunkIndex}: content mismatch!`);
-            console.error(`       Range: from=${from}, to=${to}`);
-            console.error(
-              `       First 20 bytes of original:   ${originalChunk.subarray(0, 20).toString("hex")}`,
-            );
-            console.error(
-              `       First 20 bytes of downloaded: ${chunkBuffer.subarray(0, 20).toString("hex")}`,
-            );
-
-            // Find first differing byte
-            for (let i = 0; i < Math.min(originalChunk.length, chunkBuffer.length); i++) {
-              if (originalChunk[i] !== chunkBuffer[i]) {
-                console.error(
-                  `       First difference at byte ${i}: original=0x${originalChunk[i].toString(16)}, downloaded=0x${chunkBuffer[i].toString(16)}`,
-                );
-                break;
-              }
-            }
-          }
-
-          // downloadedChunks.push(chunkBuffer);
-          downloadedBytes += chunk.length;
-
-          if ((chunkIndex + 1) % 10 === 0 || chunkIndex === totalChunks - 1) {
-            const progress = ((downloadedBytes / originalBuffer.length) * 100).toFixed(1);
-            console.log(`    - Downloaded ${chunkIndex + 1}/${totalChunks} chunks (${progress}%)`);
-          }
-
-          return {
-            chunkIndex,
-            chunkBuffer,
-          };
-        }),
-      );
-
-      const sortedResults = results.sort((a, b) => a.chunkIndex - b.chunkIndex);
-
-      for (const result of sortedResults) {
-        downloadedChunks.push(result.chunkBuffer);
-      }
-
-      const downloadTime = Date.now() - startTime;
-      const downloadSpeed = (downloadedBytes / 1024 / 1024 / (downloadTime / 1000)).toFixed(2);
-      console.log(`    - Download completed in ${downloadTime}ms (${downloadSpeed} MB/s)`);
-
-      // Concatenate all chunks
-      console.log("    - Concatenating chunks...");
-      const downloadedBuffer = Buffer.concat(downloadedChunks);
-
-      // Verify size
-      expect(downloadedBuffer.length).toBe(originalBuffer.length);
-      console.log(`    ✓ Downloaded size matches: ${downloadedBuffer.length} bytes`);
-
-      // Compute hashes
-      console.log("    - Computing hashes...");
-      const originalHash = computeHashIncremental(originalBuffer);
-      const downloadedHash = computeHashIncremental(downloadedBuffer);
-
-      console.log(`    - Original hash:    ${originalHash}`);
-      console.log(`    - Downloaded hash:  ${downloadedHash}`);
-
-      // Verify hashes match
-      expect(downloadedHash).toBe(originalHash);
-      console.log("    ✓ Hashes match - data integrity verified!");
-
-      // Additional verification: compare buffers in chunks
-      console.log("    - Comparing buffers in chunks...");
-      const buffersMatch = compareBuffersInChunks(originalBuffer, downloadedBuffer);
-      expect(buffersMatch).toBe(true);
-      console.log("    ✓ Chunk-by-chunk comparison passed!");
-
-      console.log("  ✓ Chunked download test passed");
-    }
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        25000,
-      )) as InferBlockState<typeof transferFilesModel>;
-
-      const blockFrontend = await project.getBlockFrontend(blockId).awaitStableValue();
-      expect(blockFrontend).toBeDefined();
-
-      const outputs = state.outputs;
-
-      if (outputs.fileImports.ok && outputs.fileExports.ok) {
-        const fileImports = outputs.fileImports.value;
-        const fileExports = outputs.fileExports.value as Record<
-          ImportFileHandle,
-          RemoteBlobHandleAndSize
-        >;
-
-        console.log("\n=== File Transfer Results ===");
-        console.log(`Files imported: ${Object.keys(fileImports).length}`);
-        console.log(`Files exported: ${Object.keys(fileExports).length}`);
-
-        // Verify all files were imported
-        expect(Object.keys(fileImports).length).toBe(testFiles.length);
-        expect(Object.keys(fileExports).length).toBe(testFiles.length);
-
-        // Test each file with comprehensive range testing
-        await Promise.all(
-          testFiles.map(async (testFile, i) => {
-            const handle = inputHandles[i];
-            const originalBuffer = originalBuffers[i];
-
-            console.log(`\n--- Testing ${testFile.name} (${originalBuffer.length} bytes) ---`);
-
-            // Check import progress
-            const importProgress = fileImports[handle];
-            expect(importProgress).toBeDefined();
-            expect(importProgress.done).toBe(true);
-
-            // Check exported blob
-            const exportedBlob = fileExports[handle];
-            expect(exportedBlob).toBeDefined();
-            expect(exportedBlob).toHaveProperty("handle");
-            expect(exportedBlob).toHaveProperty("size");
-            expect(exportedBlob.size).toBe(originalBuffer.length);
-
-            await Promise.all([
-              testChunkedDownload(originalBuffer, exportedBlob, 13),
-              testChunkedDownload(originalBuffer, exportedBlob, 5),
-              testChunkedDownload(originalBuffer, exportedBlob, 20),
-              testChunkedDownload(originalBuffer, exportedBlob, 1),
-              testChunkedDownload(originalBuffer, exportedBlob, 2),
-            ]);
-
-            console.log(`✅ All tests passed for ${testFile.name}`);
-          }),
-        );
-
-        console.log("\n=== All transfer-files tests completed successfully ===");
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-
-        return;
-      }
-    }
-  },
-);
-
-blockTest(
-  "transfer-files big files",
-  { timeout: 600000 },
-  async ({ rawPrj: project, ml, tmpFolder, expect }) => {
-    const blockId = await project.addBlock("TransferFiles", transferFilesSpec);
-
-    // Helper function to create random buffer
-    const createRandomBuffer = (size: number): Buffer => {
-      const buffer = Buffer.alloc(size);
-      for (let i = 0; i < size; i++) {
-        buffer[i] = Math.floor(Math.random() * 256);
-      }
-      return buffer;
-    };
-
-    // Helper function to compute hash incrementally for large buffers
-    const computeHashIncremental = (buffer: Buffer): string => {
-      const hasher = createHash("sha256");
-      const chunkSize = 64 * 1024 * 1024; // 64 MB chunks
-      for (let offset = 0; offset < buffer.length; offset += chunkSize) {
-        const end = Math.min(offset + chunkSize, buffer.length);
-        hasher.update(buffer.subarray(offset, end));
-      }
-      return hasher.digest("hex");
-    };
-
-    // Helper function to compare buffers in chunks
-    const compareBuffersInChunks = (buffer1: Buffer, buffer2: Buffer): boolean => {
-      if (buffer1.length !== buffer2.length) return false;
-
-      const chunkSize = 64 * 1024 * 1024; // 64 MB chunks
-      const totalChunks = Math.ceil(buffer1.length / chunkSize);
-      let chunksCompared = 0;
-
-      for (let offset = 0; offset < buffer1.length; offset += chunkSize) {
-        const end = Math.min(offset + chunkSize, buffer1.length);
-        const chunk1 = buffer1.subarray(offset, end);
-        const chunk2 = buffer2.subarray(offset, end);
-
-        if (!chunk1.equals(chunk2)) return false;
-
-        chunksCompared++;
-        if (chunksCompared % 20 === 0 || chunksCompared === totalChunks) {
-          const progress = ((chunksCompared / totalChunks) * 100).toFixed(1);
-          console.log(`    - Compared ${chunksCompared}/${totalChunks} chunks (${progress}%)`);
-        }
-      }
-
-      return true;
-    };
-
-    // Create test files with known content (text and binary)
-    const testFiles: Array<{ name: string; buffer: Buffer }> = [
-      // Huge binary file (1 GiB) - to test size limits
-      { name: "test_huge_binary.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 1) },
-      { name: "test_huge_binary_2.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 2) },
-      { name: "test_huge_binary_3.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 3) },
-      { name: "test_huge_binary_4.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 4) },
-      { name: "test_huge_binary_5.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 5) },
-      { name: "test_huge_binary_6.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 6) },
-      { name: "test_huge_binary_7.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 7) },
-      { name: "test_huge_binary_8.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 8) },
-      { name: "test_huge_binary_9.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 9) },
-      { name: "test_huge_binary_10.bin", buffer: createRandomBuffer(33 * 1024 * 1024 + 10) },
-    ];
-
-    const inputHandles: ImportFileHandle[] = [];
-    const originalBuffers: Buffer[] = [];
-
-    // Create temporary files and get their handles
-    const storages = await ml.driverKit.lsDriver.getStorageList();
-    const local = storages.find((s) => s.name == "local");
-    expect(local).not.toBeUndefined();
-
-    const testDir = path.join(tmpFolder, "test-files");
-    await fsp.mkdir(testDir, { recursive: true });
-    console.log("Created test directory:", testDir);
-
-    for (const testFile of testFiles) {
-      const filePath = path.join(testDir, testFile.name);
-      await fsp.writeFile(filePath, testFile.buffer);
-      console.log(`Created test file: ${testFile.name} (${testFile.buffer.length} bytes)`);
-      originalBuffers.push(testFile.buffer);
-
-      const files = await ml.driverKit.lsDriver.listFiles(local!.handle, testDir);
-      const ourFile = files.entries.find((f) => f.name == testFile.name);
-      expect(ourFile).not.toBeUndefined();
-      expect(ourFile?.type).toBe("file");
-
-      inputHandles.push((ourFile as any).handle);
-    }
-
-    await project.setBlockArgs(blockId, { inputHandles });
-    await project.runBlock(blockId);
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        25000,
-      )) as InferBlockState<typeof transferFilesModel>;
-
-      const blockFrontend = await project.getBlockFrontend(blockId).awaitStableValue();
-      expect(blockFrontend).toBeDefined();
-
-      const outputs = state.outputs;
-
-      if (outputs.fileImports.ok && outputs.fileExports.ok) {
-        const fileImports = outputs.fileImports.value;
-        const fileExports = outputs.fileExports.value as Record<
-          ImportFileHandle,
-          RemoteBlobHandleAndSize
-        >;
-
-        console.log("\n=== File Transfer Results ===");
-        console.log(`Files imported: ${Object.keys(fileImports).length}`);
-        console.log(`Files exported: ${Object.keys(fileExports).length}`);
-
-        expect(Object.keys(fileImports).length).toBe(testFiles.length);
-        expect(Object.keys(fileExports).length).toBe(testFiles.length);
-
-        await Promise.allSettled(
-          testFiles.map(async (testFile, i) => {
-            const handle = inputHandles[i];
-            const originalBuffer = originalBuffers[i];
-
-            console.log(`\n--- Testing ${testFile.name} (${originalBuffer.length} bytes) ---`);
-
-            const importProgress = fileImports[handle];
-            expect(importProgress).toBeDefined();
-            expect(importProgress.done).toBe(true);
-
-            const exportedBlob = fileExports[handle];
-            expect(exportedBlob).toBeDefined();
-            expect(exportedBlob).toHaveProperty("handle");
-            expect(exportedBlob).toHaveProperty("size");
-            expect(exportedBlob.size).toBe(originalBuffer.length);
-
-            {
-              console.log("Chunked download with hash verification");
-
-              const chunkSize = 1024 * 1024; // 1 MiB chunks
-              const totalChunks = Math.ceil(originalBuffer.length / chunkSize);
-
-              console.log(
-                `    - Downloading ${originalBuffer.length} bytes in ${totalChunks} chunks of ${chunkSize} bytes`,
-              );
-
-              const downloadedChunks: Buffer[] = [];
-              let downloadedBytes = 0;
-
-              const startTime = Date.now();
-
-              for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
-                const from = chunkIndex * chunkSize;
-                const to = Math.min(from + chunkSize, exportedBlob.size);
-                const expectedChunkSize = to - from;
-
-                const chunk = await ml.driverKit.blobDriver.getContent(exportedBlob.handle, {
-                  from,
-                  to,
-                });
-                const chunkBuffer = Buffer.from(chunk);
-
-                // Verify chunk size
-                if (chunkBuffer.length !== expectedChunkSize) {
-                  console.error(
-                    `    ❌ Chunk ${chunkIndex}: size mismatch! Expected ${expectedChunkSize}, got ${chunkBuffer.length}`,
-                  );
-                  console.error(`       Range: from=${from}, to=${to}`);
-                }
-
-                // Verify chunk content against original
-                const originalChunk = originalBuffer.subarray(from, to);
-                if (!chunkBuffer.equals(originalChunk)) {
-                  console.error(`    ❌ Chunk ${chunkIndex}: content mismatch!`);
-                  console.error(`       Range: from=${from}, to=${to}`);
-                  console.error(
-                    `       First 20 bytes of original:   ${originalChunk.subarray(0, 20).toString("hex")}`,
-                  );
-                  console.error(
-                    `       First 20 bytes of downloaded: ${chunkBuffer.subarray(0, 20).toString("hex")}`,
-                  );
-
-                  // Find first differing byte
-                  for (let i = 0; i < Math.min(originalChunk.length, chunkBuffer.length); i++) {
-                    if (originalChunk[i] !== chunkBuffer[i]) {
-                      console.error(
-                        `       First difference at byte ${i}: original=0x${originalChunk[i].toString(16)}, downloaded=0x${chunkBuffer[i].toString(16)}`,
-                      );
-                      break;
-                    }
-                  }
-                }
-
-                downloadedChunks.push(chunkBuffer);
-                downloadedBytes += chunk.length;
-
-                if ((chunkIndex + 1) % 10 === 0 || chunkIndex === totalChunks - 1) {
-                  const progress = ((downloadedBytes / originalBuffer.length) * 100).toFixed(1);
-                  console.log(
-                    `    - Downloaded ${chunkIndex + 1}/${totalChunks} chunks (${progress}%)`,
-                  );
-                }
-              }
-
-              const downloadTime = Date.now() - startTime;
-              const downloadSpeed = (downloadedBytes / 1024 / 1024 / (downloadTime / 1000)).toFixed(
-                2,
-              );
-              console.log(`    - Download completed in ${downloadTime}ms (${downloadSpeed} MB/s)`);
-
-              // Concatenate all chunks
-              console.log("    - Concatenating chunks...");
-              const downloadedBuffer = Buffer.concat(downloadedChunks);
-
-              // Verify size
-              expect(downloadedBuffer.length).toBe(originalBuffer.length);
-              console.log(`    ✓ Downloaded size matches: ${downloadedBuffer.length} bytes`);
-
-              // Compute hashes
-              console.log("    - Computing hashes...");
-              const originalHash = computeHashIncremental(originalBuffer);
-              const downloadedHash = computeHashIncremental(downloadedBuffer);
-
-              console.log(`    - Original hash:    ${originalHash}`);
-              console.log(`    - Downloaded hash:  ${downloadedHash}`);
-
-              // Verify hashes match
-              expect(downloadedHash).toBe(originalHash);
-              console.log("    ✓ Hashes match - data integrity verified!");
-
-              // Additional verification: compare buffers in chunks
-              console.log("    - Comparing buffers in chunks...");
-              const buffersMatch = compareBuffersInChunks(originalBuffer, downloadedBuffer);
-              expect(buffersMatch).toBe(true);
-              console.log("    ✓ Chunk-by-chunk comparison passed!");
-
-              console.log("  ✓ Chunked download test passed");
-            }
-
-            console.log(`✅ All tests passed for ${testFile.name}`);
-          }),
-        );
-
-        console.log("\n=== All transfer-files tests completed successfully ===");
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-
-        // Delete the project to clean up resources
-        await ml.deleteProject(project.id);
-
-        return;
-      }
-    }
-  },
-);
-
-blockTest(
-  "should create blob-url-custom-protocol block, render it and gets outputs from its config",
-  { timeout: 90000 },
-  async ({ rawPrj: project, ml, expect }) => {
-    const blockId = await project.addBlock("DownloadBlobUrl", downloadBlobURLSpec);
-
-    const inputTgzHandle = await lsDriverGetFileHandleFromAssets(
-      ml,
-      expect,
-      "funny_cats_site.tar.gz",
-    );
-    const inputZipHandle = await lsDriverGetFileHandleFromAssets(ml, expect, "funny_cats_site.zip");
-
-    await project.setBlockArgs(blockId, { inputTgzHandle, inputZipHandle });
-
-    await project.runBlock(blockId);
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        13000,
-      )) as InferBlockState<typeof downloadBlobURLModel>;
-      // console.dir(state, { depth: 5 });
-
-      const blockFrontend = await project.getBlockFrontend(blockId).awaitStableValue();
-      expect(blockFrontend).toBeDefined();
-      console.dir(blockFrontend, { depth: 5 });
-
-      const outputs = state.outputs;
-
-      if (outputs.tgz_content.ok) {
-        const url = outputs.tgz_content.value;
-        expect(url).not.toBeUndefined();
-        console.dir(ml.internalDriverKit.blobToURLDriver.info(), { depth: 150 });
-
-        const defaultUrl = ml.internalDriverKit.blobToURLDriver.getPathForCustomProtocol(url);
-        expect(defaultUrl).matches(/.*index.html$/);
-
-        const styles = ml.internalDriverKit.blobToURLDriver.getPathForCustomProtocol(
-          (url + "/styles.css") as FolderURL,
-        );
-
-        expect(styles).matches(/.*\/styles.css/);
-
-        return;
-      }
-    }
-  },
-);
-
-blockTest(
-  "should create upload-file block, render it and upload a file to pl server",
-  async ({ rawPrj: project, ml, expect }) => {
-    const blockId = await project.addBlock("UpdateFile", uploadFileSpec);
-
-    const inputHandle = await lsDriverGetFileHandleFromAssets(
-      ml,
-      expect,
-      "another_answer_to_the_ultimate_question.txt",
-    );
-
-    await project.setBlockArgs(blockId, { inputHandle });
-
-    await project.runBlock(blockId);
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        25000,
-      )) as InferBlockState<typeof uploadFileModel>;
-
-      // console.dir(state, { depth: 5 });
-
-      const outputs = state.outputs;
-      if (outputs.handle.ok && outputs.handle.value != undefined) {
-        expect(outputs.handle.value.isUpload).toBeTruthy();
-        expect(outputs.handle.value.done).toBeTruthy();
-        return;
-      }
-    }
-  },
-);
-
-blockTest(
-  "should create read-logs block, render it and read logs from a file",
-  // The timeout is higher here because pl - core must download a software for this test.
-  { timeout: 20000 },
-  async ({ rawPrj: project, ml, helpers: _helpers, expect }) => {
-    const blockId = await project.addBlock("ReadLogs", readLogsSpec);
-
-    const inputHandle = await lsDriverGetFileHandleFromAssets(
-      ml,
-      expect,
-      "maybe_the_number_of_lines_is_the_answer.txt",
-    );
-
-    await project.setBlockArgs(blockId, {
-      inputHandle,
-      // args are from here:
-      // https://github.com/milaboratory/sleep/blob/3c046cdcc504b63f1a6e592a4aa87ee773a94d72/read-file-to-stdout-with-sleep.go#L24
-      readFileWithSleepArgs: "PREFIX,100,1000",
-    });
-
-    await project.runBlock(blockId);
-
-    while (true) {
-      const state = (await awaitStableState(
-        project.getBlockState(blockId),
-        25000,
-      )) as InferBlockState<typeof readLogsModel>;
-
-      // console.dir(state, { depth: 5 });
-      const outputs = state.outputs;
-
-      if (outputs.lastLogs.ok && outputs.lastLogs.value != undefined) {
-        expect((outputs.progressLog as any).value).toContain("PREFIX");
-        expect((outputs.progressLog as any).value).toContain("bytes read");
-        expect((outputs.lastLogs as any).value.split("\n").length).toEqual(10 + 1); // 11 because the last element is empty
-        return;
-      }
-    }
-  },
-);
-
-async function lsDriverGetFileHandleFromAssets(
-  ml: MiddleLayer,
-  expect: any,
-  fName: string,
-): Promise<ImportFileHandle> {
-  const storages = await ml.driverKit.lsDriver.getStorageList();
-
-  const local = storages.find((s) => s.name == "local");
-  expect(local).not.toBeUndefined();
-
-  const fileDir = path.resolve(__dirname, "..", "..", "..", "assets");
-  const files = await ml.driverKit.lsDriver.listFiles(local!.handle, fileDir);
-
-  const ourFile = files.entries.find((f) => f.name == fName);
-  expect(ourFile).not.toBeUndefined();
-  expect(ourFile?.type).toBe("file");
-
-  return (ourFile as any).handle;
-}
-
-/*
-async function getImportFileHandleFromTmp(
-  ml: MiddleLayer,
-  fName: string,
-  fileSize: number,
-): Promise<ImportFileHandle> {
-  const storages = await ml.driverKit.lsDriver.getStorageList();
-
-  const local = storages.find((s) => s.name == 'local');
-
-  const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'tmp-'));
-  const filePath = path.join(tmpDir, fName);
-
-  console.log('filePath', filePath);
-
-  const buffer = Buffer.alloc(fileSize, 0);
-  fs.writeFileSync(filePath, buffer);
-
-  const files = await ml.driverKit.lsDriver.listFiles(local!.handle, tmpDir);
-
-  const ourFile = files.entries.find((f) => f.name == fName);
-
-  return (ourFile as any).handle;
-}
-*/
-
-function outputRef(blockId: string, name: string, requireEnrichments?: true): PlRef {
-  return { __isRef: true, blockId, name, requireEnrichments };
-}
diff --git a/tests/drivers-ml-blocks-integration/src/ml-v3.test.ts b/tests/drivers-ml-blocks-integration/src/ml-v3.test.ts
index 98164d853c..898fffec7e 100644
--- a/tests/drivers-ml-blocks-integration/src/ml-v3.test.ts
+++ b/tests/drivers-ml-blocks-integration/src/ml-v3.test.ts
@@ -2,10 +2,10 @@ import { BlockPointer as downloadBlobURLSpec } from "@milaboratories/milaborator
 import type { platforma as downloadBlobURLModel } from "@milaboratories/milaboratories.test-blob-url-custom-protocol.model";
 import { BlockPointer as downloadFileSpec } from "@milaboratories/milaboratories.test-download-file";
 import type { platforma as downloadFileModel } from "@milaboratories/milaboratories.test-download-file.model";
-import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers-v3";
+import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers";
 import { BlockPointer as readLogsSpec } from "@milaboratories/milaboratories.test-read-logs";
 import type { platforma as readLogsModel } from "@milaboratories/milaboratories.test-read-logs.model";
-import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers-v3";
+import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers";
 import { BlockPointer as uploadFileSpec } from "@milaboratories/milaboratories.test-upload-file";
 import type { platforma as uploadFileModel } from "@milaboratories/milaboratories.test-upload-file.model";
 import { BlockPointer as transferFilesSpec } from "@milaboratories/milaboratories.transfer-files";
@@ -28,7 +28,7 @@ import { createHash } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { test } from "vitest";
+import { assert, test } from "vitest";
 import { compareBuffersInChunks, computeHashIncremental, shuffleInPlace } from "./imports";
 import { isObject } from "@milaboratories/ts-helpers";
 import { withMl, withMlAndProxy } from "./with-ml";
@@ -130,6 +130,118 @@ test("v3: project list manipulations test", async ({ expect }) => {
   });
 });
 
+test("v3: duplicate project test", async ({ expect }) => {
+  await withMl(async (ml) => {
+    const projectList = ml.projectList;
+
+    // Create source project
+    const srcPrjId = await ml.createProject({ label: "Source Project" });
+    await ml.openProject(srcPrjId);
+    const srcPrj = ml.getOpenedProject(srcPrjId);
+
+    // Add blocks with args
+    const block1Id = await srcPrj.addBlock("Enter Numbers", enterNumberSpec);
+    const block2Id = await srcPrj.addBlock("Sum Numbers", sumNumbersSpec);
+
+    await srcPrj.mutateBlockStorage(block1Id, {
+      operation: "update-block-data",
+      value: { numbers: [10, 20, 30] },
+    });
+    await srcPrj.mutateBlockStorage(block2Id, {
+      operation: "update-block-data",
+      value: { sources: [outputRef(block1Id, "numbers")] },
+    });
+
+    await ml.closeProject(srcPrjId);
+
+    // Duplicate with rename lambda
+    const prjDupId = await ml.duplicateProject(srcPrjId, (prevLabel, existingLabels) => {
+      expect(existingLabels).toContain("Source Project");
+      let candidate = `${prevLabel} (Copy)`;
+      let i = 2;
+      while (existingLabels.includes(candidate)) {
+        candidate = `${prevLabel} (Copy ${i})`;
+        i++;
+      }
+      return candidate;
+    });
+
+    // Verify project list has both projects
+    const list = await projectList.getValue();
+    assert(list);
+    expect(list).toHaveLength(2);
+
+    const srcEntry = list.find((p) => p.id === srcPrjId);
+    const dupEntry = list.find((p) => p.id === prjDupId);
+    assert(srcEntry);
+    assert(dupEntry);
+    expect(srcEntry.meta.label).toBe("Source Project");
+    expect(dupEntry.meta.label).toBe("Source Project (Copy)");
+
+    // Duplicate has different rid and fresh timestamps
+    expect(prjDupId).not.toBe(srcPrjId);
+    expect(dupEntry.created.valueOf()).toBeGreaterThanOrEqual(srcEntry.created.valueOf());
+
+    // Open duplicate and verify structure
+    await ml.openProject(prjDupId);
+    const dupPrj = ml.getOpenedProject(prjDupId);
+
+    const dupOverview = await dupPrj.overview.awaitStableValue();
+    expect(dupOverview.meta.label).toBe("Source Project (Copy)");
+    expect(dupOverview.blocks).toHaveLength(2);
+    expect(dupOverview.blocks[0].title).toBeDefined();
+    expect(dupOverview.blocks[1].title).toBeDefined();
+
+    // Verify source project is unchanged
+    await ml.openProject(srcPrjId);
+    const srcPrj2 = ml.getOpenedProject(srcPrjId);
+    const srcOverview = await srcPrj2.overview.awaitStableValue();
+    expect(srcOverview.meta.label).toBe("Source Project");
+    expect(srcOverview.blocks).toHaveLength(2);
+
+    // Cleanup
+    await ml.closeProject(prjDupId);
+    await ml.closeProject(srcPrjId);
+    await ml.deleteProject(prjDupId);
+    await ml.deleteProject(srcPrjId);
+
+    expect(await projectList.awaitStableValue()).toEqual([]);
+  });
+});
+
+test("v3: duplicate project - name deduplication test", async ({ expect }) => {
+  await withMl(async (ml) => {
+    const projectList = ml.projectList;
+
+    // Create two projects with names that would conflict
+    const prj1Id = await ml.createProject({ label: "My Analysis" });
+    const prj2Id = await ml.createProject({ label: "My Analysis (Copy)" });
+
+    // Duplicate with dedup logic - should skip "My Analysis (Copy)" since it exists
+    const prjDupId = await ml.duplicateProject(prj1Id, (prevLabel, existingLabels) => {
+      let candidate = `${prevLabel} (Copy)`;
+      let i = 2;
+      while (existingLabels.includes(candidate)) {
+        candidate = `${prevLabel} (Copy ${i})`;
+        i++;
+      }
+      return candidate;
+    });
+
+    const list = await projectList.getValue();
+    assert(list);
+    expect(list).toHaveLength(3);
+    const dupEntry = list.find((p) => p.id === prjDupId);
+    assert(dupEntry);
+    expect(dupEntry.meta.label).toBe("My Analysis (Copy 2)");
+
+    // Cleanup
+    await ml.deleteProject(prjDupId);
+    await ml.deleteProject(prj2Id);
+    await ml.deleteProject(prj1Id);
+  });
+});
+
 test("v3: simple project manipulations test", { timeout: 40000 }, async ({ expect }) => {
   await withMl(async (ml) => {
     const projectList = ml.projectList;
@@ -661,7 +773,7 @@ test("v3: block update test", async ({ expect }) => {
 
     // touch
     await fs.promises.appendFile(
-      path.resolve("..", "..", "etc", "blocks", "enter-numbers-v3", "model", "dist", "model.json"),
+      path.resolve("..", "..", "etc", "blocks", "enter-numbers", "model", "dist", "model.json"),
       " ",
     );
 
@@ -803,7 +915,10 @@ blockTest(
       "answer_to_the_ultimate_question.txt",
     );
 
-    await project.setBlockArgs(blockId, { inputHandle });
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: { inputHandle },
+    });
 
     await project.runBlock(blockId);
 
@@ -912,7 +1027,12 @@ blockTest(
       inputHandles.push((ourFile as any).handle);
     }
 
-    await project.setBlockArgs(blockId, { inputHandles });
+    // transfer-files is a V3 block (modelAPIVersion 2); the deprecated
+    // setBlockArgs hardcodes modelAPIVersion 1 and would mismatch.
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: { inputHandles },
+    });
     await project.runBlock(blockId);
 
     async function testChunkedDownload(
@@ -1199,7 +1319,12 @@ blockTest(
       inputHandles.push((ourFile as any).handle);
     }
 
-    await project.setBlockArgs(blockId, { inputHandles });
+    // transfer-files is a V3 block (modelAPIVersion 2); the deprecated
+    // setBlockArgs hardcodes modelAPIVersion 1 and would mismatch.
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: { inputHandles },
+    });
     await project.runBlock(blockId);
 
     while (true) {
@@ -1373,7 +1498,12 @@ blockTest(
     );
     const inputZipHandle = await lsDriverGetFileHandleFromAssets(ml, expect, "funny_cats_site.zip");
 
-    await project.setBlockArgs(blockId, { inputTgzHandle, inputZipHandle });
+    // blob-url-custom-protocol is a V3 block (modelAPIVersion 2); the deprecated
+    // setBlockArgs hardcodes modelAPIVersion 1 and would mismatch.
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: { inputTgzHandle, inputZipHandle },
+    });
 
     await project.runBlock(blockId);
 
@@ -1390,9 +1520,12 @@ blockTest(
 
       const outputs = state.outputs;
 
-      if (outputs.tgz_content.ok) {
+      // `tgz_content` is now derived by a render lambda rather than V1's
+      // config-based extractArchiveAndGetURL, so it resolves as
+      // `FolderURL | undefined` — `ok` can be true before the URL is available.
+      // Keep polling until the value itself settles.
+      if (outputs.tgz_content.ok && outputs.tgz_content.value !== undefined) {
         const url = outputs.tgz_content.value;
-        expect(url).not.toBeUndefined();
         console.dir(ml.internalDriverKit.blobToURLDriver.info(), { depth: 150 });
 
         const defaultUrl = ml.internalDriverKit.blobToURLDriver.getPathForCustomProtocol(url);
@@ -1421,7 +1554,12 @@ blockTest(
       "another_answer_to_the_ultimate_question.txt",
     );
 
-    await project.setBlockArgs(blockId, { inputHandle });
+    // upload-file is a V3 block (modelAPIVersion 2); the deprecated
+    // setBlockArgs hardcodes modelAPIVersion 1 and would mismatch.
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: { inputHandle },
+    });
 
     await project.runBlock(blockId);
 
@@ -1456,11 +1594,16 @@ blockTest(
       "maybe_the_number_of_lines_is_the_answer.txt",
     );
 
-    await project.setBlockArgs(blockId, {
-      inputHandle,
-      // args are from here:
-      // https://github.com/milaboratory/sleep/blob/3c046cdcc504b63f1a6e592a4aa87ee773a94d72/read-file-to-stdout-with-sleep.go#L24
-      readFileWithSleepArgs: "PREFIX,100,1000",
+    // read-logs is a V3 block (modelAPIVersion 2); the deprecated setBlockArgs
+    // hardcodes modelAPIVersion 1 and would mismatch.
+    await project.mutateBlockStorage(blockId, {
+      operation: "update-block-data",
+      value: {
+        inputHandle,
+        // args are from here:
+        // https://github.com/milaboratory/sleep/blob/3c046cdcc504b63f1a6e592a4aa87ee773a94d72/read-file-to-stdout-with-sleep.go#L24
+        readFileWithSleepArgs: "PREFIX,100,1000",
+      },
     });
 
     await project.runBlock(blockId);
diff --git a/tests/drivers-ml-blocks-integration/src/template-cache-v3.test.ts b/tests/drivers-ml-blocks-integration/src/template-cache-v3.test.ts
index c8b87afd7d..3d9ca219fb 100644
--- a/tests/drivers-ml-blocks-integration/src/template-cache-v3.test.ts
+++ b/tests/drivers-ml-blocks-integration/src/template-cache-v3.test.ts
@@ -1,4 +1,4 @@
-import { BlockPointer } from "@milaboratories/milaboratories.test-enter-numbers-v3";
+import { BlockPointer } from "@milaboratories/milaboratories.test-enter-numbers";
 import {
   field,
   isNotNullSignedResourceId,
diff --git a/tests/drivers-ml-blocks-integration/src/template-round-trip.test.ts b/tests/drivers-ml-blocks-integration/src/template-round-trip.test.ts
new file mode 100644
index 0000000000..e83551f4da
--- /dev/null
+++ b/tests/drivers-ml-blocks-integration/src/template-round-trip.test.ts
@@ -0,0 +1,275 @@
+import { BlockPointer as enterNumbersSpec } from "@milaboratories/milaboratories.test-enter-numbers";
+import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers";
+import type { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
+import { createPlRef, resolveTemplateRefs } from "@milaboratories/pl-model-common";
+import type { BlockPackProvider, Project } from "@milaboratories/pl-middle-layer";
+import {
+  parseProjectTemplateV1Yaml,
+  templateBlockPackProvider,
+} from "@milaboratories/pl-middle-layer";
+import { deriveDataFromStorage } from "@platforma-sdk/model";
+import { test } from "vitest";
+import { awaitBlockDone, awaitBlockStateStable } from "./test-helpers";
+import { withMl } from "./with-ml";
+
+/**
+ * Export and apply are inverses: what a project writes out, applying it reads back
+ * into an equivalent project.
+ *
+ * The two halves that only a live project can exercise are `exportProjectAsTemplate`
+ * — which derives every block's params in the model VM off stored block state — and
+ * `applyTemplateToProject`, which resolves, installs and places the blocks against a
+ * real backend. Everything between them (the walk, the serializer, resolution, the
+ * orchestrator, id assignment) is unit-tested in the middle layer; what is proven
+ * here is that the two ends compose.
+ *
+ * Transport is held constant and local. Both test blocks are installed from a built
+ * pack on disk, so their entries carry a `location` and no registry is consulted —
+ * which is why `registryIds` below is empty. Where a block's bytes come from is a
+ * resolution concern behind `BlockPackProvider` and is covered separately; it is not
+ * part of the claim that export and apply are inverses.
+ */
+
+/** How much slack a block gets to compute, cold, on a freshly created project. */
+const RUN_TIMEOUT_MS = 60_000;
+
+/**
+ * How long a block's state may take to settle.
+ *
+ * Well above the helper's own default, which is short enough to abort on a cold render
+ * of a block that was just created — a flake, not a finding.
+ */
+const STATE_TIMEOUT_MS = 60_000;
+
+/** A block's settled state, with a budget that survives a cold machine. */
+async function settled(project: Project, blockId: string) {
+  return await awaitBlockStateStable(project, blockId, STATE_TIMEOUT_MS);
+}
+
+test("v3: a project exported as a template applies back as an equivalent project", async ({
+  expect,
+}) => {
+  await withMl(async (ml) => {
+    // --- A configured, running source project ------------------------------
+
+    const sourceId = await ml.createProject({ label: "Source" });
+    await ml.openProject(sourceId);
+    const source = ml.getOpenedProject(sourceId);
+
+    const numbersId = await source.addBlock("Numbers", enterNumbersSpec);
+    const sumId = await source.addBlock("Sum", sumNumbersSpec);
+
+    // `numbers` is what this block's kind declares; `description` is not, and is set
+    // here to something distinguishable so the trip's boundary is visible below.
+    await source.mutateBlockStorage(numbersId, {
+      operation: "update-block-data",
+      value: { numbers: [1, 2, 3], labels: [], description: "outside the params contract" },
+    });
+    await source.mutateBlockStorage(sumId, {
+      operation: "update-block-data",
+      value: { sources: [createPlRef(numbersId, "numbers")] },
+    });
+
+    await source.runBlock(sumId);
+    await awaitBlockDone(source, sumId, RUN_TIMEOUT_MS);
+
+    const sourceNumbersData = blockData(await settled(source, numbersId));
+    const sourceSumState = await settled(source, sumId);
+    const sourceSumData = blockData(sourceSumState);
+    expect(sourceSumState.outputs!["sum"]).toMatchObject({ ok: true, value: 6 });
+
+    // --- Export ------------------------------------------------------------
+
+    const exported = await ml.exportProjectAsTemplate(sourceId);
+    if (!exported.ok) throw new Error(`export failed: ${JSON.stringify(exported.problems)}`);
+
+    // Entry ids are the source project's own block ids, in structure order.
+    expect(exported.document.blocks.map((entry) => entry.id)).toStrictEqual([numbersId, sumId]);
+
+    // The wiring is in the file, as a reference naming the upstream entry. Asserted
+    // before the comparisons below, which would otherwise be satisfied by two documents
+    // that both carry nothing.
+    expect(exported.document.blocks[0].params).toStrictEqual({ numbers: [1, 2, 3] });
+    expect(exported.document.blocks[1].params).toStrictEqual({
+      sources: [{ block: numbersId, output: "numbers" }],
+    });
+
+    // Both blocks came from a folder on this machine, and each entry says so by
+    // carrying the locator that folder resolves to — which is what makes the apply
+    // below reachable without a registry.
+    for (const entry of exported.document.blocks) {
+      expect(entry.location).toMatch(/^file:\/\//);
+    }
+
+    // --- Apply, from the text and not the document -------------------------
+
+    // The document is already asserted to parse on every export; going through the
+    // YAML is what proves the text a user would save is what the importer reads.
+    const parsed = parseProjectTemplateV1Yaml(exported.yaml);
+    if (!parsed.ok) throw new Error(`the exported YAML did not parse: ${parsed.error}`);
+
+    const targetId = await ml.createProject({ label: "Target" });
+    const report = await ml.applyTemplateToProject(targetId, parsed.document, localPacksOnly());
+
+    expect(report.problems).toStrictEqual([]);
+    expect(report.added.map((entry) => entry.templateLocalId)).toStrictEqual([numbersId, sumId]);
+
+    const appliedId = new Map(report.added.map((entry) => [entry.templateLocalId, entry.blockId]));
+    // Applied blocks are new blocks with new ids, which is why equivalence below is
+    // stated up to renaming rather than as equality of ids.
+    expect(appliedId.get(numbersId)).not.toBe(numbersId);
+
+    // --- 1. The applied project exports to the same template ---------------
+
+    const reExported = await ml.exportProjectAsTemplate(targetId);
+    if (!reExported.ok) throw new Error(`re-export failed: ${JSON.stringify(reExported.problems)}`);
+
+    expect(canonical(reExported.document)).toStrictEqual(canonical(exported.document));
+
+    // --- 2. Every block starts with the state its source block held --------
+
+    await ml.openProject(targetId);
+    const target = ml.getOpenedProject(targetId);
+
+    // Bounded by the params contract, and only by it. `numbers` is declared by the kind
+    // and arrives intact; `description` is not, so the applied block holds what its own
+    // init produces instead of what the source block held. A block's fidelity is
+    // therefore its own choice of what to project into params — silent for anything left
+    // out, which is why this asserts the loss rather than looking away from it.
+    expect(sourceNumbersData).toMatchObject({ description: "outside the params contract" });
+    expect(blockData(await settled(target, appliedId.get(numbersId)!))).toStrictEqual({
+      numbers: [1, 2, 3],
+      labels: [],
+      description: "",
+    });
+
+    // The one field that must differ: the reference now names the block the apply
+    // created, not the one it was exported from.
+    expect(blockData(await settled(target, appliedId.get(sumId)!))).toStrictEqual(
+      renameInLiveParams(sourceSumData, appliedId),
+    );
+
+    // --- 3. And the applied project computes what the source computed ------
+
+    const appliedSumId = appliedId.get(sumId)!;
+    await target.runBlock(appliedSumId);
+    await awaitBlockDone(target, appliedSumId, RUN_TIMEOUT_MS);
+    expect((await settled(target, appliedSumId)).outputs!["sum"]).toMatchObject({
+      ok: true,
+      value: 6,
+    });
+  });
+});
+
+test("v3: a block whose params name a deleted block cannot be exported", async ({ expect }) => {
+  await withMl(async (ml) => {
+    const projectId = await ml.createProject({ label: "With a dangling reference" });
+    await ml.openProject(projectId);
+    const project = ml.getOpenedProject(projectId);
+
+    const numbersId = await project.addBlock("Numbers", enterNumbersSpec);
+    const sumId = await project.addBlock("Sum", sumNumbersSpec);
+    await project.mutateBlockStorage(sumId, {
+      operation: "update-block-data",
+      value: { sources: [createPlRef(numbersId, "numbers")] },
+    });
+    await settled(project, sumId);
+
+    // Deleting a block removes it from the structure and leaves downstream params
+    // naming it, so the reference survives into the file pointing at nothing. All or
+    // nothing: no partial template is written.
+    await project.deleteBlock(numbersId);
+    await settled(project, sumId);
+
+    const exported = await ml.exportProjectAsTemplate(projectId);
+    expect(exported.ok).toBe(false);
+    if (exported.ok) return;
+    expect(exported.problems.map((problem) => problem.blockId)).toStrictEqual([sumId]);
+  });
+});
+
+/** A block's current data, as the model sees it. */
+function blockData(state: Awaited<ReturnType<typeof awaitBlockStateStable>>): unknown {
+  return deriveDataFromStorage(state.blockStorage);
+}
+
+/**
+ * A provider for a document whose every entry names a place on this machine.
+ *
+ * Configuring no registries is not a shortcut: a located entry is resolved by reading
+ * the folder it names, and consulting a registry for one would be a bug. With the list
+ * empty there is nothing for the kind route to read, so an entry that reached it would
+ * fail the apply rather than pass quietly.
+ */
+function localPacksOnly(): BlockPackProvider {
+  return templateBlockPackProvider({
+    registry: {
+      resolveKind: () => {
+        throw new Error("a located entry must not consult a registry");
+      },
+      getOverview: () => {
+        throw new Error("a located entry must not consult a registry");
+      },
+    },
+    registryIds: [],
+    logger: {
+      info: (msg) => console.log(msg),
+      warn: (msg) => console.warn(msg),
+      error: (msg) => console.error(msg),
+    },
+  });
+}
+
+/**
+ * A document with every entry id replaced by its position, references included.
+ *
+ * Two exports of the same pipeline can never be textually equal: the entry ids are the
+ * project's block ids, and applying a template creates new blocks with new ids. What
+ * "equivalent" has to mean is therefore equality up to that renaming — same blocks, in
+ * the same order, with the same kinds, the same locators and the same params, wired the
+ * same way. Position is the right name to canonicalize to because the list's order is
+ * itself part of the document's meaning: it is the instantiation order.
+ *
+ * Not covered, deliberately: a block's label, which is an instance name a template does
+ * not carry, and any block state outside what the block projects into params. Both are
+ * lost by design, and the assertions above pin each one where it is visible rather than
+ * hiding them in here.
+ */
+function canonical(document: ProjectTemplateV1): ProjectTemplateV1 {
+  const positionOf = new Map(document.blocks.map((entry, i) => [entry.id, `b${i}`]));
+
+  // Renaming goes through the engine's own redirect, so this recognizes exactly the
+  // references the engine recognizes — reimplementing the walk here would let the comparison
+  // agree with a bug instead of catching it. Note it rewrites INSIDE the wrappers and leaves
+  // them in place, which is what a document holds.
+  const blocks = document.blocks.map((entry, i) => ({
+    ...entry,
+    id: `b${i}`,
+    ...(entry.params !== undefined ? { params: renameInsideRefs(entry.params, positionOf) } : {}),
+  }));
+
+  return { ...document, blocks };
+}
+
+/** Redirect the block ids inside every reference wrapper, keeping the wrappers. */
+function renameInsideRefs(
+  params: Record<string, unknown>,
+  newIdOf: ReadonlyMap<string, string>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [key, renameInLiveParams(value, newIdOf)]),
+  );
+}
+
+/**
+ * Rename the blocks named by references inside a value — live params, or one reference
+ * payload.
+ *
+ * Wrapping the value and resolving it back is the engine's own redirect, applied to
+ * something that is not a document. Re-implementing the walk here would let the comparison
+ * agree with a bug instead of catching it.
+ */
+function renameInLiveParams(value: unknown, newIdOf: ReadonlyMap<string, string>): unknown {
+  const wrapped = resolveTemplateRefs({ $ref: value }, newIdOf);
+  return wrapped;
+}
diff --git a/tests/drivers-ml-blocks-integration/src/v2.test.ts b/tests/drivers-ml-blocks-integration/src/v2.test.ts
deleted file mode 100644
index 2b8ddf0cfe..0000000000
--- a/tests/drivers-ml-blocks-integration/src/v2.test.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers";
-import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers";
-import { test } from "vitest";
-import { withMl } from "./with-ml";
-import { awaitBlockDone, createProjectWatcher, outputRef } from "./test-helpers";
-
-import { BlockDumpArraySchemaUnified } from "./unified-state-schema";
-
-// v2/v1 ui api test
-test("v2: temp test", { timeout: 10_000 }, async ({ expect }) => {
-  await withMl(async (ml, workFolder) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    expect(prj.id).toBe(prj1Id);
-
-    const enterNumberId = await prj.addBlock("Block 1", enterNumberSpec);
-    const sumNumbersId = await prj.addBlock("Block 2", sumNumbersSpec);
-
-    const projectWatcher = await createProjectWatcher(ml, prj, {
-      workFolder,
-      validator: BlockDumpArraySchemaUnified,
-    });
-
-    console.log(">>>> projectWatcher dump", projectWatcher.dump);
-
-    const overview0 = await prj.overview.awaitStableValue();
-    overview0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false); // should be false because numbers length is 0
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    console.log(">>>> before setBlockArgs");
-
-    await prj.setBlockArgs(enterNumberId, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(sumNumbersId, { sources: [outputRef(enterNumberId, "numbers")] });
-
-    const overview1 = await prj.overview.awaitStableValue();
-
-    overview1.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(true);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await projectWatcher.abort();
-  });
-});
-
-test("v2: project watcher test", { timeout: 10_000 }, async ({ expect }) => {
-  await withMl(async (ml, workFolder) => {
-    const prj1Id = await ml.createProject({ label: "Project 1" });
-    await ml.openProject(prj1Id);
-    const prj = ml.getOpenedProject(prj1Id);
-
-    expect(prj.id).toBe(prj1Id);
-
-    const enterNumberId = await prj.addBlock("Block 1", enterNumberSpec);
-    const sumNumbersId = await prj.addBlock("Block 2", sumNumbersSpec);
-
-    const projectWatcher = await createProjectWatcher(ml, prj, {
-      workFolder,
-      validator: BlockDumpArraySchemaUnified,
-    });
-
-    console.log(">>>> projectWatcher dump", projectWatcher.dump);
-
-    const overview0 = await prj.overview.awaitStableValue();
-    overview0.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    console.log(">>>> before setBlockArgs");
-
-    await prj.setBlockArgs(enterNumberId, { numbers: [1, 2, 3] });
-    await prj.setBlockArgs(sumNumbersId, { sources: [outputRef(enterNumberId, "numbers")] });
-
-    const overview1 = await prj.overview.awaitStableValue();
-
-    overview1.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.canRun).toEqual(true);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.runBlock(sumNumbersId);
-    await awaitBlockDone(prj, sumNumbersId);
-
-    const block2StableState1 = await prj.getBlockState(sumNumbersId).getValue();
-    expect(block2StableState1.outputs!["sum"]).toStrictEqual({
-      ok: true,
-      value: 6,
-      stable: true,
-    });
-
-    const overview2 = await prj.overview.awaitStableValue();
-    overview2.blocks.forEach((block) => {
-      expect(block.sections).toBeDefined();
-      expect(block.calculationStatus).toEqual("Done");
-      expect(block.canRun).toEqual(false);
-      expect(block.currentBlockPack).toBeDefined();
-    });
-
-    await prj.setBlockArgs(enterNumberId, { numbers: [2, 3] });
-    await prj.runBlock(enterNumberId);
-    await awaitBlockDone(prj, enterNumberId);
-
-    const overview3 = await prj.overview.awaitStableValue();
-    const [overview3Block1, overview3Block2] = overview3.blocks;
-    expect(overview3Block1.calculationStatus).toEqual("Done");
-    expect(overview3Block2.calculationStatus).toEqual("Limbo");
-
-    await prj.runBlock(sumNumbersId);
-    await awaitBlockDone(prj, sumNumbersId);
-    console.log("block done 2");
-
-    const block2StableState2 = await prj.getBlockState(sumNumbersId).getValue();
-    expect(block2StableState2.outputs!["sum"]).toStrictEqual({
-      ok: true,
-      value: 5,
-      stable: true,
-    });
-
-    const overview4 = await prj.overview.awaitStableValue();
-    const [overview4Block1, overview4Block2] = overview4.blocks;
-    expect(overview4Block1.calculationStatus).toEqual("Done");
-    expect(overview4Block2.calculationStatus).toEqual("Done");
-    await projectWatcher.abort();
-  });
-});
diff --git a/tests/drivers-ml-blocks-integration/src/v3.test.ts b/tests/drivers-ml-blocks-integration/src/v3.test.ts
index 4d3a737be6..4ae7dea346 100644
--- a/tests/drivers-ml-blocks-integration/src/v3.test.ts
+++ b/tests/drivers-ml-blocks-integration/src/v3.test.ts
@@ -1,5 +1,5 @@
-import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers-v3";
-import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers-v3";
+import { BlockPointer as enterNumberSpec } from "@milaboratories/milaboratories.test-enter-numbers";
+import { BlockPointer as sumNumbersSpec } from "@milaboratories/milaboratories.test-sum-numbers";
 import { test } from "vitest";
 import { withMl } from "./with-ml";
 import {
@@ -189,6 +189,8 @@ test("v3: project watcher test", { timeout: 20_000 }, async ({ expect }) => {
       expect(sumNumbersBlock?.calculationStatus).toBe("NotCalculated");
       expect(sumNumbersBlock?.canRun).toBe(false);
       expect(enterNumberBlock?.sections).toBeDefined(); // should be defined
+      expect(enterNumberBlock?.currentBlockPack).toBeDefined();
+      expect(sumNumbersBlock?.currentBlockPack).toBeDefined();
     });
 
     // v3 state format: direct state object (not wrapped in {args: ...})
@@ -228,6 +230,8 @@ test("v3: project watcher test", { timeout: 20_000 }, async ({ expect }) => {
       expect(enterNumberBlock?.canRun).toBe(false);
       expect(sumNumbersBlock?.calculationStatus).toBe("Done");
       expect(sumNumbersBlock?.canRun).toBe(false);
+      expect(enterNumberBlock?.currentBlockPack).toBeDefined();
+      expect(sumNumbersBlock?.currentBlockPack).toBeDefined();
     });
 
     await prj.mutateBlockStorage(enterNumberId, {
diff --git a/tests/mcp-server/src/blocks.test.ts b/tests/mcp-server/src/blocks.test.ts
index 631aa520b5..9b31a7c343 100644
--- a/tests/mcp-server/src/blocks.test.ts
+++ b/tests/mcp-server/src/blocks.test.ts
@@ -15,7 +15,7 @@ const enterNumbersBlockFolder = path.resolve(
   "..",
   "etc",
   "blocks",
-  "enter-numbers-v3",
+  "enter-numbers",
   "block",
 );
 
diff --git a/tests/mcp-server/src/pipeline.test.ts b/tests/mcp-server/src/pipeline.test.ts
index 729da45e13..b320c1aea4 100644
--- a/tests/mcp-server/src/pipeline.test.ts
+++ b/tests/mcp-server/src/pipeline.test.ts
@@ -15,7 +15,7 @@ const enterNumbersBlockFolder = path.resolve(
   "..",
   "etc",
   "blocks",
-  "enter-numbers-v3",
+  "enter-numbers",
   "block",
 );
 
diff --git a/tests/mcp-server/src/state.test.ts b/tests/mcp-server/src/state.test.ts
index f19daf981f..bf51ad9d23 100644
--- a/tests/mcp-server/src/state.test.ts
+++ b/tests/mcp-server/src/state.test.ts
@@ -15,7 +15,7 @@ const enterNumbersBlockFolder = path.resolve(
   "..",
   "etc",
   "blocks",
-  "enter-numbers-v3",
+  "enter-numbers",
   "block",
 );
 
diff --git a/tools/block-tools/src/cli.test.ts b/tools/block-tools/src/cli.test.ts
index 4ab957b226..10915bc201 100644
--- a/tools/block-tools/src/cli.test.ts
+++ b/tools/block-tools/src/cli.test.ts
@@ -15,8 +15,9 @@ function longNames(cmd: Command): string[] {
 describe("block-tools CLI structure", () => {
   const program = buildProgram();
 
-  it("exposes the full command surface (11 commands + structure topic)", () => {
+  it("exposes the full command surface (12 commands + structure topic)", () => {
     expect(program.commands.map((c) => c.name()).sort()).toEqual([
+      "build-kind-manifest",
       "build-meta",
       "build-model",
       "list-overview-snapshots",
diff --git a/tools/block-tools/src/cli.ts b/tools/block-tools/src/cli.ts
index 9d5e7ea8dc..2b43bd23b7 100644
--- a/tools/block-tools/src/cli.ts
+++ b/tools/block-tools/src/cli.ts
@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { buildMetaCommand } from "./cmd/build-meta";
 import { buildModelCommand } from "./cmd/build-model";
+import { buildKindManifestCommand } from "./cmd/build-kind-manifest";
 import { packCommand } from "./cmd/pack";
 import { publishCommand } from "./cmd/publish";
 import { refreshRegistryCommand } from "./cmd/refresh-registry";
@@ -25,6 +26,7 @@ export function buildProgram(packageRoot: string = process.cwd()): Command {
 
   program.addCommand(buildMetaCommand());
   program.addCommand(buildModelCommand());
+  program.addCommand(buildKindManifestCommand());
   program.addCommand(packCommand());
   program.addCommand(publishCommand());
   program.addCommand(refreshRegistryCommand());
diff --git a/tools/block-tools/src/cmd/build-kind-manifest.ts b/tools/block-tools/src/cmd/build-kind-manifest.ts
new file mode 100644
index 0000000000..d274a3f8a5
--- /dev/null
+++ b/tools/block-tools/src/cmd/build-kind-manifest.ts
@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { buildKindDist } from "../v2/build_kind_dist";
+
+// @todo: disscuss why we need manifest for kind
+
+/**
+ * Thin commander wrapper (build-model.ts shape) delegating to the commander-free
+ * `buildKindDist` core. Bundles the compiled kind's identity + src source-hash
+ * into `dist/manifest.json`.
+ */
+export function buildKindManifestCommand(): Command {
+  const cmd = new Command("build-kind-manifest").description(
+    "Writes the block-kind dist manifest (identity + src source-hash) from a pre-built kind bundle",
+  );
+
+  cmd.option(
+    "-i, --modulePath <path>",
+    "kind package dir (contains package.json, src/, dist/)",
+    ".",
+  );
+  cmd.option(
+    "-s, --srcDir <path>",
+    "source dir hashed into sourceHash, relative to modulePath",
+    "src",
+  );
+  cmd.option(
+    "-o, --dst <path>",
+    "output dir with the compiled bundle, relative to modulePath",
+    "dist",
+  );
+
+  cmd.action(async (flags) => {
+    await buildKindDist({
+      modulePath: flags.modulePath,
+      srcDir: flags.srcDir,
+      dst: flags.dst,
+    });
+  });
+
+  return cmd;
+}
diff --git a/tools/block-tools/src/cmd/publish.ts b/tools/block-tools/src/cmd/publish.ts
index 46f4f87c85..5ffd2b0d42 100644
--- a/tools/block-tools/src/cmd/publish.ts
+++ b/tools/block-tools/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 { publishBlock } from "../v2/publish-block";
 import { buildPublishedCoords, writePublishedCoords } from "../v2/resolve_to_registry";
 import path from "node:path";
 
@@ -82,15 +83,23 @@ export function publishCommand(): Command {
       manifest as BlockPackManifest & Record<string, unknown>,
     );
     const manifestRoot = path.dirname(manifestPath);
+    // The facade package root holds `package.json` (with the direct kind
+    // dependency the kind-first publish reads); the manifest sits one level down
+    // in `block-pack/`. `readFacadeKindDependency`/`resolveFacadeKind` need the
+    // package root, not the block-pack dir.
+    const facadeDir = path.dirname(manifestRoot);
 
     logger.info(`Manifest root = ${manifestRoot}`);
+    logger.info(`Facade root = ${facadeDir}`);
 
     if (flags.versionOverride) manifest = overrideManifestVersion(manifest, flags.versionOverride);
 
     const storage = storageByUrl(flags.registry);
     const registry = new BlockRegistryV2(storage, logger);
 
-    await registry.publishPackage(manifest, async (file) =>
+    // Kind-first publish: resolve refs -> version-match gate (before any S3
+    // write) -> publishKind (if the block declares a kind) -> publishPackage.
+    await publishBlock(registry, manifest, facadeDir, async (file) =>
       Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file))),
     );
 
diff --git a/tools/block-tools/src/structure/__tests__/model-package-json.snapshot.test.ts b/tools/block-tools/src/structure/__tests__/model-package-json.snapshot.test.ts
index 89d9392387..b96fa61b17 100644
--- a/tools/block-tools/src/structure/__tests__/model-package-json.snapshot.test.ts
+++ b/tools/block-tools/src/structure/__tests__/model-package-json.snapshot.test.ts
@@ -29,6 +29,7 @@ const EXPECTED_MODEL_PACKAGE_JSON = `{
     "check": "ts-builder check --target block-model"
   },
   "dependencies": {
+    "@platforma-open/test-org.demo.kind": "workspace:*",
     "@platforma-sdk/model": "catalog:"
   },
   "devDependencies": {
diff --git a/tools/block-tools/src/structure/engine/api.ts b/tools/block-tools/src/structure/engine/api.ts
index cabfd410bc..d70bf91418 100644
--- a/tools/block-tools/src/structure/engine/api.ts
+++ b/tools/block-tools/src/structure/engine/api.ts
@@ -10,7 +10,7 @@
 
 import type { ContentForm, ManagedBody, RunMode, Structure, TriggerFn } from "./ir";
 
-export type Scope = "root" | "block" | "model" | "ui" | "workflow" | "test" | "software";
+export type Scope = "root" | "block" | "model" | "ui" | "workflow" | "test" | "software" | "kind";
 
 /** Variables describing a block — populated by `init` or parsed by
  *  `check`/`refresh` from the block's package.json `name`. */
diff --git a/tools/block-tools/src/structure/engine/ctx.ts b/tools/block-tools/src/structure/engine/ctx.ts
index 21e5f123ae..0c48cd74e2 100644
--- a/tools/block-tools/src/structure/engine/ctx.ts
+++ b/tools/block-tools/src/structure/engine/ctx.ts
@@ -55,6 +55,7 @@ export function modulesForInit(vars: BlockVars): Module[] {
     { scope: "root", name: facade, path: "" },
     { scope: "block", name: `${facade}.block`, path: "block" },
     { scope: "model", name: `${facade}.model`, path: "model" },
+    { scope: "kind", name: `${facade}.kind`, path: "kind" },
     { scope: "ui", name: `${facade}.ui`, path: "ui" },
     { scope: "workflow", name: `${facade}.workflow`, path: "workflow" },
     { scope: "test", name: `${facade}.test`, path: "test" },
diff --git a/tools/block-tools/src/structure/engine/discovery.ts b/tools/block-tools/src/structure/engine/discovery.ts
index 5172c0b54a..5f8ee6264e 100644
--- a/tools/block-tools/src/structure/engine/discovery.ts
+++ b/tools/block-tools/src/structure/engine/discovery.ts
@@ -1,4 +1,4 @@
-// Workspace-package classification — the seven scope detection rules.
+// Workspace-package classification — the eight scope detection rules.
 //
 // Input: the parsed package.json of every workspace member, plus its
 // block-relative path. Output: `Module[]` (scope + name + path).
@@ -7,7 +7,16 @@
 
 import type { Module, Scope } from "./api";
 
-export const ALL_SCOPES: Scope[] = ["root", "block", "model", "ui", "workflow", "test", "software"];
+export const ALL_SCOPES: Scope[] = [
+  "root",
+  "block",
+  "model",
+  "ui",
+  "workflow",
+  "test",
+  "software",
+  "kind",
+];
 
 export type WorkspacePackage = {
   /** Block-relative path of the package — "" or "." means the
@@ -96,6 +105,11 @@ export function classifyOne(wp: WorkspacePackage): Scope | undefined {
 
   const deps = depKeys(wp.pkg);
 
+  // kind — @platforma-sdk/block-kind is unique to kind packages (no other scope
+  // depends on it). MUST precede the model rule: a kind sets `main`, and were it
+  // to carry any model-ish signal it would otherwise misclassify.
+  if (deps.has("@platforma-sdk/block-kind")) return "kind";
+
   // 1. software — top-level `block-software` field OR
   //    (package-builder AND any @platforma-open/*runenv* dep).
   if (wp.pkg["block-software"] !== undefined) return "software";
diff --git a/tools/block-tools/src/structure/rules/block-package-json.ts b/tools/block-tools/src/structure/rules/block-package-json.ts
index 2a5478ebb6..b9424d65ed 100644
--- a/tools/block-tools/src/structure/rules/block-package-json.ts
+++ b/tools/block-tools/src/structure/rules/block-package-json.ts
@@ -153,6 +153,11 @@ export function blockPackageJsonInitial(ctx: RunContext): Record<string, unknown
     ...scopeDepMaps(ctx, "model"),
     ...scopeDepMaps(ctx, "ui"),
     ...scopeDepMaps(ctx, "workflow"),
+    // The kind is a fourth block component the facade depends on directly (the
+    // tetrad); like its siblings it is a build-time workspace devDep, never a
+    // runtime dependency, and it is NOT a bundled `block.component` (its content
+    // publishes to the `kinds/` registry tree, not into block-pack).
+    ...scopeDepMaps(ctx, "kind"),
   };
   // `block-tools pack` requires both `block.components` and `block.meta`. The
   // author edits the placeholder meta before publishing.
@@ -194,6 +199,18 @@ export function blockPackageJsonInitial(ctx: RunContext): Record<string, unknown
 export function blockPackageJsonRules(ctx: RunContext): void {
   const v = ctx.blockVars;
 
+  // The kind is a MANDATORY block component: every block must declare exactly
+  // one sibling `kind/` package. Fail loudly otherwise — a kind-less block is
+  // invalid, and this is what surfaces the not-yet-migrated blocks.
+  const kindModules = findModules(ctx, "kind");
+  if (kindModules.length !== 1) {
+    throw new Error(
+      kindModules.length === 0
+        ? `block '${v.facadeName}' declares no kind — every block must have a sibling kind/ package`
+        : `block '${v.facadeName}' declares ${kindModules.length} kinds; exactly one is required`,
+    );
+  }
+
   ensureField("type", "module");
   ensureField("files", ["dist", "block-pack"]);
   ensureField("main", "./dist/index.js");
@@ -212,6 +229,7 @@ export function blockPackageJsonRules(ctx: RunContext): void {
   ensureWorkspaceScopeDevDeps("model");
   ensureWorkspaceScopeDevDeps("ui");
   ensureWorkspaceScopeDevDeps("workflow");
+  ensureWorkspaceScopeDevDeps("kind");
   ensureDevDep("@milaboratories/ts-builder", "sdk:");
   ensureDevDep("@milaboratories/ts-configs", "sdk:");
   ensureDevDep("@platforma-sdk/block-tools", "sdk:");
diff --git a/tools/block-tools/src/structure/rules/kind-package-json.ts b/tools/block-tools/src/structure/rules/kind-package-json.ts
new file mode 100644
index 0000000000..c2ffc7fe77
--- /dev/null
+++ b/tools/block-tools/src/structure/rules/kind-package-json.ts
@@ -0,0 +1,117 @@
+// Kind `package.json`: the initial generator and the drift-correcting body,
+// co-located. A kind is a private workspace sibling (like the model): its
+// content ships to the `kinds/` registry tree via `build-kind-manifest`, not to
+// npm. Identity (name/version) stays untouched; the body enforces
+// type/main/exports + canonical scripts + canonical dep sets, then projects
+// canonical field / dependency order (oxfmt-clean, so build->check passes with
+// no prior `pnpm fmt`).
+//
+// A kind builds TWICE, like the model: `dist/index.{js,cjs}` with dependencies
+// external — what a block imports — and the self-contained `dist/kind.js` that
+// the registry publishes and `build-kind-manifest` hashes. The `exports` map
+// points at the externalized pair only, so a kind and the block implementing it
+// share one copy of any dependency they both use; the self-contained bundle is
+// read off disk by the manifest builder and needs no export.
+//
+// All three of `import` / `require` / `default` are spelled out: `block-tools
+// build-model` loads the model via `require()`, and the model `require`s its
+// kind, so the CJS arm has to resolve to real CJS.
+
+import {
+  ensureField,
+  ensureScript,
+  ensureDep,
+  ensureDevDeps,
+  ensurePeerDeps,
+  removeScript,
+  enforceAlphabeticalOrder,
+  enforceFieldOrder,
+  type RunContext,
+} from "../engine/api";
+import { canonicalPackageJsonOrder } from "./shared/key-order";
+
+const KIND_EXPORTS = {
+  ".": {
+    types: "./dist/index.d.ts",
+    sources: "./src/index.ts",
+    import: "./dist/index.js",
+    require: "./dist/index.cjs",
+    default: "./dist/index.js",
+  },
+};
+
+export function kindPackageJsonInitial(ctx: RunContext): Record<string, unknown> {
+  const v = ctx.blockVars;
+  return {
+    name: `${v.facadeName}.kind`,
+    private: true,
+    type: "module",
+    // `main` is the CommonJS entry (require fallback), `module` the ESM one —
+    // the model's convention. `dist/kind.js`, the self-contained bundle, is
+    // deliberately not an entry: it exists for the registry, not for importers.
+    main: "./dist/index.cjs",
+    module: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: KIND_EXPORTS,
+    scripts: {
+      fmt: "ts-builder format",
+      watch: "ts-builder build --target block-kind --watch",
+      build: "ts-builder build --target block-kind && block-tools build-kind-manifest",
+      check: "ts-builder check --target block-kind",
+    },
+    dependencies: {
+      "@platforma-sdk/block-kind": "sdk:",
+      // A kind ships a runtime params check, so it is not a types-only package. zod is
+      // the default the scaffolded parser is written against; an author who validates by
+      // hand can drop this, which is why it is seeded rather than asserted on refresh.
+      zod: "catalog:",
+    },
+    devDependencies: {
+      "@milaboratories/ts-builder": "sdk:",
+      "@milaboratories/ts-configs": "sdk:",
+      "@platforma-sdk/block-tools": "sdk:",
+    },
+    peerDependencies: {
+      "@types/node": "*",
+      typescript: "*",
+    },
+  };
+}
+
+export function kindPackageJsonRules(): void {
+  // Controlled sibling — workspace-only, never published to npm. `private: true`
+  // makes npm refuse to publish it; the `version` is kept (changesets-owned) and
+  // is what the kind's on-wire `{name}@{version}` reference is baked from.
+  ensureField("private", true);
+
+  ensureField("type", "module");
+  ensureField("main", "./dist/index.cjs");
+  ensureField("module", "./dist/index.js");
+  ensureField("types", "./dist/index.d.ts");
+  ensureField("exports", KIND_EXPORTS);
+
+  ensureScript("fmt", "ts-builder format");
+  ensureScript("watch", "ts-builder build --target block-kind --watch");
+  ensureScript("build", "ts-builder build --target block-kind && block-tools build-kind-manifest");
+  ensureScript("check", "ts-builder check --target block-kind");
+  removeScript("lint");
+
+  ensureDep("@platforma-sdk/block-kind", "sdk:");
+
+  ensureDevDeps({
+    "@milaboratories/ts-builder": "sdk:",
+    "@milaboratories/ts-configs": "sdk:",
+    "@platforma-sdk/block-tools": "sdk:",
+  });
+
+  ensurePeerDeps({
+    "@types/node": "*",
+    typescript: "*",
+  });
+
+  enforceAlphabeticalOrder("dependencies");
+  enforceAlphabeticalOrder("devDependencies");
+  enforceAlphabeticalOrder("peerDependencies");
+  enforceAlphabeticalOrder("optionalDependencies");
+  enforceFieldOrder([...canonicalPackageJsonOrder]);
+}
diff --git a/tools/block-tools/src/structure/rules/kind.ts b/tools/block-tools/src/structure/rules/kind.ts
new file mode 100644
index 0000000000..ba5e5c2ed2
--- /dev/null
+++ b/tools/block-tools/src/structure/rules/kind.ts
@@ -0,0 +1,29 @@
+// Kind-scope rules. Static config files + managed package.json; the
+// `src/index.ts` seed is dropped by `init` and never touched again (the block
+// author owns the BlockParams contract). The seed is a deliberate non-building
+// sentinel — its BlockParams is undefined, so a scaffolded-but-unmigrated block
+// fails to typecheck until the params contract is chosen on purpose.
+
+import { scope, fixed, managed, seed, file, generate } from "../engine/api";
+import { kindPackageJsonInitial, kindPackageJsonRules } from "./kind-package-json";
+
+export function kindRules(): void {
+  scope("kind", () => {
+    fixed("tsconfig.json", file("kind/tsconfig.json"));
+    fixed(".oxlintrc.json", file("kind/.oxlintrc.json"));
+    fixed(".oxfmtrc.json", file("kind/.oxfmtrc.json"));
+
+    // Minimal-but-real kind: identity imported from the package's own
+    // package.json, plus a non-building BlockParams sentinel the block author
+    // must resolve (via the migration recipe or by hand) before the block builds.
+    seed("src/index.ts", file("kind/src/index.ts"));
+
+    managed(
+      "package.json",
+      generate((ctx) => kindPackageJsonInitial(ctx)),
+      () => {
+        kindPackageJsonRules();
+      },
+    );
+  });
+}
diff --git a/tools/block-tools/src/structure/rules/model-package-json.ts b/tools/block-tools/src/structure/rules/model-package-json.ts
index e7970a3a88..95039eb772 100644
--- a/tools/block-tools/src/structure/rules/model-package-json.ts
+++ b/tools/block-tools/src/structure/rules/model-package-json.ts
@@ -15,6 +15,7 @@ import {
   ensureDep,
   ensureDevDep,
   ensureDevDeps,
+  ensureWorkspaceScopeDeps,
   removeDep,
   removeScript,
   removeField,
@@ -25,6 +26,7 @@ import {
   whenFilesExist,
   type RunContext,
 } from "../engine/api";
+import { scopeDepMaps } from "../engine/ctx";
 import { canonicalPackageJsonOrder } from "./shared/key-order";
 import { COLOCATED_TEST_GLOB } from "./shared/colocated-tests";
 import { removeRetiredToolchainDeps } from "./shared/retired-deps";
@@ -56,6 +58,9 @@ export function modelPackageJsonInitial(ctx: RunContext): Record<string, unknown
     },
     dependencies: {
       "@platforma-sdk/model": "sdk:",
+      // The model imports its block's kind (to bake the kind reference into
+      // model.json), so it depends on the sibling kind package directly.
+      ...scopeDepMaps(ctx, "kind"),
     },
     devDependencies: {
       "@milaboratories/ts-builder": "sdk:",
@@ -95,6 +100,9 @@ export function modelPackageJsonRules(): void {
   ensureScript("check", "ts-builder check --target block-model");
 
   ensureDep("@platforma-sdk/model", "sdk:");
+  // The model imports its block's kind to bake the kind reference — direct
+  // dependency on the sibling kind package.
+  ensureWorkspaceScopeDeps("kind");
 
   ensureDevDeps({
     "@milaboratories/ts-builder": "sdk:",
diff --git a/tools/block-tools/src/structure/rules/model.ts b/tools/block-tools/src/structure/rules/model.ts
index 30dfdb60d5..941cccd4d7 100644
--- a/tools/block-tools/src/structure/rules/model.ts
+++ b/tools/block-tools/src/structure/rules/model.ts
@@ -2,17 +2,22 @@
 // `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 } from "../engine/api";
+import {
+  scope,
+  fixed,
+  managed,
+  seed,
+  file,
+  tpl,
+  generate,
+  when,
+  whenFilesExist,
+} from "../engine/api";
 import { modelPackageJsonInitial, modelPackageJsonRules } from "./model-package-json";
 import { COLOCATED_TEST_GLOB } from "./shared/colocated-tests";
 
 export function modelRules(): void {
   scope("model", () => {
-    // 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")),
@@ -21,13 +26,10 @@ export function modelRules(): void {
     fixed(".oxlintrc.json", file("model/.oxlintrc.json"));
     fixed(".oxfmtrc.json", file("model/.oxfmtrc.json"));
 
-    // A minimal-but-REAL BlockModelV3: `build-model` rejects a non-model
-    // export ("Malformed model object"), and a bare `.create(dataModel)`
-    // still errors ("Args rendering function not set"). This seed is the
-    // smallest chain that produces a valid `dist/model.json` — empty data
-    // model, identity args, a single "Main" section. The block author owns
-    // and extends it after init.
-    seed("src/index.ts", file("model/src/index.ts"));
+    seed(
+      "src/index.ts",
+      tpl("model/src/index.tpl.ts", (ctx) => ({ kindPkg: `${ctx.blockVars.facadeName}.kind` })),
+    );
 
     managed(
       "package.json",
diff --git a/tools/block-tools/src/structure/rules/shared/pascal-case.ts b/tools/block-tools/src/structure/rules/shared/pascal-case.ts
index 60b71d1545..1449ec707d 100644
--- a/tools/block-tools/src/structure/rules/shared/pascal-case.ts
+++ b/tools/block-tools/src/structure/rules/shared/pascal-case.ts
@@ -1,7 +1,7 @@
 // `pascalCase(shortName)` → the block-named alias prefix the facade entry
 // template emits (`<PascalName>BlockContract`, …). Splits on any run of
 // non-alphanumeric characters and capitalises each segment's first char:
-//   test-sum-numbers-v3  → TestSumNumbersV3
+//   test-sum-numbers  → TestSumNumbersV3
 //   mixcr-clonotyping-2  → MixcrClonotyping2
 //   samples-and-data     → SamplesAndData
 export function pascalCase(s: string): string {
diff --git a/tools/block-tools/src/structure/structure-definition.ts b/tools/block-tools/src/structure/structure-definition.ts
index abfb1bc676..ce0c2cf990 100644
--- a/tools/block-tools/src/structure/structure-definition.ts
+++ b/tools/block-tools/src/structure/structure-definition.ts
@@ -8,6 +8,7 @@ import { rootRules } from "./rules/root";
 import { rootCiRules } from "./rules/root-ci";
 import { blockRules } from "./rules/block";
 import { modelRules } from "./rules/model";
+import { kindRules } from "./rules/kind";
 import { uiRules } from "./rules/ui";
 import { workflowRules } from "./rules/workflow";
 import { testRules } from "./rules/test";
@@ -20,6 +21,7 @@ export const STRUCTURE = defineStructure(() => {
   rootCiRules();
   blockRules();
   modelRules();
+  kindRules();
   uiRules();
   workflowRules();
   testRules();
diff --git a/tools/block-tools/src/structure/templates/static/kind/.oxfmtrc.json b/tools/block-tools/src/structure/templates/static/kind/.oxfmtrc.json
new file mode 100644
index 0000000000..7eff5e7af0
--- /dev/null
+++ b/tools/block-tools/src/structure/templates/static/kind/.oxfmtrc.json
@@ -0,0 +1,4 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/configs/oxfmt.json"],
+  "ignorePatterns": ["dist", "coverage", "CHANGELOG.md"]
+}
diff --git a/tools/block-tools/src/structure/templates/static/kind/.oxlintrc.json b/tools/block-tools/src/structure/templates/static/kind/.oxlintrc.json
new file mode 100644
index 0000000000..b1a139038f
--- /dev/null
+++ b/tools/block-tools/src/structure/templates/static/kind/.oxlintrc.json
@@ -0,0 +1,3 @@
+{
+  "extends": ["node_modules/@milaboratories/ts-builder/dist/configs/oxlint-node.json"]
+}
diff --git a/tools/block-tools/src/structure/templates/static/kind/src/index.ts b/tools/block-tools/src/structure/templates/static/kind/src/index.ts
new file mode 100644
index 0000000000..b241480ea7
--- /dev/null
+++ b/tools/block-tools/src/structure/templates/static/kind/src/index.ts
@@ -0,0 +1,42 @@
+import { defineBlockKind } from "@platforma-sdk/block-kind";
+import { z } from "zod";
+import { name, version } from "../package.json" with { type: "json" };
+
+/**
+ * This block's init-params contract — the shape a block of this kind receives
+ * at creation, and exactly what a project template serializes for it.
+ *
+ * TODO(block-kind): replace `NEEDS_BLOCK_PARAMS` with the real params shape, then
+ * wire the model's `init(({ params }) => …)` to consume them. If this block takes
+ * no author-supplied params, set it to `Record<string, never>` deliberately.
+ *
+ * This is an intentional sentinel: `NEEDS_BLOCK_PARAMS` is an undefined type, so
+ * the block fails to typecheck (TS2304) until the contract is chosen on purpose.
+ * A scaffolded-but-unmigrated block must never compile with an empty contract by
+ * default — see the block-kind migration recipe in the `block-dev` skill.
+ */
+export type BlockParams = NEEDS_BLOCK_PARAMS;
+
+/**
+ * The same contract at runtime, for params that arrive from a template file rather than
+ * from typed code — the only point that can catch a hand-written entry being wrong.
+ *
+ * TODO(block-kind): mirror `BlockParams` here. Keep `.strict()`: it is what turns a
+ * misspelled key into a rejection naming that key, instead of one silently ignored while
+ * the block initializes blank.
+ *
+ * This is a second intentional sentinel. The schema has to produce `BlockParams`, so an
+ * empty one stops compiling the moment the contract declares a required field — the check
+ * cannot drift from the contract by being left behind. zod is the default; any function
+ * from `unknown` to `BlockParams` satisfies the slot, including a hand-written one.
+ */
+const Params = z.object({}).strict();
+
+// Identity (`name`/`version`) comes from this package's own `package.json`, so
+// the on-wire `{name}@{version}` reference can never drift from what npm
+// publishes; the bundler inlines the JSON import.
+export const kind = defineBlockKind<BlockParams>({
+  name,
+  version,
+  parseInitializationParams: (value) => Params.parse(value),
+});
diff --git a/tools/block-tools/src/structure/templates/static/kind/tsconfig.json b/tools/block-tools/src/structure/templates/static/kind/tsconfig.json
new file mode 100644
index 0000000000..54112078cf
--- /dev/null
+++ b/tools/block-tools/src/structure/templates/static/kind/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/tools/block-tools/src/structure/templates/static/model/src/index.ts b/tools/block-tools/src/structure/templates/static/model/src/index.ts
deleted file mode 100644
index 3e9bc4c63c..0000000000
--- a/tools/block-tools/src/structure/templates/static/model/src/index.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import type { InferOutputsType } from "@platforma-sdk/model";
-import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
-
-export type BlockArgs = Record<string, never>;
-
-const dataModel = new DataModelBuilder().from<BlockArgs>("v1").init(() => ({}));
-
-export const platforma = BlockModelV3.create(dataModel)
-  .args(() => ({}))
-  .sections(() => [{ type: "link", href: "/", label: "Main" }])
-  .done();
-
-export type BlockOutputs = InferOutputsType<typeof platforma>;
diff --git a/tools/block-tools/src/structure/templates/text/model/src/index.tpl.ts b/tools/block-tools/src/structure/templates/text/model/src/index.tpl.ts
new file mode 100644
index 0000000000..1deac2e283
--- /dev/null
+++ b/tools/block-tools/src/structure/templates/text/model/src/index.tpl.ts
@@ -0,0 +1,18 @@
+import type { InferOutputsType } from "@platforma-sdk/model";
+import { BlockModelV3, DataModelBuilder } from "@platforma-sdk/model";
+import type { BlockParams } from "${kindPkg}";
+import { kind } from "${kindPkg}";
+
+export type BlockData = BlockParams;
+
+const dataModel = new DataModelBuilder({ kind })
+  .from<BlockData>("v1")
+  .init(({ params }) => params ?? {});
+
+export const platforma = BlockModelV3.create({ dataModel, kind })
+  .args(() => ({}))
+  .templateParams((data) => ({}))
+  .sections(() => [{ type: "link", href: "/", label: "Main" }])
+  .done();
+
+export type BlockOutputs = InferOutputsType<typeof platforma>;
diff --git a/tools/block-tools/src/v2/build_dist.ts b/tools/block-tools/src/v2/build_dist.ts
index fecd5e1f08..9051dce9dd 100644
--- a/tools/block-tools/src/v2/build_dist.ts
+++ b/tools/block-tools/src/v2/build_dist.ts
@@ -3,6 +3,7 @@ import type {
   ManifestFileInfo,
 } from "@milaboratories/pl-model-middle-layer";
 import { BlockPackManifest, BlockPackManifestFile } from "@milaboratories/pl-model-middle-layer";
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
 import type { CompiledTemplateV3 } from "@milaboratories/pl-model-backend";
 import type { BlockPackDescriptionAbsolute } from "./model";
 import { consolidateBlockPackDescription } from "./model";
@@ -41,6 +42,33 @@ async function workflowRequiredCapabilities(
   return pack.template.requiredCapabilities;
 }
 
+/**
+ * Returns the block-kind reference the model config declares (baked at the
+ * container level by `BlockModelV3.done()`), or `undefined` for kind-less
+ * blocks or malformed model files — fail-safe, mirroring
+ * {@link workflowRequiredCapabilities}.
+ *
+ * Note: `build-model` writes `JSON.stringify(config)` where `config` is the
+ * `BlockConfigContainer` itself, so `kind` sits at the top level of
+ * `model.json` (not nested under a `config` key).
+ */
+async function modelKindReference(
+  descriptionRelative: BlockPackDescriptionManifest,
+  dst: string,
+): Promise<BlockKindReference | undefined> {
+  // After consolidateBlockPackDescription runs, components.model is always a
+  // `{type: "relative", path: ...}` reference into `dst`.
+  const model = descriptionRelative.components.model;
+  try {
+    const cfg = JSON.parse(await fsp.readFile(path.resolve(dst, model.path), "utf-8")) as {
+      kind?: BlockKindReference;
+    };
+    return cfg.kind ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function buildBlockPackDist(
   description: BlockPackDescriptionAbsolute,
   dst: string,
@@ -71,6 +99,13 @@ export async function buildBlockPackDist(
     };
   }
 
+  // Lift the model's container-level block-kind reference onto the manifest
+  // description (top-level, like featureFlags), so the published manifest
+  // advertises which kind the block implements. Fail-safe undefined leaves
+  // kind-less blocks unprojected.
+  const kindRef = await modelKindReference(descriptionRelative, dst);
+  if (kindRef) descriptionRelative.kind = kindRef;
+
   const filesForManifest = await Promise.all(
     files.map(async (f): Promise<ManifestFileInfo> => {
       const bytes = await fsp.readFile(path.resolve(dst, f));
diff --git a/tools/block-tools/src/v2/build_kind_dist.ts b/tools/block-tools/src/v2/build_kind_dist.ts
new file mode 100644
index 0000000000..f95c9ce4cb
--- /dev/null
+++ b/tools/block-tools/src/v2/build_kind_dist.ts
@@ -0,0 +1,104 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { util } from "@platforma-sdk/package-builder-lib";
+import { calculateSha256 } from "../util";
+import type { KindManifest, KindManifestFileInfo } from "./registry/schema_kinds";
+
+export interface BuildKindDistOptions {
+  /** Kind package directory (the dir containing `package.json`, `src/`, `dist/`). */
+  modulePath?: string;
+  /** Source directory hashed into `sourceHash`, relative to `modulePath`. */
+  srcDir?: string;
+  /** Output directory holding the compiled bundle and receiving `manifest.json`. */
+  dst?: string;
+  /** Compiled entry file name inside `dst` (rolldown emits `kind.js`). */
+  entryFileName?: string;
+}
+
+// The on-wire kind manifest shape (identity, per-file info, and the manifest
+// itself) is owned by the registry schema module — the single source of truth
+// shared by the build side (this producer) and the registry read/write path.
+export type {
+  KindManifest,
+  KindManifestIdentity,
+  KindManifestFileInfo,
+} from "./registry/schema_kinds";
+
+export const KindManifestFile = "manifest.json";
+
+/**
+ * Read the kind's identity from its own `package.json` — the SINGLE source of
+ * truth. The block-kind build bakes the SAME `{name, version}` into the emitted
+ * bundle (via `define`), so the manifest identity here and the runtime
+ * descriptor's identity are guaranteed to agree. Reading package.json directly
+ * (rather than importing the ESM bundle) keeps this authoritative and free of a
+ * dynamic-import dependency on the compiled output.
+ */
+async function readKindPackageIdentity(
+  modulePath: string,
+): Promise<{ name: string; version: string }> {
+  const pkgPath = path.resolve(modulePath, "package.json");
+  let raw: string;
+  try {
+    raw = await fsp.readFile(pkgPath, "utf-8");
+  } catch {
+    throw new Error(`Cannot read kind package.json at ${pkgPath}.`);
+  }
+  const pkg = JSON.parse(raw) as { name?: unknown; version?: unknown };
+  if (typeof pkg.name !== "string" || typeof pkg.version !== "string") {
+    throw new Error(`Kind package.json at ${pkgPath} must declare string "name" and "version".`);
+  }
+  return { name: pkg.name, version: pkg.version };
+}
+
+/**
+ * Commander-free core: bundle-in, manifest-out. Reads the kind's npm package
+ * `name`/`version` from its `package.json`, computes one sha256 over the `src/`
+ * tree (upper-case), and writes `manifest.json` LAST as the commit marker (the
+ * build_dist.ts convention: readers treat the manifest's presence as "the dist
+ * is complete").
+ *
+ * Shaped commander-free so the deferred publish-time source-hash guard can
+ * `import` and reuse both the hash computation and this manifest shape without
+ * CLI coupling.
+ */
+export async function buildKindDist(opts: BuildKindDistOptions = {}): Promise<KindManifest> {
+  const modulePath = path.resolve(opts.modulePath ?? ".");
+  const srcDir = path.resolve(modulePath, opts.srcDir ?? "src");
+  const dst = path.resolve(modulePath, opts.dst ?? "dist");
+  const entryFileName = opts.entryFileName ?? "kind.js";
+
+  const { name, version } = await readKindPackageIdentity(modulePath);
+
+  const sourceHash = util.hashDirSync(srcDir).digest("hex").toUpperCase();
+
+  const artifactNames = [entryFileName, "kind.d.ts"];
+  const files: KindManifestFileInfo[] = [];
+  for (const artifact of artifactNames) {
+    const abs = path.resolve(dst, artifact);
+    let bytes: Buffer;
+    try {
+      bytes = await fsp.readFile(abs);
+    } catch (err: unknown) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        throw new Error(
+          `Kind build is incomplete: ${artifact} is missing from ${dst}. Run the kind's build before building its manifest.`,
+        );
+      }
+      throw err;
+    }
+    files.push({ name: artifact, size: bytes.length, sha256: await calculateSha256(bytes) });
+  }
+
+  const manifest: KindManifest = {
+    schema: "v1",
+    kind: { name, version },
+    sourceHash,
+    files,
+    timestamp: Date.now(),
+  };
+
+  // manifest.json written LAST — commit marker.
+  await fsp.writeFile(path.resolve(dst, KindManifestFile), JSON.stringify(manifest));
+  return manifest;
+}
diff --git a/tools/block-tools/src/v2/from_pack_v2.test.ts b/tools/block-tools/src/v2/from_pack_v2.test.ts
index 6510e15819..4ae7a9bb2f 100644
--- a/tools/block-tools/src/v2/from_pack_v2.test.ts
+++ b/tools/block-tools/src/v2/from_pack_v2.test.ts
@@ -80,12 +80,12 @@ test("loadPackDescriptionFromManifest resolves manifest entries to absolute FS p
   expect(existsSync(description.components.ui.folder)).toBe(true);
 });
 
-test("loadPackDescriptionFromManifest works against a real packed sum-numbers-v3", async () => {
+test("loadPackDescriptionFromManifest works against a real packed sum-numbers", async () => {
   // Runs when the block has been built+packed; skips gracefully in a clean
   // checkout where block-pack/ is gitignored. Guards against manifest-shape
   // drift the hermetic fixture above can't catch.
   const here = path.dirname(fileURLToPath(import.meta.url));
-  const real = path.resolve(here, "../../../../etc/blocks/sum-numbers-v3/block");
+  const real = path.resolve(here, "../../../../etc/blocks/sum-numbers/block");
   if (!existsSync(path.join(real, "block-pack", "manifest.json"))) return;
 
   const description = await loadPackDescriptionFromManifest(path.join(real, "block-pack"));
diff --git a/tools/block-tools/src/v2/index.ts b/tools/block-tools/src/v2/index.ts
index fd213d156b..573b726bd0 100644
--- a/tools/block-tools/src/v2/index.ts
+++ b/tools/block-tools/src/v2/index.ts
@@ -1,5 +1,9 @@
 export * from "./model";
 export * from "./build_dist";
+export * from "./build_kind_dist";
+export * from "./publish-block";
+export * from "./kind/resolve-refs";
+export * from "./kind/version-match";
 export * from "./source_package";
 export * from "./resolve_to_registry";
 export * from "./registry";
diff --git a/tools/block-tools/src/v2/kind/resolve-refs.ts b/tools/block-tools/src/v2/kind/resolve-refs.ts
new file mode 100644
index 0000000000..021a97b789
--- /dev/null
+++ b/tools/block-tools/src/v2/kind/resolve-refs.ts
@@ -0,0 +1,150 @@
+import fsp from "node:fs/promises";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { formatKindRef, type BlockKindReference } from "@milaboratories/pl-model-common";
+import type { BlockPackManifest } from "@milaboratories/pl-model-middle-layer";
+import { KindManifest } from "../registry/schema_kinds";
+import type { RelativeContentReader } from "../model";
+
+/**
+ * Kind → block ref resolution. The single reader of the facade's kind dependency.
+ *
+ * A kind is a fourth block component alongside model, ui and workflow, and the facade
+ * depends on it DIRECTLY — not transitively through one of the other three. Its concrete
+ * version is not read from that dependency either: the facade's range may be
+ * `workspace:*` or `catalog:`, so the authority is the kind's own built manifest.
+ *
+ * Keeping every "how the facade names and locates its kind" assumption in this one module
+ * means the publish gate and the orchestrator never touch dependency-shape details.
+ */
+
+/** npm package-name suffix marking a package as a block kind (schema_kinds convention). */
+const KIND_PACKAGE_SUFFIX = ".kind";
+
+/**
+ * The kind reference the MODEL was compiled against, as baked into the block manifest
+ * when the block was built.
+ *
+ * It sits at the TOP LEVEL of the description — `description.kind`, a `{name}@{version}`
+ * string (declared in `block_description.ts`, read back by the registry's reconciler) —
+ * rather than under the model component, because the build lifts the model's
+ * container-level `kind` up when it writes the manifest. `undefined` means the block
+ * declares no kind.
+ */
+export function readModelCompiledKindRef(
+  manifest: BlockPackManifest,
+): BlockKindReference | undefined {
+  return manifest.description.kind;
+}
+
+/** A kind dependency as declared in the facade's `package.json`. */
+export interface FacadeKindDependency {
+  /** npm package name of the kind (ends in `.kind`). */
+  npmName: string;
+  /** Raw version range as written in `package.json` (e.g. `^1.2.3`, `workspace:*`). */
+  range: string;
+}
+
+/**
+ * The facade-side kind dependency, read from the facade's `package.json`.
+ *
+ * The facade depends on its kind DIRECTLY: the `.kind`-suffixed entry is a direct
+ * dependency of the facade, not something reached transitively through
+ * `model/package.json`. We scan both `dependencies` and
+ * `devDependencies` for the single `.kind` entry — the slim facade keeps the
+ * kind (like its model/ui/workflow siblings) as a build-time `workspace:*`
+ * devDep, and its concrete version is resolved from the kind's built manifest
+ * downstream, so the range written here (`workspace:*`/`catalog:`/a semver
+ * range) is not load-bearing.
+ *
+ * Returns `undefined` when no kind dependency is declared.
+ */
+export function readFacadeKindDependency(facadeDir: string): FacadeKindDependency | undefined {
+  const pkgPath = path.join(facadeDir, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  const deps = { ...pkg.devDependencies, ...pkg.dependencies };
+  const entry = Object.entries(deps).find(([name]) => name.endsWith(KIND_PACKAGE_SUFFIX));
+  if (!entry) return undefined;
+  return { npmName: entry[0], range: entry[1] };
+}
+
+/**
+ * Resolved, publishable kind artifacts: the concrete reference, the kind's
+ * content manifest, and a reader rooted at the kind's `dist/` folder.
+ */
+export interface ResolvedFacadeKind {
+  /** Concrete `{name}@{version}` reference of the kind the facade actually ships. */
+  ref: BlockKindReference;
+  /** The kind content manifest (`build_kind_dist` output) read from the kind's dist. */
+  manifest: KindManifest;
+  /** Reads the manifest's `files[].name` relative to the kind's `dist/`. */
+  fileReader: RelativeContentReader;
+}
+
+/**
+ * Resolve the facade's kind dependency to concrete publishable artifacts.
+ *
+ * Resolves the kind npm package from the facade's perspective, reads its
+ * built `dist/manifest.json` (the authoritative concrete version — the facade
+ * `package.json` range may be `workspace:*`/`catalog:` and carry no concrete
+ * version), and returns a `dist/`-rooted file reader for `publishKind`.
+ *
+ * The concrete version comes from the built manifest, so a `workspace:*`/`catalog:`
+ * range in the facade's `package.json` resolves cleanly. Resolution uses standard node resolution from the facade dir; if the
+ * package or its manifest cannot be found it throws with a pointed message
+ * rather than silently skipping.
+ */
+export async function resolveFacadeKind(
+  facadeDir: string,
+  npmName: string,
+): Promise<ResolvedFacadeKind> {
+  const kindPkgDir = resolveKindPackageDir(facadeDir, npmName);
+  const distDir = path.join(kindPkgDir, "dist");
+
+  let manifestRaw: string;
+  try {
+    manifestRaw = await fsp.readFile(path.join(distDir, "manifest.json"), "utf-8");
+  } catch {
+    throw new Error(
+      `Kind package "${npmName}" resolved to ${kindPkgDir} but has no dist/manifest.json. ` +
+        `Build the kind (ts-builder build --target block-kind && block-tools build-kind-manifest) before publishing.`,
+    );
+  }
+  const manifest = KindManifest.parse(JSON.parse(manifestRaw));
+
+  const ref = formatKindRef({ name: manifest.kind.name, version: manifest.kind.version });
+  const fileReader: RelativeContentReader = async (relativePath) =>
+    Buffer.from(await fsp.readFile(path.resolve(distDir, relativePath)));
+
+  return { ref, manifest, fileReader };
+}
+
+/** Resolve the directory of an installed kind npm package from the facade's location. */
+function resolveKindPackageDir(facadeDir: string, npmName: string): string {
+  const req = createRequire(path.join(facadeDir, "package.json"));
+  // Prefer the package's own package.json (deterministic package root).
+  try {
+    return path.dirname(req.resolve(`${npmName}/package.json`));
+  } catch {
+    // Fall back to the package entry point, then walk up to the folder holding package.json.
+    try {
+      let dir = path.dirname(req.resolve(npmName));
+      for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+    } catch {
+      /* fall through to the throw below */
+    }
+    throw new Error(
+      `Cannot resolve kind package "${npmName}" from ${facadeDir}. ` +
+        `Ensure it is installed as a dependency of the facade.`,
+    );
+  }
+}
diff --git a/tools/block-tools/src/v2/kind/version-match.test.ts b/tools/block-tools/src/v2/kind/version-match.test.ts
new file mode 100644
index 0000000000..fa481faf1d
--- /dev/null
+++ b/tools/block-tools/src/v2/kind/version-match.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, test } from "vitest";
+import { formatKindRef } from "@milaboratories/pl-model-common";
+import { checkKindVersionMatch, KindVersionMismatchError } from "./version-match";
+
+/**
+ * `checkKindVersionMatch` is the pure pre-publish gate: the model's
+ * compiled-against kind and the facade's declared kind must be the SAME kind at
+ * the SAME version. Success is "did not throw". The full `{org, name}` identity is
+ * compared, not just the terminal name.
+ */
+describe("checkKindVersionMatch", () => {
+  const name = "@platforma-open/milaboratories.demo.kind";
+
+  test("identical name + version passes", () => {
+    expect(() =>
+      checkKindVersionMatch(
+        formatKindRef({ name, version: "1.2.3" }),
+        formatKindRef({ name, version: "1.2.3" }),
+      ),
+    ).not.toThrow();
+  });
+
+  test("same kind, different version -> version mismatch", () => {
+    expect(() =>
+      checkKindVersionMatch(
+        formatKindRef({ name, version: "1.2.3" }),
+        formatKindRef({ name, version: "1.2.4" }),
+      ),
+    ).toThrow(KindVersionMismatchError);
+  });
+
+  test("different name segment at the same version -> name mismatch", () => {
+    expect(() =>
+      checkKindVersionMatch(
+        formatKindRef({ name: "@platforma-open/milaboratories.demo.kind", version: "1.2.3" }),
+        formatKindRef({ name: "@platforma-open/milaboratories.other.kind", version: "1.2.3" }),
+      ),
+    ).toThrow(KindVersionMismatchError);
+  });
+
+  test("different org at the same version -> name mismatch (org IS compared)", () => {
+    expect(() =>
+      checkKindVersionMatch(
+        formatKindRef({ name: "@platforma-open/milaboratories.demo.kind", version: "1.2.3" }),
+        formatKindRef({ name: "@platforma-open/acme.demo.kind", version: "1.2.3" }),
+      ),
+    ).toThrow(KindVersionMismatchError);
+  });
+
+  test("an incidental npm-scope difference is normalized away", () => {
+    // Scoped vs. bare npm name: `npmNameToKindPath` drops the scope, so both
+    // resolve to the same `{org, name}` and the same kind matches.
+    expect(() =>
+      checkKindVersionMatch(
+        formatKindRef({ name: "@platforma-open/milaboratories.demo.kind", version: "1.2.3" }),
+        formatKindRef({ name: "milaboratories.demo.kind", version: "1.2.3" }),
+      ),
+    ).not.toThrow();
+  });
+});
diff --git a/tools/block-tools/src/v2/kind/version-match.ts b/tools/block-tools/src/v2/kind/version-match.ts
new file mode 100644
index 0000000000..2399a12815
--- /dev/null
+++ b/tools/block-tools/src/v2/kind/version-match.ts
@@ -0,0 +1,55 @@
+import { parseKindRef, type BlockKindReference } from "@milaboratories/pl-model-common";
+import { npmNameToKindPath } from "../registry/schema_kinds";
+
+/**
+ * Thrown when the kind version the model was compiled against does not match
+ * the kind version the facade ships. Typed so the publish command (and future
+ * callers) can distinguish this hard-fail from generic errors.
+ */
+export class KindVersionMismatchError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "KindVersionMismatchError";
+  }
+}
+
+/**
+ * Pure pre-publish gate: assert the model's compiled-against kind and the
+ * facade's declared kind are the same kind at the same version. Throws
+ * {@link KindVersionMismatchError} on mismatch; success is "did not throw".
+ *
+ * No I/O — both inputs are already-resolved `{name}@{version}` references, so a
+ * mismatch aborts before any S3 write (a strict superset of "abort before the
+ * facade publish"). Reuses the SINGLE `{name}@{version}` codec `parseKindRef`
+ * from `block_kind_ref.ts` (§3) — it is NOT redefined here.
+ *
+ * @param modelKindRef  reference the model was compiled against (`description.kind`)
+ * @param facadeKindDep concrete reference the facade ships (from resolve-refs)
+ */
+export function checkKindVersionMatch(
+  modelKindRef: BlockKindReference,
+  facadeKindDep: BlockKindReference,
+): void {
+  const m = parseKindRef(modelKindRef);
+  const f = parseKindRef(facadeKindDep);
+
+  // Version is the load-bearing comparison. Exact-match, no semver range: the
+  // facade reference is already normalized to a concrete version by resolve-refs
+  // (which resolves `workspace:*`/`catalog:` via the kind's built manifest), so
+  // a range never reaches here.
+  if (m.version !== f.version) {
+    throw new KindVersionMismatchError(
+      `Kind version mismatch: model compiled against ${modelKindRef}, ` +
+        `facade declares ${facadeKindDep}. Rebuild the model against the declared kind.`,
+    );
+  }
+
+  const mLoc = npmNameToKindPath(m.name);
+  const fLoc = npmNameToKindPath(f.name);
+  if (mLoc.org !== fLoc.org || mLoc.name !== fLoc.name) {
+    throw new KindVersionMismatchError(
+      `Kind name mismatch: model compiled against ${modelKindRef}, ` +
+        `facade declares ${facadeKindDep}.`,
+    );
+  }
+}
diff --git a/tools/block-tools/src/v2/model/block_description.ts b/tools/block-tools/src/v2/model/block_description.ts
index 6ef3c5c3ef..0eded0e79d 100644
--- a/tools/block-tools/src/v2/model/block_description.ts
+++ b/tools/block-tools/src/v2/model/block_description.ts
@@ -22,7 +22,14 @@ export type BlockPackDescriptionAbsolute = BlockPackDescription<
  * Resolves a raw `package.json`-form block-pack description against the
  * module root: workflow/model/ui paths via node module resolution, text and
  * binary fields in `meta` via `mapLocalToAbsolute`. Reads the resolved model
- * file to extract feature flags from its `BlockConfigContainer`.
+ * file to extract feature flags and the kind reference from its
+ * `BlockConfigContainer`.
+ *
+ * Both of those come from the built model rather than from `package.json`,
+ * because both are decided when the model is compiled. Carrying the kind here
+ * means a description means the same thing whichever side it was loaded from —
+ * a manifest already records it, and a caller should not have to know that a
+ * source package does not and re-read the model to find out.
  */
 export async function resolveBlockPackDescription(
   raw: BlockPackDescriptionRaw,
@@ -30,14 +37,18 @@ export async function resolveBlockPackDescription(
 ): Promise<BlockPackDescriptionAbsolute> {
   const components = resolveBlockComponents(raw.components, root);
   const meta = await resolveBlockPackMeta(raw.meta, root);
-  const cfg = extractConfigGeneric(
-    JSON.parse(await fsp.readFile(components.model.file, "utf-8")) as BlockConfigContainer,
-  );
+  const container = JSON.parse(
+    await fsp.readFile(components.model.file, "utf-8"),
+  ) as BlockConfigContainer;
+  const cfg = extractConfigGeneric(container);
   return {
     ...raw,
     components,
     meta,
     featureFlags: cfg.featureFlags,
+    // The kind sits at the container level, above the render envelope, so it
+    // survives `extractConfigGeneric` normalizing that envelope away.
+    ...(container.kind !== undefined ? { kind: container.kind } : {}),
   };
 }
 
diff --git a/tools/block-tools/src/v2/publish-block.ts b/tools/block-tools/src/v2/publish-block.ts
new file mode 100644
index 0000000000..d2f69794dd
--- /dev/null
+++ b/tools/block-tools/src/v2/publish-block.ts
@@ -0,0 +1,60 @@
+import type { BlockPackManifest } from "@milaboratories/pl-model-middle-layer";
+import type { BlockRegistryV2 } from "./registry/registry";
+import type { RelativeContentReader } from "./model";
+import {
+  readModelCompiledKindRef,
+  readFacadeKindDependency,
+  resolveFacadeKind,
+} from "./kind/resolve-refs";
+import { checkKindVersionMatch } from "./kind/version-match";
+
+/**
+ * Publish a block package, kind-first.
+ *
+ * This is the single forward-compat seam the deferred kind/template phases
+ * extend. It sequences exactly three steps around the existing facade publish:
+ *
+ *   1. resolve both kind refs — every assumption about how the facade names and locates
+ *      its kind lives in `resolve-refs`, so this step has no shape details of its own,
+ *   2. run the pure version-match gate — hard-fails before ANY S3 write,
+ *   3. `publishKind` (kind content → `kinds/` tree, idempotent, source-hash
+ *      guarded), then
+ *   4. `publishPackage` — the facade block, byte-for-byte unchanged.
+ *
+ * A block that declares no kind (`description.kind` absent) publishes exactly as
+ * before: the gate and `publishKind` are skipped entirely.
+ *
+ * The channel marker / coords write / refresh tail stays in the publish command
+ * and runs only after this resolves.
+ */
+export async function publishBlock(
+  registry: BlockRegistryV2,
+  manifest: BlockPackManifest,
+  facadeDir: string,
+  fileReader: RelativeContentReader,
+): Promise<void> {
+  const modelKindRef = readModelCompiledKindRef(manifest);
+
+  if (modelKindRef !== undefined) {
+    // 1. resolve the facade-declared kind dependency
+    const facadeDep = readFacadeKindDependency(facadeDir);
+    if (facadeDep === undefined) {
+      throw new Error(
+        `Model was compiled against kind ${modelKindRef}, but the facade declares ` +
+          `no kind dependency in its package.json.`,
+      );
+    }
+
+    // Resolve to concrete artifacts (concrete version + kind content + reader).
+    const resolvedKind = await resolveFacadeKind(facadeDir, facadeDep.npmName);
+
+    // 2. pure gate — throws KindVersionMismatchError before any S3 write
+    checkKindVersionMatch(modelKindRef, resolvedKind.ref);
+
+    // 3. kind FIRST — idempotent, source-hash-guarded write to the kinds/ tree
+    await registry.publishKind(resolvedKind.manifest, resolvedKind.fileReader);
+  }
+
+  // 4. facade — unchanged behavior
+  await registry.publishPackage(manifest, fileReader);
+}
diff --git a/tools/block-tools/src/v2/registry/index.ts b/tools/block-tools/src/v2/registry/index.ts
index 55f5d913f2..ae2a33099a 100644
--- a/tools/block-tools/src/v2/registry/index.ts
+++ b/tools/block-tools/src/v2/registry/index.ts
@@ -1,3 +1,5 @@
 export * from "./registry";
 export * from "./registry_reader";
 export * from "./schema_public";
+export * from "./schema_kinds";
+export * from "./kind_resolver";
diff --git a/tools/block-tools/src/v2/registry/kind_resolver.test.ts b/tools/block-tools/src/v2/registry/kind_resolver.test.ts
new file mode 100644
index 0000000000..6b8be03abe
--- /dev/null
+++ b/tools/block-tools/src/v2/registry/kind_resolver.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, test } from "vitest";
+import * as semver from "semver";
+import { AnyChannel, StableChannel } from "@milaboratories/pl-model-middle-layer";
+import type { BlockPackId } from "@milaboratories/pl-model-middle-layer";
+import { parseSelector, resolveKind, selectorToRange } from "./kind_resolver";
+import type { KindOverview } from "./schema_kinds";
+
+const block = (version: string): BlockPackId => ({
+  organization: "acme",
+  name: "blk",
+  version,
+});
+
+// Implementing block ids, one per kind version. Block versions are independent
+// of the kind versions they implement.
+const b100 = block("3.0.0"); // implements kind 1.0.0 (stable)
+const b120 = block("3.1.0"); // implements kind 1.2.0 (stable)
+const b130 = block("3.2.0"); // implements kind 1.3.0 (stable)
+const b200 = block("4.0.0"); // implements kind 2.0.0 (unstable only)
+
+/**
+ * Overview with a multi-step version ladder inside one major, so patch-tier and
+ * minor-tier resolution land on different versions, and a top kind version
+ * (2.0.0) whose only implementer sits off the stable channel — the
+ * `no-stable-implementation` fixture.
+ */
+const overview: KindOverview = {
+  schema: "v1",
+  implementers: [
+    { id: b100, kindVersion: "1.0.0", channels: [StableChannel] },
+    { id: b120, kindVersion: "1.2.0", channels: [StableChannel] },
+    { id: b130, kindVersion: "1.3.0", channels: [StableChannel] },
+    { id: b200, kindVersion: "2.0.0", channels: ["unstable"] },
+  ],
+  kindVersions: [
+    { kindVersion: "1.0.0", latestByChannel: { [StableChannel]: b100, [AnyChannel]: b100 } },
+    { kindVersion: "1.2.0", latestByChannel: { [StableChannel]: b120, [AnyChannel]: b120 } },
+    { kindVersion: "1.3.0", latestByChannel: { [StableChannel]: b130, [AnyChannel]: b130 } },
+    { kindVersion: "2.0.0", latestByChannel: { [AnyChannel]: b200 } },
+  ],
+};
+
+describe("selector parsing / range mapping", () => {
+  test("leading operator selects the tier; bare version is exact", () => {
+    expect(parseSelector("1.2.0")).toEqual({ op: "exact", version: "1.2.0" });
+    expect(parseSelector("~1.2.0")).toEqual({ op: "patch", version: "1.2.0" });
+    expect(parseSelector("^1.2.0")).toEqual({ op: "minor", version: "1.2.0" });
+  });
+
+  test("selectorToRange emits the explicit range for each tier", () => {
+    expect(selectorToRange({ op: "exact", version: "1.2.0" })).toBe("=1.2.0");
+    expect(selectorToRange({ op: "patch", version: "1.2.0" })).toBe(">=1.2.0 <1.3.0-0");
+    expect(selectorToRange({ op: "minor", version: "1.0.0" })).toBe(">=1.0.0 <2.0.0-0");
+  });
+
+  test("at or above 1.0.0 the explicit ranges are equivalent to npm ~ and ^", () => {
+    for (const version of ["1.0.0", "1.2.3", "2.0.0", "10.4.0", "1.2.0-rc.1"]) {
+      expect(semver.validRange(selectorToRange({ op: "patch", version }))).toBe(
+        semver.validRange(`~${version}`),
+      );
+      expect(semver.validRange(selectorToRange({ op: "minor", version }))).toBe(
+        semver.validRange(`^${version}`),
+      );
+    }
+  });
+
+  // npm collapses `^0.2.0` and `~0.2.0` to the same range, treating a 0.x minor
+  // as the breaking boundary. The kind scheme puts params-breaks on the major at
+  // every major, so the two tiers must stay distinct for a 0.x kind.
+  test("below 1.0.0 the tiers stay distinct, unlike npm ~ and ^", () => {
+    expect(selectorToRange({ op: "patch", version: "0.2.0" })).toBe(">=0.2.0 <0.3.0-0");
+    expect(selectorToRange({ op: "minor", version: "0.2.0" })).toBe(">=0.2.0 <1.0.0-0");
+
+    expect(semver.validRange("^0.2.0")).toBe(semver.validRange("~0.2.0"));
+    expect(semver.satisfies("0.3.0", selectorToRange({ op: "minor", version: "0.2.0" }))).toBe(
+      true,
+    );
+    expect(semver.satisfies("0.3.0", selectorToRange({ op: "patch", version: "0.2.0" }))).toBe(
+      false,
+    );
+    expect(semver.satisfies("1.0.0", selectorToRange({ op: "minor", version: "0.2.0" }))).toBe(
+      false,
+    );
+  });
+
+  test("an unparseable version is rejected at range construction", () => {
+    expect(() => selectorToRange({ op: "minor", version: "latest" })).toThrow();
+  });
+});
+
+describe("resolveKind", () => {
+  test("exact @X.Y.Z hit -> that kind version's stable block", () => {
+    const r = resolveKind(overview, "1.2.0", { allowUnstable: false });
+    expect(r).toEqual({ ok: true, blockId: b120, channel: StableChannel });
+  });
+
+  test("minor float ^1.0.0 picks the newest matching kind version (1.3.0)", () => {
+    const r = resolveKind(overview, "^1.0.0", { allowUnstable: false });
+    // ^1.0.0 == >=1.0.0 <2.0.0 -> maxSatisfying is 1.3.0.
+    expect(r).toEqual({ ok: true, blockId: b130, channel: StableChannel });
+  });
+
+  test("patch float ~1.2.0 stays within the minor line", () => {
+    const r = resolveKind(overview, "~1.2.0", { allowUnstable: false });
+    // ~1.2.0 == >=1.2.0 <1.3.0 -> maxSatisfying is 1.2.0.
+    expect(r).toEqual({ ok: true, blockId: b120, channel: StableChannel });
+  });
+
+  test("kind version exists but only an unstable implementer -> no-stable-implementation", () => {
+    const r = resolveKind(overview, "2.0.0", { allowUnstable: false });
+    expect(r).toEqual({ ok: false, reason: "no-stable-implementation" });
+  });
+
+  test("allowUnstable lifts the same 2.0.0 to the any channel", () => {
+    const r = resolveKind(overview, "2.0.0", { allowUnstable: true });
+    expect(r).toEqual({ ok: true, blockId: b200, channel: AnyChannel });
+  });
+
+  test("selector satisfying zero kind versions -> no-matching-kind-version", () => {
+    const r = resolveKind(overview, "5.0.0", { allowUnstable: false });
+    expect(r).toEqual({ ok: false, reason: "no-matching-kind-version" });
+  });
+});
diff --git a/tools/block-tools/src/v2/registry/kind_resolver.ts b/tools/block-tools/src/v2/registry/kind_resolver.ts
new file mode 100644
index 0000000000..29d69859af
--- /dev/null
+++ b/tools/block-tools/src/v2/registry/kind_resolver.ts
@@ -0,0 +1,190 @@
+import type { BlockPackId } from "@milaboratories/pl-model-middle-layer";
+import { AnyChannel, StableChannel } from "@milaboratories/pl-model-middle-layer";
+import * as semver from "semver";
+import type { KindOverview } from "./schema_kinds";
+
+/**
+ * PURE, IO-free block-kind resolution core.
+ *
+ * Given a parsed {@link KindOverview} projection (fetched by the reader) and a
+ * version selector, this module answers "which concrete implementing block
+ * satisfies `{name}@{selector}`?" with a discriminated {@link KindResolution}.
+ *
+ * Everything here is fed literals in unit tests — no `FolderReader`, no cache,
+ * no `semver` use beyond range math. This is the net-new, correctness-critical
+ * seam (implementation-path §6): selector→range translation and channel
+ * selection each have edges worth isolating and testing.
+ *
+ * Naming: this module never parses the `{name}@{version}` *reference* string
+ * (that codec is `parseKindRef`, block_kind_ref.ts) nor the npm-name→path split
+ * (`npmNameToKindPath`, schema_kinds.ts). It consumes an already-split selector.
+ */
+
+/**
+ * The three version-selector tiers of the redefined-semver scheme
+ * (01-kind-and-lifecycle.md:63):
+ *   - `exact` — `@X.Y.Z`, pin to one version.
+ *   - `patch` — `~X.Y.Z`, behavior frozen (patch floats).
+ *   - `minor` — `^X.Y.Z`, behavior floats (minor floats).
+ */
+export type SelectorOp = "exact" | "patch" | "minor";
+
+export interface Selector {
+  op: SelectorOp;
+  version: string;
+}
+
+/**
+ * Split a raw selector string into its {@link Selector} operator + version.
+ *
+ * The leading character encodes the tier: `~`→patch, `^`→minor, `@`→exact.
+ * A bare version (no recognized leading operator) is treated as `exact`. Note
+ * that `@` as a *leading* char is redundant with the bare form and accepted
+ * only because the reference form is `{name}@{version}` — after `parseKindRef`
+ * splits on the final `@`, the version half is normally bare or `~`/`^`-prefixed.
+ */
+export function parseSelector(raw: string): Selector {
+  const s = raw.trim();
+  switch (s[0]) {
+    case "~":
+      return { op: "patch", version: s.slice(1) };
+    case "^":
+      return { op: "minor", version: s.slice(1) };
+    case "@":
+      return { op: "exact", version: s.slice(1) };
+    default:
+      return { op: "exact", version: s };
+  }
+}
+
+/**
+ * Map a {@link Selector} to a semver range string:
+ *   - `exact` — `=X.Y.Z`
+ *   - `patch` — `>=X.Y.Z <X.(Y+1).0-0`, behavior frozen, params float
+ *   - `minor` — `>=X.Y.Z <(X+1).0.0-0`, behavior floats, never crosses a params-break
+ *
+ * The kind scheme redefines the *meaning* of major/minor/patch, not the range
+ * arithmetic — so the arithmetic is written out here rather than delegated to
+ * npm's `~`/`^` operators, which are not major-agnostic. Below 1.0.0 npm expands
+ * both `^0.2.3` and `~0.2.3` to `>=0.2.3 <0.3.0-0`, treating a `0.x` minor as the
+ * breaking boundary per ecosystem convention. Under the kind scheme a
+ * params-break is a MAJOR bump at every major including zero, and nothing
+ * guarantees a kind starts at `1.0.0`, so borrowing `^` would silently collapse
+ * `patch` and `minor` into one tier for any `0.x` kind — erasing the distinction
+ * the whole scheme rests on.
+ *
+ * For `X >= 1` these forms are equivalent to `~`/`^`, down to npm's `-0`
+ * upper-bound suffix that keeps prereleases of the boundary out of range.
+ *
+ * @throws if `sel.version` is not a valid semver version. {@link parseSelector}
+ *   does not validate it; the model-side `parseKindSelector` does.
+ */
+export function selectorToRange(sel: Selector): string {
+  if (sel.op === "exact") return `=${sel.version}`;
+  const major = semver.major(sel.version);
+  const minor = semver.minor(sel.version);
+  const upperBound = sel.op === "patch" ? `${major}.${minor + 1}.0` : `${major + 1}.0.0`;
+  return `>=${sel.version} <${upperBound}-0`;
+}
+
+/**
+ * Outcome of resolving a kind reference against its overview projection.
+ *
+ * The three failure reasons are distinct on purpose (the caller maps each to a
+ * different user-facing error):
+ *   - `no-matching-kind-version` — the selector satisfies zero kind versions
+ *     (`maxSatisfying` returned `null`).
+ *   - `no-implementation` — a kind version matched, but it has no implementing
+ *     block at all.
+ *   - `no-stable-implementation` — implementing blocks exist for the matched
+ *     kind version, but none is on the `stable` channel and `allowUnstable` is
+ *     off.
+ */
+export type KindResolution =
+  | { ok: true; blockId: BlockPackId; channel: string }
+  | { ok: false; reason: "no-matching-kind-version" }
+  | { ok: false; reason: "no-implementation" }
+  | { ok: false; reason: "no-stable-implementation" };
+
+export type KindResolutionReason = Extract<KindResolution, { ok: false }>["reason"];
+
+/**
+ * Typed error the reader/facade throw when {@link resolveKind} fails, carrying
+ * the discriminated {@link KindResolutionReason} and the offending reference so
+ * a caller can map it to a spec-level error without re-deriving the reason.
+ */
+export class KindResolutionError extends Error {
+  constructor(
+    public readonly reason: KindResolutionReason,
+    public readonly ref: string,
+  ) {
+    super(`Cannot resolve block kind "${ref}": ${reason}`);
+    this.name = "KindResolutionError";
+  }
+}
+
+/**
+ * Newest implementing block for `(kindVersion, channel)` from the flat
+ * `implementers` list — the RMW source of truth. Newest by *block* version via
+ * `semver.gt`. Under `allowUnstable` every implementer of the kind version is
+ * eligible regardless of channel membership (the `AnyChannel` view); otherwise
+ * only implementers published to `channel` count.
+ */
+function pickNewestImplementer(
+  implementers: KindOverview["implementers"],
+  kindVersion: string,
+  channel: string,
+  allowUnstable: boolean,
+): BlockPackId | undefined {
+  const candidates = implementers.filter(
+    (i) => semver.eq(i.kindVersion, kindVersion) && (allowUnstable || i.channels.includes(channel)),
+  );
+  if (candidates.length === 0) return undefined;
+  return candidates.reduce((a, b) => (semver.gt(b.id.version, a.id.version) ? b : a)).id;
+}
+
+/**
+ * Resolve a kind reference to a concrete implementing block.
+ *
+ * 1. Pick the newest kind version satisfying the selector via
+ *    `semver.maxSatisfying` over the overview's `kindVersions`.
+ * 2. Select the target channel: `stable` by default, `any` when `allowUnstable`
+ *    is set (the apply-time flag).
+ * 3. Pick the newest implementing block in that `(version, channel)` via
+ *    `semver.gt`, reading the flat `implementers` source of truth and falling
+ *    back to the derived `latestByChannel` projection for older overviews.
+ *
+ * @param overview parsed & normalized kind projection (reader-supplied).
+ * @param selector either a raw selector string (`^1.2.3`, `~1.2.3`, `1.2.3`)
+ *   or a pre-parsed {@link Selector}.
+ */
+export function resolveKind(
+  overview: KindOverview,
+  selector: string | Selector,
+  opt: { allowUnstable: boolean },
+): KindResolution {
+  const sel = typeof selector === "string" ? parseSelector(selector) : selector;
+  const range = selectorToRange(sel);
+
+  const versions = overview.kindVersions.map((v) => v.kindVersion);
+  const picked = semver.maxSatisfying(versions, range);
+  if (picked === null) return { ok: false, reason: "no-matching-kind-version" };
+
+  const entry = overview.kindVersions.find((v) => semver.eq(v.kindVersion, picked));
+  const channel = opt.allowUnstable ? AnyChannel : StableChannel;
+
+  const blockId =
+    pickNewestImplementer(overview.implementers, picked, channel, opt.allowUnstable) ??
+    entry?.latestByChannel[channel];
+  if (blockId) return { ok: true, blockId, channel };
+
+  // Nothing in the target channel. Distinguish "no implementer at all" from
+  // "implementers exist but none stable". When `allowUnstable` is set the target
+  // channel is `any`, so an empty result here always means zero implementers.
+  const hasAnyImpl =
+    overview.implementers.some((i) => semver.eq(i.kindVersion, picked)) ||
+    (entry !== undefined && Object.keys(entry.latestByChannel).length > 0);
+
+  if (!hasAnyImpl) return { ok: false, reason: "no-implementation" };
+  return { ok: false, reason: "no-stable-implementation" };
+}
diff --git a/tools/block-tools/src/v2/registry/registry.test.ts b/tools/block-tools/src/v2/registry/registry.test.ts
index 2bc84ac9c5..9ab3b71932 100644
--- a/tools/block-tools/src/v2/registry/registry.test.ts
+++ b/tools/block-tools/src/v2/registry/registry.test.ts
@@ -4,9 +4,15 @@ import { randomUUID } from "crypto";
 import path from "path";
 import fsp from "fs/promises";
 import { BlockRegistryV2 } from "./registry";
-import { UpdateSuggestions, BlockPackManifest } from "@milaboratories/pl-model-middle-layer";
+import {
+  UpdateSuggestions,
+  BlockPackManifest,
+  StableChannel,
+} from "@milaboratories/pl-model-middle-layer";
 import { inferUpdateSuggestions } from "./registry_reader";
 import { OverviewSnapshotsPrefix } from "./schema_internal";
+import { KindOverview, kindOverviewPath, npmNameToKindPath } from "./schema_kinds";
+import { resolveKind } from "./kind_resolver";
 
 type TestStorageInstance = {
   storage: RegistryStorage;
@@ -260,6 +266,246 @@ test.each(testStorages)(
   },
 );
 
+/**
+ * Fixture for the kind-projection test: a block version whose description
+ * carries a `{name}@{version}` kind reference. Only the id and that reference
+ * matter to the reconciler's kind pass.
+ */
+const kindTestKindNpmName = "@platforma-open/kindorg.kindpkg.kind";
+/** A second, unrelated kind — the migration target in the kind-change test. */
+const kindTestOtherKindNpmName = "@platforma-open/kindorg.otherpkg.kind";
+
+function kindImplementingManifest(
+  version: string,
+  kindVersion: string,
+  kindNpmName: string = kindTestKindNpmName,
+): BlockPackManifest {
+  return BlockPackManifest.parse({
+    schema: "v2",
+    description: {
+      id: { organization: "testorg", name: "kindblk", version },
+      title: "Kind implementing block",
+      summary: "Test package",
+      kind: `${kindNpmName}@${kindVersion}`,
+      components: {
+        workflow: { type: "workflow-v1", main: { type: "relative", path: "workflow.json" } },
+        model: { type: "relative", path: "model.json" },
+        ui: { type: "relative", path: "ui.json" },
+      },
+      meta: {
+        title: "Kind implementing block",
+        description: "Test package description",
+        organization: { name: "Test Organization", url: "https://test.com" },
+        tags: [],
+      },
+    },
+    files: [
+      {
+        name: "model.json",
+        size: 13,
+        sha256: "6FD977DB9B2AFE87A9CEEE48432881299A6AAF83D935FBBE83007660287F9C2E",
+      },
+    ],
+  });
+}
+
+const kindTestFileReader = async (fileName: string) => {
+  if (fileName === "model.json") return Buffer.from('{"test":true}');
+  throw new Error(`Unknown file: ${fileName}`);
+};
+
+/**
+ * Channel membership is per *block version* (`v2/{org}/{name}/{version}/channels/{channel}`),
+ * and every writer of a channel marker drops an update seed for that same
+ * version. So a `normal` (read-modify-write) reconcile pass always re-reads the
+ * versions whose membership changed, and the per-entry `channels` snapshot
+ * stored in `kinds/{org}/{name}/overview.json` cannot go stale behind it.
+ *
+ * This test pins that invariant on both sides of a stable-channel handover:
+ * adding `stable` to a newer version (both versions stable — marking is not a
+ * moving pointer, so the older one keeps its own membership) and then removing
+ * `stable` from the older one. Either step must leave every entry's snapshot
+ * equal to the markers actually present in storage, and stable resolution must
+ * follow. Regression guard: any future change that mutates a marker without
+ * seeding that exact version — or that turns `stable` into a single moving
+ * pointer — leaves the kind index asserting a version is stable when it is not.
+ */
+test.each(testStorages)(
+  "channel handover keeps kind overview channel snapshots correct in normal mode with $name",
+  async ({ storageProvider }) => {
+    const { storage, teardown } = storageProvider();
+    const registry = new BlockRegistryV2(storage, undefined, { skipSnapshotCreation: true });
+
+    const ovPath = kindOverviewPath(npmNameToKindPath(kindTestKindNpmName));
+    const readKindOverview = async (): Promise<KindOverview> => {
+      const content = await storage.getFile(ovPath);
+      expect(content).toBeDefined();
+      return KindOverview.parse(JSON.parse(content!.toString()));
+    };
+    const channelsOf = (overview: KindOverview, version: string): string[] => {
+      const entry = overview.implementers.find((i) => i.id.version === version);
+      expect(entry, `no implementer entry for ${version}`).toBeDefined();
+      return [...entry!.channels].sort();
+    };
+    const stableResolution = (overview: KindOverview) =>
+      resolveKind(overview, "1.0.0", { allowUnstable: false });
+
+    try {
+      // Two versions of one block, both implementing kind 1.0.0.
+      const a = kindImplementingManifest("1.0.0", "1.0.0");
+      const b = kindImplementingManifest("2.0.0", "1.0.0");
+      await registry.publishPackage(a, kindTestFileReader);
+      await registry.publishPackage(b, kindTestFileReader);
+
+      // A stable, reconcile.
+      await registry.addPackageToChannel(a.description.id, StableChannel);
+      await registry.updateIfNeeded("normal");
+
+      let overview = await readKindOverview();
+      expect(channelsOf(overview, "1.0.0")).toEqual([StableChannel]);
+      expect(channelsOf(overview, "2.0.0")).toEqual([]);
+      expect(stableResolution(overview)).toEqual({
+        ok: true,
+        blockId: a.description.id,
+        channel: StableChannel,
+      });
+
+      // B stable, reconcile in normal mode. A keeps its own marker (marking is
+      // additive per version), so both entries must read stable and resolution
+      // must move to the newer version.
+      await registry.addPackageToChannel(b.description.id, StableChannel);
+      await registry.updateIfNeeded("normal");
+
+      overview = await readKindOverview();
+      expect(channelsOf(overview, "1.0.0")).toEqual([StableChannel]);
+      expect(channelsOf(overview, "2.0.0")).toEqual([StableChannel]);
+      expect(await storage.listFiles(`v2/testorg/kindblk/1.0.0/channels/`)).toEqual([
+        StableChannel,
+      ]);
+      expect(stableResolution(overview)).toEqual({
+        ok: true,
+        blockId: b.description.id,
+        channel: StableChannel,
+      });
+
+      // Now the losing side of a real handover: drop stable from A. The version
+      // losing membership is the one seeded, so a normal pass must clear its
+      // snapshot rather than carry the stale `["stable"]`.
+      await registry.removePackageFromChannel(a.description.id, StableChannel);
+      await registry.updateIfNeeded("normal");
+
+      overview = await readKindOverview();
+      expect(channelsOf(overview, "1.0.0")).toEqual([]);
+      expect(channelsOf(overview, "2.0.0")).toEqual([StableChannel]);
+      expect(await storage.listFiles(`v2/testorg/kindblk/1.0.0/channels/`)).toEqual([]);
+      expect(stableResolution(overview)).toEqual({
+        ok: true,
+        blockId: b.description.id,
+        channel: StableChannel,
+      });
+
+      // Dropping the last stable marker must make the kind unresolvable on the
+      // stable channel — not silently fall back to a no-longer-stable version.
+      await registry.removePackageFromChannel(b.description.id, StableChannel);
+      await registry.updateIfNeeded("normal");
+
+      overview = await readKindOverview();
+      expect(channelsOf(overview, "1.0.0")).toEqual([]);
+      expect(channelsOf(overview, "2.0.0")).toEqual([]);
+      expect(stableResolution(overview)).toEqual({
+        ok: false,
+        reason: "no-stable-implementation",
+      });
+      expect(resolveKind(overview, "1.0.0", { allowUnstable: true })).toEqual({
+        ok: true,
+        blockId: b.description.id,
+        channel: "any",
+      });
+    } finally {
+      await teardown();
+    }
+  },
+);
+
+/**
+ * A block version can change which kind it implements: `publishPackage` overwrites
+ * same-version content (unlike `publishKind`, which is source-hash guarded), so a
+ * re-publish can move `{org}:{name}:{version}` from kind A to kind B.
+ *
+ * A `normal` pass only ever reads the CURRENT manifest, which names B — so nothing
+ * in the fresh scan points at A. Without an explicit visit A keeps listing the block
+ * as its implementer, and `resolveKind(A)` answers with a block whose manifest
+ * implements B: a mismatch that surfaces only at apply time, as rejected params.
+ * The reconciler recovers the old ref from the package overview it already loaded.
+ *
+ * Both halves are pinned here: A survives, minus the migrated version, while it
+ * still has an implementer — and is deleted once the last one leaves.
+ */
+test.each(testStorages)(
+  "changing a block's kind clears its old kind overview in normal mode with $name",
+  async ({ storageProvider }) => {
+    const { storage, teardown } = storageProvider();
+    const registry = new BlockRegistryV2(storage, undefined, { skipSnapshotCreation: true });
+
+    const ovPathA = kindOverviewPath(npmNameToKindPath(kindTestKindNpmName));
+    const ovPathB = kindOverviewPath(npmNameToKindPath(kindTestOtherKindNpmName));
+    const readOverview = async (ovPath: string): Promise<KindOverview | undefined> => {
+      const content = await storage.getFile(ovPath);
+      return content === undefined ? undefined : KindOverview.parse(JSON.parse(content.toString()));
+    };
+    const implementerVersions = (overview: KindOverview | undefined): string[] =>
+      (overview?.implementers ?? []).map((i) => i.id.version).sort();
+
+    try {
+      // Two versions of one block, both implementing kind A, both stable.
+      const a1 = kindImplementingManifest("1.0.0", "1.0.0");
+      const a2 = kindImplementingManifest("2.0.0", "1.0.0");
+      await registry.publishPackage(a1, kindTestFileReader);
+      await registry.publishPackage(a2, kindTestFileReader);
+      await registry.addPackageToChannel(a1.description.id, StableChannel);
+      await registry.addPackageToChannel(a2.description.id, StableChannel);
+      await registry.updateIfNeeded("normal");
+
+      expect(implementerVersions(await readOverview(ovPathA))).toEqual(["1.0.0", "2.0.0"]);
+      expect(await readOverview(ovPathB)).toBeUndefined();
+
+      // Re-publish 1.0.0 against kind B — same block id, different kind.
+      const b1 = kindImplementingManifest("1.0.0", "1.0.0", kindTestOtherKindNpmName);
+      await registry.publishPackage(b1, kindTestFileReader);
+      await registry.updateIfNeeded("normal");
+
+      const overviewA = await readOverview(ovPathA);
+      const overviewB = await readOverview(ovPathB);
+      expect(implementerVersions(overviewA)).toEqual(["2.0.0"]);
+      expect(implementerVersions(overviewB)).toEqual(["1.0.0"]);
+      // Each kind must resolve to the block that actually implements it now.
+      expect(resolveKind(overviewA!, "1.0.0", { allowUnstable: false })).toEqual({
+        ok: true,
+        blockId: a2.description.id,
+        channel: StableChannel,
+      });
+      expect(resolveKind(overviewB!, "1.0.0", { allowUnstable: false })).toEqual({
+        ok: true,
+        blockId: b1.description.id,
+        channel: StableChannel,
+      });
+
+      // Migrate the last implementer off A: its overview is orphaned and removed.
+      const b2 = kindImplementingManifest("2.0.0", "1.0.0", kindTestOtherKindNpmName);
+      await registry.publishPackage(b2, kindTestFileReader);
+      await registry.updateIfNeeded("normal");
+
+      expect(await readOverview(ovPathA)).toBeUndefined();
+      expect(implementerVersions(await readOverview(ovPathB))).toEqual(["1.0.0", "2.0.0"]);
+      expect(
+        resolveKind((await readOverview(ovPathB))!, "1.0.0", { allowUnstable: false }),
+      ).toEqual({ ok: true, blockId: b2.description.id, channel: StableChannel });
+    } finally {
+      await teardown();
+    }
+  },
+);
+
 test.each([
   {
     name: "test1",
diff --git a/tools/block-tools/src/v2/registry/registry.ts b/tools/block-tools/src/v2/registry/registry.ts
index 27f63af3bc..355fae88c2 100644
--- a/tools/block-tools/src/v2/registry/registry.ts
+++ b/tools/block-tools/src/v2/registry/registry.ts
@@ -10,6 +10,7 @@ import {
   blockPackIdToString,
   BlockPackManifest,
 } from "@milaboratories/pl-model-middle-layer";
+import { parseKindRef } from "@milaboratories/pl-model-common";
 import {
   GlobalUpdateSeedInFile,
   GlobalUpdateSeedOutFile,
@@ -37,6 +38,17 @@ import {
   MainPrefix,
   PackageManifestPattern,
 } from "./schema_public";
+import {
+  KindsPrefix,
+  KindManifest,
+  KindManifestFileName,
+  KindOverview,
+  KindOverviewPathPattern,
+  kindContentPrefix,
+  kindOverviewPath,
+  npmNameToKindPath,
+} from "./schema_kinds";
+import type { KindImplementer, KindVersionOverview } from "./schema_kinds";
 import type { RelativeContentReader } from "../model";
 import { addRelativePathPrefix } from "../model";
 import { randomUUID } from "node:crypto";
@@ -56,6 +68,30 @@ type PackageUpdateInfo = {
   versions: Set<string>;
 };
 
+/**
+ * What one kind overview (`kinds/{org}/{name}/overview.json`) will be rewritten to.
+ *
+ * Filled while the block manifests are already parsed in the main `updateRegistry` pass — no
+ * extra reads. Two shapes, because the pass has two modes and they read the existing file
+ * differently:
+ *
+ * - `rebuild: false` — read-modify-write. `replacedBlockIds` names the block-pack ids (with
+ *   version) whose manifests were re-read this pass; their existing `implementers` entries are
+ *   dropped so the fresh ones in `add` take their place instead of duplicating them.
+ * - `rebuild: true` — force mode. The scan re-enumerates every live kind reference, so the
+ *   existing content is discarded rather than filtered, and there is nothing to name.
+ *
+ * A discriminant rather than `Set<string> | null`: the mode is a fact about the pass, and
+ * encoding it as an absent collection makes "rebuild everything" and "replace nothing" look
+ * the same at the use site.
+ */
+type KindOverviewMerge = {
+  readonly add: KindImplementer[];
+} & (
+  | { readonly rebuild: true }
+  | { readonly rebuild: false; readonly replacedBlockIds: Set<string> }
+);
+
 export class BlockRegistryV2 {
   private readonly gzipAsync = promisify(gzip);
   private readonly gunzipAsync = promisify(gunzip);
@@ -130,7 +166,28 @@ export class BlockRegistryV2 {
 
     // reading update requests
     const packagesToUpdate = new Map<string, PackageUpdateInfo>();
+    // planned kind-overview rewrites, keyed by kinds/{org}/{name}/overview.json
+    const kindOverviewMerges = new Map<string, KindOverviewMerge>();
     const seedPaths: string[] = [];
+
+    /**
+     * Get-or-create the planned rewrite for one kind overview, recording `blockId` as
+     * re-read this pass so the RMW below drops its stale entry before merging.
+     *
+     * In force mode the plan is a rebuild and there is nothing to record — including for the
+     * plans the force pre-seed already created, which this must leave as rebuilds.
+     */
+    const mergeIntoKindOverview = (ovPath: string, blockId: string): KindOverviewMerge => {
+      const plan =
+        kindOverviewMerges.get(ovPath) ??
+        (mode === "force"
+          ? { rebuild: true as const, add: [] }
+          : { rebuild: false as const, replacedBlockIds: new Set<string>(), add: [] });
+      if (!plan.rebuild) plan.replacedBlockIds.add(blockId);
+      kindOverviewMerges.set(ovPath, plan);
+      return plan;
+    };
+
     const rawSeedPaths = await this.storage.listFiles(VersionUpdatesPrefix);
 
     const addVersionToBeUpdated = ({ organization, name, version }: BlockPackId) => {
@@ -169,6 +226,16 @@ export class BlockRegistryV2 {
         const added = addVersionToBeUpdated({ organization, name, version });
         this.logger.info(`  - ${organization}:${name}:${version} force_added:${added}`);
       }
+
+      // Seed every existing kind overview empty so kinds orphaned by
+      // migration/removal are rewritten (or deleted) this pass. The block scan
+      // above already re-enumerates every live kind ref (refs live inside block
+      // manifests); this LIST exists solely to reset orphans.
+      const kindPaths = await this.storage.listFiles(KindsPrefix);
+      for (const rel of kindPaths) {
+        if (!KindOverviewPathPattern.test(rel)) continue;
+        kindOverviewMerges.set(KindsPrefix + rel, { rebuild: true, add: [] });
+      }
     }
 
     // loading global overview
@@ -219,10 +286,19 @@ export class BlockRegistryV2 {
       );
 
       // removing versions that we will update
+      const droppedVersions = packageOverview.versions.filter((e) =>
+        packageInfo.versions.has(e.description.id.version),
+      );
       const newVersions = packageOverview.versions.filter(
         (e) => !packageInfo.versions.has(e.description.id.version),
       );
 
+      for (const e of droppedVersions) {
+        if (!e.description.kind) continue;
+        const ovPath = kindOverviewPath(npmNameToKindPath(parseKindRef(e.description.kind).name));
+        mergeIntoKindOverview(ovPath, blockPackIdToString(e.description.id));
+      }
+
       // reading new entries
       for (const [v] of packageInfo.versions.entries()) {
         const version = v.toString();
@@ -244,14 +320,26 @@ export class BlockRegistryV2 {
           }
         });
         // pushing the overview
+        const description = BlockPackManifest.parse(
+          JSON.parse(manifestContent.toString("utf8")),
+        ).description;
         newVersions.push({
-          description: addRelativePathPrefix(
-            BlockPackManifest.parse(JSON.parse(manifestContent.toString("utf8"))).description,
-            version,
-          ),
+          description: addRelativePathPrefix(description, version),
           manifestSha256: sha256,
           channels,
         });
+
+        // accumulate the kind-overview projection from this block's kind ref
+        // (both inputs already in hand: parsed manifest + listed channels).
+        if (description.kind) {
+          const { name: kindNpmName, version: kindVersion } = parseKindRef(description.kind);
+          const ovPath = kindOverviewPath(npmNameToKindPath(kindNpmName));
+          mergeIntoKindOverview(ovPath, blockPackIdToString(id)).add.push({
+            id,
+            kindVersion,
+            channels,
+          });
+        }
       }
 
       // sorting entries according to version
@@ -315,6 +403,61 @@ export class BlockRegistryV2 {
       });
     }
 
+    // projecting kind overviews (kinds/{org}/{name}/overview.json)
+    for (const [ovPath, plan] of kindOverviewMerges) {
+      // A rebuild reads nothing: the scan re-enumerated every live kind reference, so keeping
+      // any of the existing entries could only resurrect one the scan no longer sees.
+      const kept = plan.rebuild
+        ? []
+        : ((await this.getKindOverviewAt(ovPath))?.implementers ?? []).filter(
+            (e) => !plan.replacedBlockIds.has(blockPackIdToString(e.id)),
+          );
+      const merged = [...kept, ...plan.add];
+
+      if (merged.length === 0) {
+        if (mode !== "dry-run") await this.storage.deleteFiles(ovPath);
+        this.logger.info(`Kind overview ${ovPath} orphaned — removed`);
+        continue;
+      }
+
+      // bucket implementers by kind version, then compute the newest block per
+      // channel (+ derived AnyChannel), mirroring the package latestByChannel.
+      const byKindVersion = new Map<string, KindImplementer[]>();
+      for (const impl of merged) {
+        const bucket = byKindVersion.get(impl.kindVersion);
+        if (bucket) bucket.push(impl);
+        else byKindVersion.set(impl.kindVersion, [impl]);
+      }
+
+      const kindVersions: KindVersionOverview[] = [...byKindVersion.entries()]
+        .map(([kindVersion, impls]) => {
+          const allChannels = new Set<string>();
+          for (const i of impls) for (const c of i.channels) allChannels.add(c);
+          const latestByChannel = Object.fromEntries(
+            [...allChannels, AnyChannel].map((c) => {
+              const candidate = impls
+                .filter((i) => c === AnyChannel || i.channels.indexOf(c) !== -1)
+                .sort((a, b) => compareSemver(b.id.version, a.id.version))[0];
+              if (!candidate) throw new Error("Assertion error");
+              return [c, candidate.id];
+            }),
+          );
+          return { kindVersion, latestByChannel };
+        })
+        .sort((e1, e2) => compareSemver(e2.kindVersion, e1.kindVersion));
+
+      const overviewData = {
+        schema: "v1",
+        implementers: merged,
+        kindVersions,
+      } satisfies KindOverview;
+      if (mode !== "dry-run")
+        await this.storage.putFile(ovPath, Buffer.from(JSON.stringify(overviewData)));
+      this.logger.info(
+        `Kind overview ${ovPath} updated (${merged.length} implementers, ${kindVersions.length} kind versions)`,
+      );
+    }
+
     // writing global overview
     if (mode !== "dry-run") {
       const overviewData = JSON.stringify({
@@ -384,6 +527,13 @@ export class BlockRegistryV2 {
     return parseGlobalOverviewReg(JSON.parse(content.toString()));
   }
 
+  /** Read+parse a kind overview by its absolute `kinds/{org}/{name}/overview.json` path. */
+  private async getKindOverviewAt(path: string): Promise<KindOverview | undefined> {
+    const content = await this.storage.getFile(path);
+    if (content === undefined) return undefined;
+    return KindOverview.parse(JSON.parse(content.toString()));
+  }
+
   private async marchChanged(id: BlockPackId) {
     // adding update seed
     const seed = randomUUID();
@@ -501,4 +651,77 @@ export class BlockRegistryV2 {
 
     await this.marchChanged(manifest.description.id);
   }
+
+  /**
+   * Publish a block *kind* into the `kinds/` tree — idempotent, immutable,
+   * content-first. Cloned from {@link publishPackage} with two differences:
+   *
+   *   1. NET-NEW source-hash guard: kind versions are immutable. If a manifest
+   *      already exists with the same `sourceHash` this is a no-op; with a
+   *      different `sourceHash` it hard-fails. (No such guard exists for
+   *      blocks — `publishPackage` still overwrites same-version content.)
+   *   2. NO `marchChanged`: the kind projection is derived from *block*
+   *      manifests by the reconciler, so kind content publish drops no ticket —
+   *      it rides the block's publish ticket. A kind with zero implementing
+   *      blocks is deliberately invisible (no `overview.json`).
+   *
+   * The path is derived from the manifest's full npm package name
+   * (`kind.name`) via `npmNameToKindPath` (inside `kindContentPrefix`) — the
+   * SAME derivation the reconciler and readers use, so content and overview
+   * always co-locate under one `{org}/{name}` folder. There is no separate
+   * `organization` field on the identity.
+   */
+  public async publishKind(
+    kindManifest: KindManifest,
+    fileReader: RelativeContentReader,
+  ): Promise<void> {
+    const { name: npmName, version } = kindManifest.kind;
+    const prefix = kindContentPrefix(npmName, version);
+
+    // NET-NEW source-hash immutability guard (absent / equal / differ).
+    const existing = await this.storage.getFile(`${prefix}/${KindManifestFileName}`);
+    if (existing !== undefined) {
+      const prev = KindManifest.parse(JSON.parse(existing.toString()));
+      if (prev.sourceHash === kindManifest.sourceHash) {
+        this.logger.info(
+          `Kind ${npmName}@${version} already published with identical source — no-op`,
+        );
+        return; // idempotent
+      }
+      throw new Error(
+        `Immutable kind version republished with different content: ${prefix} ` +
+          `(stored sourceHash ${prev.sourceHash} != ${kindManifest.sourceHash})`,
+      );
+    }
+
+    // content-first upload, per-file size + sha256 verify (mirrors publishPackage)
+    for (const f of kindManifest.files) {
+      const bytes = await fileReader(f.name);
+      if (bytes.length !== f.size)
+        throw new Error(
+          `Actual file size don't match the manifest for ${f.name} (actual = ${bytes.length}; manifest = ${f.size})`,
+        );
+      const sha256 = await calculateSha256(bytes);
+      if (sha256 !== f.sha256.toUpperCase())
+        throw new Error(
+          `Actual file SHA-256 don't match the manifest for ${f.name} (actual = ${sha256}; manifest = ${f.sha256.toUpperCase()})`,
+        );
+
+      const dst = `${prefix}/${f.name}`;
+      this.logger.info(`Uploading ${f.name} -> ${dst} ...`);
+      await this.storage.putFile(dst, bytes);
+    }
+
+    // manifest LAST = commit marker; stamp firstUploadTimestamp when absent.
+    const toStore = KindManifest.parse({
+      ...kindManifest,
+      firstUploadTimestamp: kindManifest.firstUploadTimestamp ?? Date.now(),
+    } satisfies KindManifest);
+    const manifestDst = `${prefix}/${KindManifestFileName}`;
+    this.logger.info(`Uploading kind manifest to ${manifestDst} ...`);
+    await this.storage.putFile(manifestDst, Buffer.from(JSON.stringify(toStore)));
+
+    // NO `marchChanged`: the kind projection is derived from block manifests, so this
+    // publish drops no ticket of its own — see the note on this method.
+  }
 }
diff --git a/tools/block-tools/src/v2/registry/registry_reader.ts b/tools/block-tools/src/v2/registry/registry_reader.ts
index 737510c7f5..f05f34d1cf 100644
--- a/tools/block-tools/src/v2/registry/registry_reader.ts
+++ b/tools/block-tools/src/v2/registry/registry_reader.ts
@@ -6,12 +6,15 @@ import type {
   UpdateSuggestions,
   SingleBlockPackOverview,
   BlockPackOverviewNoRegistryId,
+  BlockPackFromRegistryV2,
 } from "@milaboratories/pl-model-middle-layer";
 import {
   blockPackIdNoVersionEquals,
   BlockPackManifest,
   AnyChannel,
 } from "@milaboratories/pl-model-middle-layer";
+import type { BlockKindReference } from "@milaboratories/pl-model-common";
+import { parseKindRef } from "@milaboratories/pl-model-common";
 import type { FolderReader } from "../../io";
 import canonicalize from "canonicalize";
 import {
@@ -22,6 +25,8 @@ import {
   packageContentPrefixInsideV2,
   parseGlobalOverviewReg,
 } from "./schema_public";
+import { KindsPrefix, KindOverview, KindOverviewFileName, npmNameToKindPath } from "./schema_kinds";
+import { resolveKind as resolveKindOverview, KindResolutionError } from "./kind_resolver";
 import type { BlockComponentsAbsoluteUrl } from "../model";
 import { blockComponentsManifestToAbsoluteUrl, embedBlockPackMetaBytes } from "../model";
 import { LRUCache } from "lru-cache";
@@ -65,6 +70,8 @@ export function inferUpdateSuggestions(currentVersion: string, availableVersions
 
 export class RegistryV2Reader {
   private readonly v2RootFolderReader: FolderReader;
+  /** Rooted at `kinds/`, a sibling of `v2/` — the kind projection tree. */
+  private readonly kindsRootFolderReader: FolderReader;
   private readonly ops: RegistryV2ReaderOps;
 
   constructor(
@@ -72,6 +79,7 @@ export class RegistryV2Reader {
     ops?: Partial<RegistryV2ReaderOps>,
   ) {
     this.v2RootFolderReader = registryReader.relativeReader(MainPrefix);
+    this.kindsRootFolderReader = registryReader.relativeReader(KindsPrefix);
     this.ops = { ...DefaultRegistryV2ReaderOps, ...ops };
   }
 
@@ -259,4 +267,64 @@ export class RegistryV2Reader {
   public async getComponents(id: BlockPackId): Promise<BlockComponentsAbsoluteUrl> {
     return await this.componentsCache.forceFetch(canonicalize(id)!, { context: id });
   }
+
+  /**
+   * Read the kind projection at `kinds/{org}/{name}/overview.json` for a kind
+   * npm package name. Single, no-LIST read against the `kinds/` sibling tree
+   * (rooted separately from `v2/`). Returns `undefined` when the overview is
+   * absent — a kind with zero implementing blocks has no overview by design.
+   *
+   * Client-side selector→version resolution is left to the §6 resolution
+   * concern; this method only fetches and parses.
+   */
+  public async getKindOverview(
+    kindNpmName: string,
+    options?: { signal?: AbortSignal },
+  ): Promise<KindOverview | undefined> {
+    const { org, name } = npmNameToKindPath(kindNpmName);
+    const relPath = `${org}/${name}/${KindOverviewFileName}`;
+    try {
+      return await retry(async () => {
+        const bytes = await this.kindsRootFolderReader.readFile(relPath, {
+          signal: options?.signal,
+        });
+        return KindOverview.parse(JSON.parse(Buffer.from(bytes).toString()));
+      }, Retry2TimesWithDelay);
+    } catch {
+      // Absent overview (or unreadable) → treat as "no such kind projection".
+      return undefined;
+    }
+  }
+
+  /**
+   * Resolve a kind reference (`{name}@{selector}`) to a concrete implementing
+   * block, returning the **byte-identical** `from-registry-v2` spec shape that
+   * {@link getSpecificOverview} emits — so the resolved block flows through the
+   * unchanged add-block / `getComponents` / `prepareBlockPack` path.
+   *
+   * One projection read ({@link getKindOverview}) + client-side semver
+   * ({@link resolveKindOverview}); kind and its implementing blocks share this
+   * one registry, so no cross-registry intersection is needed. Throws a typed
+   * {@link KindResolutionError} on any failure (absent projection or no
+   * satisfying version/implementation) — the caller maps it to a spec error.
+   */
+  public async resolveKind(
+    ref: BlockKindReference,
+    { allowUnstable }: { allowUnstable: boolean },
+    options?: { signal?: AbortSignal },
+  ): Promise<BlockPackFromRegistryV2> {
+    const { name, version } = parseKindRef(ref);
+    const overview = await this.getKindOverview(name, options);
+    if (overview === undefined) throw new KindResolutionError("no-matching-kind-version", ref);
+
+    const r = resolveKindOverview(overview, version, { allowUnstable });
+    if (!r.ok) throw new KindResolutionError(r.reason, ref);
+
+    return {
+      type: "from-registry-v2",
+      id: r.blockId,
+      registryUrl: this.registryReader.rootUrl.toString(),
+      channel: r.channel,
+    };
+  }
 }
diff --git a/tools/block-tools/src/v2/registry/schema_kinds.test.ts b/tools/block-tools/src/v2/registry/schema_kinds.test.ts
new file mode 100644
index 0000000000..50a81eff89
--- /dev/null
+++ b/tools/block-tools/src/v2/registry/schema_kinds.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, test } from "vitest";
+import { formatKindRef, parseKindRef } from "@milaboratories/pl-model-common";
+import { kindContentPrefix, kindOverviewPath, npmNameToKindPath } from "./schema_kinds";
+
+/**
+ * Seam-2 regression guard: a kind's reference is the FULL npm package name +
+ * version, and EVERYONE derives the S3 `{org, name}` from that npm name via the
+ * single `npmNameToKindPath` helper. If content and overview ever derive the
+ * folder differently again, this round-trip fails.
+ */
+describe("kind reference / path derivation round-trip", () => {
+  const npmName = "@platforma-open/milaboratories.mixcr-clonotyping.kind";
+  const version = "1.2.0";
+
+  test("npmName -> formatKindRef -> parseKindRef preserves name and version", () => {
+    const ref = formatKindRef({ name: npmName, version });
+    expect(ref).toBe(`${npmName}@${version}`);
+
+    // Split on the LAST '@', so the scoped npm name (which itself starts with
+    // '@') survives intact.
+    const parsed = parseKindRef(ref);
+    expect(parsed).toEqual({ name: npmName, version });
+  });
+
+  test("content path and overview path share the same {org, name} folder", () => {
+    const ref = formatKindRef({ name: npmName, version });
+    const parsed = parseKindRef(ref);
+
+    // The SINGLE derivation everyone uses.
+    const loc = npmNameToKindPath(parsed.name);
+
+    const contentPrefix = kindContentPrefix(parsed.name, parsed.version);
+    const overviewPath = kindOverviewPath(loc);
+
+    // Strip the version segment / the overview filename to expose the folder.
+    const contentDir = contentPrefix.slice(0, contentPrefix.lastIndexOf("/"));
+    const overviewDir = overviewPath.slice(0, overviewPath.lastIndexOf("/"));
+
+    expect(contentDir).toBe(overviewDir);
+    // kindContentPrefix derives {org,name} internally from the SAME npm name, so
+    // the co-located folder is exactly `kinds/{org}/{name}`.
+    expect(contentDir).toBe(`kinds/${loc.org}/${loc.name}`);
+    expect(contentPrefix).toBe(`kinds/${loc.org}/${loc.name}/${version}`);
+  });
+
+  test("npmNameToKindPath delegates to parsePackageName (scope dropped, 1st dotted segment = org, 2nd = name, .kind ignored)", () => {
+    // Scoped form: the npm scope (`@platforma-open/`) is dropped, then the dotted
+    // body yields org = 1st segment, name = 2nd, and the trailing `.kind` marker
+    // is simply not matched by the canonical parser.
+    expect(npmNameToKindPath("@platforma-open/milaboratories.mixcr-clonotyping.kind")).toEqual({
+      org: "milaboratories",
+      name: "mixcr-clonotyping",
+    });
+    // Bare dotted form: org = 1st segment, name = 2nd, `.kind` ignored.
+    expect(npmNameToKindPath("platforma-open.mixcr-clonotyping.kind")).toEqual({
+      org: "platforma-open",
+      name: "mixcr-clonotyping",
+    });
+    // Delegation means the derivation is identical whether or not the `.kind`
+    // marker is present — the trailing segment never participates in the split.
+    expect(npmNameToKindPath("@platforma-open/milaboratories.mixcr-clonotyping")).toEqual(
+      npmNameToKindPath("@platforma-open/milaboratories.mixcr-clonotyping.kind"),
+    );
+  });
+});
diff --git a/tools/block-tools/src/v2/registry/schema_kinds.ts b/tools/block-tools/src/v2/registry/schema_kinds.ts
new file mode 100644
index 0000000000..6861260130
--- /dev/null
+++ b/tools/block-tools/src/v2/registry/schema_kinds.ts
@@ -0,0 +1,169 @@
+import { BlockPackId, SemVer, Sha256Schema } from "@milaboratories/pl-model-middle-layer";
+// @todo: don't use zod
+import { z } from "zod";
+import { parsePackageName } from "../source_package";
+
+/**
+ * Registry tree for block *kinds*, a sibling of {@link MainPrefix} (`v2/`).
+ *
+ * Layout mirrors the package tree one level down:
+ *   kinds/{org}/{name}/{version}/manifest.json   — immutable kind content (publishKind)
+ *   kinds/{org}/{name}/{version}/kind.d.ts        — kind artifacts
+ *   kinds/{org}/{name}/overview.json              — projection over implementing blocks (reconciler)
+ */
+export const KindsPrefix = "kinds/";
+
+export const KindOverviewFileName = "overview.json";
+export const KindManifestFileName = "manifest.json";
+
+/** Location of a kind inside the `kinds/` tree, split into path segments. */
+export interface KindPathLocation {
+  org: string;
+  name: string;
+}
+
+/**
+ * `kinds/{org}/{name}/{version}` — the immutable per-version content folder,
+ * counterpart of {@link packageContentPrefix}.
+ *
+ * The `{org, name}` segments are DERIVED from the kind's full npm package name
+ * via {@link npmNameToKindPath} — the SAME helper {@link kindOverviewPath} and
+ * the reconciler use. This is what guarantees a kind's per-version content and
+ * its `overview.json` projection land under one identical `{org}/{name}` folder.
+ */
+export function kindContentPrefix(npmName: string, version: string): string {
+  const { org, name } = npmNameToKindPath(npmName);
+  return `${KindsPrefix}${org}/${name}/${version}`;
+}
+
+/**
+ * `kinds/{org}/{name}/overview.json` — the reconciler-maintained projection of
+ * every block that implements this kind, bucketed by kind version.
+ */
+export function kindOverviewPath(loc: KindPathLocation): string {
+  return `${KindsPrefix}${loc.org}/${loc.name}/${KindOverviewFileName}`;
+}
+
+/**
+ * Matches a `kinds/`-relative overview path (`{org}/{name}/overview.json`).
+ * Used by the force-mode orphan seed to enumerate every existing overview.
+ */
+export const KindOverviewPathPattern = new RegExp(
+  `^(?<org>[^/]+)/(?<name>[^/]+)/${KindOverviewFileName.replace(".", "\\.")}$`,
+);
+
+/**
+ * Kind npm package name → `{org, name}` path segments.
+ *
+ * DELEGATES to {@link parsePackageName} — the canonical block npm-name parser
+ * (`source_package.ts`) — so kind registry paths (`kinds/{org}/{name}/…`) mirror
+ * block paths (`v2/{org}/{name}/…`) byte-for-byte and cannot drift. That parser
+ * drops the npm scope (`@platforma-open/`), takes the 1st dotted segment as the
+ * organization and the 2nd as the name, and ignores any trailing segment (the
+ * kind's `.kind` marker simply is not matched):
+ *   - `@platforma-open/milaboratories.mixcr-clonotyping.kind` → `{ org: "milaboratories", name: "mixcr-clonotyping" }`
+ *   - `milaboratories.mixcr-clonotyping.kind`                 → `{ org: "milaboratories", name: "mixcr-clonotyping" }`
+ *
+ * This helper is DISTINCT from `parseKindRef` (the `{name}@{version}` reference
+ * codec in `block_kind_ref.ts`): `parseKindRef` splits a reference into
+ * name/version; `npmNameToKindPath` splits the *name* half into path segments.
+ */
+export function npmNameToKindPath(npmName: string): KindPathLocation {
+  const { organization, name } = parsePackageName(npmName);
+  return { org: organization, name };
+}
+
+/**
+ * On-wire kind identity, mirroring the `kind` block written by the build side
+ * (`build_kind_dist.ts` `KindManifestIdentity`).
+ *
+ * `name` is the FULL npm package name of the kind (e.g.
+ * `@platforma-open/milaboratories.mixcr-clonotyping.kind`). There is no separate
+ * `organization` field — the S3 `{org, name}` path is always derived from this
+ * npm name via {@link npmNameToKindPath}, so the content publisher and the
+ * overview reconciler resolve to the same folder.
+ */
+export const KindManifestIdentity = z
+  .object({
+    name: z.string(),
+    version: SemVer,
+  })
+  .passthrough();
+export type KindManifestIdentity = z.infer<typeof KindManifestIdentity>;
+
+export const KindManifestFileInfo = z
+  .object({
+    name: z.string(),
+    size: z.number(),
+    sha256: Sha256Schema,
+  })
+  .passthrough();
+export type KindManifestFileInfo = z.infer<typeof KindManifestFileInfo>;
+
+/**
+ * Kind content manifest, as produced by `build_kind_dist.ts` and stored (LAST,
+ * as the commit marker) at `kinds/{org}/{name}/{version}/manifest.json`.
+ *
+ * `sourceHash` is the sorted-`src/`-tree digest computed at build time (NOT the
+ * per-file `calculateSha256`); it is the comparand for the publish-time
+ * source-hash immutability guard. `firstUploadTimestamp` is stamped by
+ * `publishKind` when the manifest is first written to the registry.
+ */
+export const KindManifest = z
+  .object({
+    schema: z.literal("v1"),
+    kind: KindManifestIdentity,
+    sourceHash: z.string(),
+    files: z.array(KindManifestFileInfo),
+    /** Build-time timestamp carried from `build_kind_dist.ts`. */
+    timestamp: z.number().optional(),
+    /** Stamped by `publishKind` on first upload to the registry. */
+    firstUploadTimestamp: z.number().optional(),
+  })
+  .passthrough();
+export type KindManifest = z.infer<typeof KindManifest>;
+
+/**
+ * One implementing block version for some kind version. Flat and
+ * RMW-friendly: the reconciler filters this list by `(id)` to drop stale
+ * entries before re-adding fresh ones.
+ */
+export const KindImplementer = z
+  .object({
+    /** Full id of the implementing block, incl. its version. */
+    id: BlockPackId,
+    /** Kind version this block implements. */
+    kindVersion: SemVer,
+    /** Channels the block version is published to. */
+    channels: z.array(z.string()).default(() => []),
+  })
+  .passthrough();
+export type KindImplementer = z.infer<typeof KindImplementer>;
+
+/**
+ * Per-kind-version projection: the newest implementing block per channel,
+ * including the derived `any` channel. Mirrors the package overview's
+ * `latestByChannel` + `AnyChannel` computation.
+ */
+export const KindVersionOverview = z
+  .object({
+    kindVersion: SemVer,
+    latestByChannel: z.record(z.string(), BlockPackId),
+  })
+  .passthrough();
+export type KindVersionOverview = z.infer<typeof KindVersionOverview>;
+
+/**
+ * Reconciler-maintained projection at `kinds/{org}/{name}/overview.json`.
+ *
+ * `implementers` is the flat, RMW source of truth; `kindVersions` is the
+ * derived, reader-facing view (kind versions × newest implementer per channel).
+ */
+export const KindOverview = z
+  .object({
+    schema: z.literal("v1"),
+    implementers: z.array(KindImplementer),
+    kindVersions: z.array(KindVersionOverview),
+  })
+  .passthrough();
+export type KindOverview = z.infer<typeof KindOverview>;
diff --git a/tools/ts-builder/public/rolldown.block-kind.config.js b/tools/ts-builder/public/rolldown.block-kind.config.js
new file mode 100644
index 0000000000..54a2c57419
--- /dev/null
+++ b/tools/ts-builder/public/rolldown.block-kind.config.js
@@ -0,0 +1,4 @@
+import { defineConfig } from "rolldown";
+import { createRolldownBlockKindConfig } from "@milaboratories/ts-builder/configs/utils/createRolldownBlockKindConfig.js";
+
+export default defineConfig(createRolldownBlockKindConfig());
diff --git a/tools/ts-builder/public/tsconfig.block-kind.json b/tools/ts-builder/public/tsconfig.block-kind.json
new file mode 100644
index 0000000000..765e821dc0
--- /dev/null
+++ b/tools/ts-builder/public/tsconfig.block-kind.json
@@ -0,0 +1,9 @@
+{
+  "extends": "@milaboratories/ts-configs/block/facade",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/tools/ts-builder/src/commands/utils/config-manager.ts b/tools/ts-builder/src/commands/utils/config-manager.ts
index 3737c65c2f..b1e1e7a8e6 100644
--- a/tools/ts-builder/src/commands/utils/config-manager.ts
+++ b/tools/ts-builder/src/commands/utils/config-manager.ts
@@ -7,6 +7,7 @@ export type TargetType =
   | "browser-lib"
   | "block-model"
   | "block-facade"
+  | "block-kind"
   | "block-ui"
   | "block-test";
 
@@ -37,6 +38,10 @@ const TARGET_CONFIG_MAP: Record<Exclude<TargetType, "block-test">, ConfigInfo> =
     filename: "rolldown.block-facade.config.js",
     outputPath: "./build.block-facade.config.js",
   },
+  "block-kind": {
+    filename: "rolldown.block-kind.config.js",
+    outputPath: "./build.block-kind.config.js",
+  },
   "block-ui": {
     filename: "vite.block-ui.config.js",
     outputPath: "./build.block-ui.config.js",
@@ -49,6 +54,7 @@ const TSCONFIG_MAP: Record<TargetType, string> = {
   "browser-lib": "tsconfig.browser.json",
   "block-model": "tsconfig.block-model.json",
   "block-facade": "tsconfig.block-facade.json",
+  "block-kind": "tsconfig.block-kind.json",
   "block-ui": "tsconfig.block-ui.json",
   "block-test": "tsconfig.block-test.json",
 };
@@ -180,6 +186,7 @@ const TARGET_TO_OXLINT_MAP: Record<TargetType, OxlintConfigType> = {
   "browser-lib": "browser",
   "block-model": "block-model",
   "block-facade": "node",
+  "block-kind": "node",
   "block-ui": "block-ui",
   "block-test": "block-test",
 };
diff --git a/tools/ts-builder/src/configs/rolldown/block-kind.config.ts b/tools/ts-builder/src/configs/rolldown/block-kind.config.ts
new file mode 100644
index 0000000000..7e6b831b2a
--- /dev/null
+++ b/tools/ts-builder/src/configs/rolldown/block-kind.config.ts
@@ -0,0 +1,4 @@
+import { defineConfig } from "rolldown";
+import { createRolldownBlockKindConfig } from "../utils/createRolldownBlockKindConfig";
+
+export default defineConfig(createRolldownBlockKindConfig());
diff --git a/tools/ts-builder/src/configs/utils/createRolldownBlockKindConfig.ts b/tools/ts-builder/src/configs/utils/createRolldownBlockKindConfig.ts
new file mode 100644
index 0000000000..f7adbe1143
--- /dev/null
+++ b/tools/ts-builder/src/configs/utils/createRolldownBlockKindConfig.ts
@@ -0,0 +1,44 @@
+import type { RolldownOptions } from "rolldown";
+import { dts } from "rolldown-plugin-dts";
+import { createRolldownNodeConfig, type RolldownNodeConfigProps } from "./createRolldownNodeConfig";
+
+export interface RolldownBlockKindConfigProps extends RolldownNodeConfigProps {
+  output?: string;
+}
+
+/**
+ * A kind builds twice, for two consumers that want opposite things — the same
+ * split `createRolldownBlockModelConfig` makes.
+ *
+ * - **`index.js` / `index.cjs`**, dependencies external. What a block imports. A kind
+ *   that validates its params depends on a schema library, and a block model that
+ *   uses the same one must end up with ONE copy in its bundle: a self-contained kind
+ *   would contribute a second, and the model bundle is re-evaluated on every model-VM
+ *   call, so the duplicate is paid per call rather than once.
+ * - **`kind.js`**, everything inlined. What the registry publishes and what
+ *   `build-kind-manifest` hashes into the kind's `manifest.json`. It has to stand alone
+ *   because nothing resolves node_modules for it on the way out.
+ */
+export function createRolldownBlockKindConfig(
+  props?: RolldownBlockKindConfigProps,
+): RolldownOptions[] {
+  const output = props?.output ?? "dist";
+
+  return [
+    ...createRolldownNodeConfig(props),
+    {
+      input: { kind: "src/index.ts" },
+      external: () => false,
+      plugins: [dts({ tsconfig: "tsconfig.json", emitDtsOnly: false, sourcemap: true })],
+      output: {
+        dir: output,
+        format: "es",
+        entryFileNames: "[name].js",
+        sourcemap: true,
+      },
+      transform: {
+        target: "ES2022",
+      },
+    },
+  ];
+}