@milaboratories/pl-model-common 1.48.0 → 1.50.0

package/dist/template/project_template_v1.d.ts

@@ -1,13 +1,12 @@
 import { BlockKindSelectorReference } from "./kind_selector.js";
 import { Branded } from "@milaboratories/helpers";
-
 //#region src/template/project_template_v1.d.ts
 /**
  * Value of a template file's `schema` field — the format marker every
  * `template-v1` document opens with.
  */
-declare const PROJECT_TEMPLATE_SCHEMA_V1 = "template-v1";
-type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
+export declare 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`.
  *
@@ -16,14 +15,14 @@ type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
  * `BlockPackId` (`{ organization, name, version }`) is import-side work; the
  * organization lives inside the npm scope here, as it does for kind names.
  */
-type BlockPackReference = Branded<string, "BlockPackReference">;
+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`
  */
-declare function parseBlockPackReference(ref: BlockPackReference): {
+export declare function parseBlockPackReference(ref: BlockPackReference): {
   name: string;
   version: string;
 };
@@ -42,7 +41,7 @@ declare function parseBlockPackReference(ref: BlockPackReference): {
  * business: this type fixes only the grammar, so a document remains readable by a
  * consumer that cannot fetch every scheme.
  */
-type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
+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
@@ -54,7 +53,7 @@ type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
  *
  * @throws if the value carries no scheme
  */
-declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
+export declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
   scheme: string;
 };
 /**
@@ -75,7 +74,7 @@ declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
  * entirely; carrying both would state two different things with no way to reconcile them, so
  * the type admits at most one.
  */
-type ProjectTemplateV1Entry = {
+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,
@@ -110,7 +109,7 @@ type ProjectTemplateV1Entry = {
  * Readers are unaffected: every arm declares both keys, so `entry.block` and `entry.location`
  * stay directly readable without narrowing.
  */
-type BlockPackLocatorOverride = {
+export type BlockPackLocatorOverride = {
   /**
    * WHICH VERSION to install, leaving it to the environment to decide which registry
    * serves it — so an entry pinned this way stays portable.
@@ -120,10 +119,12 @@ type BlockPackLocatorOverride = {
    * it already records the exact version the block implements, leaving a pin nothing to
    * add — so this is a hand-written field.
    */
-  readonly block?: BlockPackReference; /** Excluded: this arm is the version pin. */
+  readonly block?: BlockPackReference;
+  /** Excluded: this arm is the version pin. */
   readonly location?: never;
 } | {
-  /** Excluded: this arm is the place. */readonly block?: never;
+  /** Excluded: this arm is the place. */
+  readonly block?: never;
   /**
    * WHICH PLACE to install from, as an absolute URI (see
    * {@link BlockPackLocationReference}).
@@ -151,13 +152,15 @@ type BlockPackLocatorOverride = {
  * dependency; serializing to YAML bytes belongs with the caller that already
  * has one (pl-middle-layer).
  */
-type ProjectTemplateV1 = {
+export type ProjectTemplateV1 = {
   readonly schema: ProjectTemplateSchemaV1;
   readonly blocks: readonly ProjectTemplateV1Entry[];
 };
 /** One thing wrong with a document, and where in it. */
-type TemplateParseIssue = {
-  /** Location in the decoded value: `["blocks", 2, "kind"]`. */readonly path: readonly (string | number)[]; /** What is wrong, worded for whoever is editing the file. */
+export type TemplateParseIssue = {
+  /** Location in the decoded value: `["blocks", 2, "kind"]`. */
+  readonly path: readonly (string | number)[];
+  /** What is wrong, worded for whoever is editing the file. */
   readonly message: string;
 };
 /**
@@ -166,19 +169,19 @@ type TemplateParseIssue = {
  * Indexes read as they are written in the file — `blocks[2]`, not `blocks.2` — so the place
  * can be found by reading rather than by counting.
  */
-declare function formatTemplateParseIssue(issue: TemplateParseIssue): string;
+export declare function formatTemplateParseIssue(issue: TemplateParseIssue): string;
 /**
  * Every problem a document has, thrown once so a caller fixes the file in one pass.
  *
  * The issues are in `message` as well as on `issues`, because a throw that escapes to a log is
  * read as its message and nothing else.
  */
-declare class ProjectTemplateV1ParseError extends Error {
+export declare class ProjectTemplateV1ParseError extends Error {
   readonly issues: readonly TemplateParseIssue[];
   constructor(issues: readonly TemplateParseIssue[]);
 }
 /** A document, or everything wrong with the value that was supposed to be one. */
-type ProjectTemplateV1ReadResult = {
+export type ProjectTemplateV1ReadResult = {
   readonly ok: true;
   readonly document: ProjectTemplateV1;
 } | {
@@ -202,14 +205,13 @@ type ProjectTemplateV1ReadResult = {
  *
  * Collects rather than stops: a file with three mistakes should take one pass to fix.
  */
-declare function readProjectTemplateV1(value: unknown): ProjectTemplateV1ReadResult;
+export declare function readProjectTemplateV1(value: unknown): ProjectTemplateV1ReadResult;
 /**
  * {@link readProjectTemplateV1} for a caller that treats an unreadable document as
  * exceptional — export, which asserts on every run that what it wrote can be read back.
  *
  * @throws {ProjectTemplateV1ParseError} carrying every problem found
  */
-declare function parseProjectTemplateV1(value: unknown): ProjectTemplateV1;
+export declare function parseProjectTemplateV1(value: unknown): ProjectTemplateV1;
 //#endregion
-export { BlockPackLocationReference, BlockPackLocatorOverride, BlockPackReference, PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateSchemaV1, ProjectTemplateV1, ProjectTemplateV1Entry, ProjectTemplateV1ParseError, ProjectTemplateV1ReadResult, TemplateParseIssue, formatTemplateParseIssue, parseBlockPackLocation, parseBlockPackReference, parseProjectTemplateV1, readProjectTemplateV1 };
 //# sourceMappingURL=project_template_v1.d.ts.map

package/dist/template/project_template_v1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project_template_v1.d.ts","names":[],"sources":["../../src/template/project_template_v1.ts"],"mappings":";;;;;;AASA;;cAAa,0BAAA;AAAA,KACD,uBAAA,UAAiC,0BAA0B;AADhC;AACvC;;;;AAAuE;AAUvE;;AAXuC,KAW3B,kBAAA,GAAqB,OAAO;;AAAA;AAQxC;;;;iBAAgB,uBAAA,CAAwB,GAAA,EAAK,kBAAkB;EAC7D,IAAA;EACA,OAAA;AAAA;;AAAO;AA2BT;;;;AAAgD;AAahD;;;;;;;;KAbY,0BAAA,GAA6B,OAAO;AAqDhD;;;;;;;;;;;AAAA,iBAxCgB,sBAAA,CAAuB,GAAA,EAAK,0BAA0B;EAAK,MAAA;AAAA;;AA+D/C;AAa5B;;;;;;;;;;;AA6BoD;AAiBpD;;;;KAlFY,sBAAA;EAmFO;;;;AAC+B;EAD/B,SA7ER,EAAA;EAAA,SACA,IAAA,EAAM,0BAAA;;;AAiGC;AASlB;;;;AAAkE;AAmBlE;;;;;;WA9GW,MAAA,EAAQ,MAAA;AAAA,IACf,wBAAA;;;;;;;;AA8GwD;AAY5D;;;KA7GY,wBAAA;EA8GG;;;;;;;AACuD;AAyBtE;EA1Be,SAnGA,KAAA,GAAQ,kBAAA;WAER,QAAA;AAAA;EAwRC,gDApRD,KAAA;;;AAoR0D;;;;;;;;;WAxQ1D,QAAA,GAAW,0BAA0B;AAAA;;;;;;;;;;;;;;;KAiBxC,iBAAA;EAAA,SACD,MAAA,EAAQ,uBAAA;EAAA,SACR,MAAA,WAAiB,sBAAsB;AAAA;;KAgBtC,kBAAA;yEAED,IAAA;WAEA,OAAO;AAAA;;;;;;;iBASF,wBAAA,CAAyB,KAAyB,EAAlB,kBAAkB;;;;;;;cAmBrD,2BAAA,SAAoC,KAAA;EAAA,SAC1B,MAAA,WAAiB,kBAAA;cAAjB,MAAA,WAAiB,kBAAA;AAAA;;KAY5B,2BAAA;EAAA,SACG,EAAA;EAAA,SAAmB,QAAA,EAAU,iBAAA;AAAA;EAAA,SAC7B,EAAA;EAAA,SAAoB,MAAA,WAAiB,kBAAkB;AAAA;;;;;;;;;;;;;;;;;;iBAyBtD,qBAAA,CAAsB,KAAA,YAAiB,2BAA2B;;;;;;;iBA6JlE,sBAAA,CAAuB,KAAA,YAAiB,iBAAiB"}
+{"version":3,"file":"project_template_v1.d.ts","names":[],"sources":["../../src/template/project_template_v1.ts"],"mappings":";;;;;;;qBASa;YACD,iCAAiC;;;;;;;;;YAUjC,qBAAqB;;;;;;;wBAQjB,wBAAwB,KAAK;EAC3C;EACA;;;;;;;;;;;;;;;;;YA2BU,6BAA6B;;;;;;;;;;;;wBAazB,uBAAuB,KAAK;EAA+B;;;;;;;;;;;;;;;;;;;;YAwC/D;;;;;;WAMD;WACA,MAAM;;;;;;;;;;;;;;;WAeN,QAAQ;IACf;;;;;;;;;;;;YAaQ;;;;;;;;;;WAWG,QAAQ;;WAER;;;WAIA;;;;;;;;;;;;WAYA,WAAW;;;;;;;;;;;;;;;;YAiBd;WACD,QAAQ;WACR,iBAAiB;;;YAgBhB;;WAED;;WAEA;;;;;;;;wBASK,yBAAyB,OAAO;;;;;;;qBAmBnC,oCAAoC;WAC1B,iBAAiB;EAAtC,YAAqB,iBAAiB;;;YAY5B;WACG;WAAmB,UAAU;;WAC7B;WAAoB,iBAAiB;;;;;;;;;;;;;;;;;;;wBAyBpC,sBAAsB,iBAAiB;;;;;;;wBA6JvC,uBAAuB,iBAAiB"}

package/dist/template/template_ref_form.d.ts

@@ -26,8 +26,10 @@
  * parser runs, so a kind's params contract is written against `PlRef` alone and never learns
  * this type exists.
  */
-type TemplatePlRef = {
-  /** The template-local id of the entry this points at. */readonly block: string; /** The upstream output's name, exactly as a `PlRef` spells it. */
+export type TemplatePlRef = {
+  /** The template-local id of the entry this points at. */
+  readonly block: string;
+  /** The upstream output's name, exactly as a `PlRef` spells it. */
   readonly name: string;
 };
 /**
@@ -37,7 +39,7 @@ type TemplatePlRef = {
  * and nothing else. A value carrying `__isRef` is a `PlRef` already and is not this — the two
  * are told apart by shape and never overlap.
  */
-declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
+export declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
 /**
  * Expand every readable reference form in `params` into the form the system stores.
  *
@@ -68,7 +70,6 @@ declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
  * would have to be resolved somewhere that knows the document, and would drag that knowledge
  * into every caller of this. Keep them information-preserving.
  */
-declare function expandTemplateRefs<T>(params: T): T;
+export declare function expandTemplateRefs<T>(params: T): T;
 //#endregion
-export { TemplatePlRef, expandTemplateRefs, isTemplatePlRef };
 //# sourceMappingURL=template_ref_form.d.ts.map

package/dist/template/template_ref_form.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template_ref_form.d.ts","names":[],"sources":["../../src/template/template_ref_form.ts"],"mappings":";;AA6BA;;;;AAIe;AAUf;;;;;;;;AAAuE;AAsCvE;;;;;;;;;AAAmD;;;KApDvC,aAAA;oEAED,KAAA;WAEA,IAAI;AAAA;;;;;;;;iBAUC,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCvD,kBAAA,IAAsB,MAAA,EAAQ,CAAA,GAAI,CAAC"}
+{"version":3,"file":"template_ref_form.d.ts","names":[],"sources":["../../src/template/template_ref_form.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6BY;;WAED;;WAEA;;;;;;;;;wBAUK,gBAAgB,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsC1C,mBAAmB,GAAG,QAAQ,IAAI"}

package/dist/template/template_relocate.cjs

@@ -1,5 +1,7 @@
+const require_spec = require("../drivers/pframe/spec/spec.cjs");
 const require_ids = require("../drivers/pframe/spec/ids.cjs");
 require("../drivers/index.cjs");
+let es_toolkit = require("es-toolkit");
 //#region src/template/template_relocate.ts
 /**
 * Point every column identifier in a block's params at the blocks of the project being built.
@@ -16,8 +18,13 @@ require("../drivers/index.cjs");
 *
 * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
 * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
-* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
-* what re-sorts a qualifications map whose keys are identifiers.
+* like an id — an axis filter, a domain this package can see belongs to an identifier it
+* knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+* keys are identifiers.
+*
+* A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+* qualified by the block that produced it. Only the domain keys known to name a block are
+* repointed — matching an entry id is not on its own evidence of a reference.
 *
 * An id the map does not mention is left as it is. That is the ordering rule doing its work:
 * a caller building the map as it creates blocks passes only the entries already created, so
@@ -35,9 +42,23 @@ function relocateBlockIds(params, blockIds) {
 		if (typeof node === "string") return require_ids.remapColumnIdBlockIds(node, remapBlockId);
 		if (require_ids.isColumnUniversalKey(node)) return require_ids.remapColumnIdBlockIds(node, remapBlockId);
 		if (Array.isArray(node)) return node.map(walk);
-		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [require_ids.remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [require_ids.remapColumnIdBlockIds(key, remapBlockId), key === "domain" && (0, es_toolkit.isPlainObject)(value) ? relocateDomain(value) : walk(value)]));
 		return node;
 	};
+	/**
+	* The block-naming entries of a domain, repointed at the project being built: an axis a block
+	* produced names that block in its domain, so those are references like any other.
+	*
+	* Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary
+	* non-empty strings — a hand-written template may name an entry `closest`, and a qualifier
+	* reading `closest` is not a reference to it. Matching the map is not on its own enough to
+	* tell one from the other; the key is.
+	*
+	* Reached only from the generic object case — inside an identifier this package recognizes a
+	* domain is spec data and stays as it is, which is what keeps an overridden column's
+	* `specOverrides.domain` untouched.
+	*/
+	const relocateDomain = (domain) => Object.fromEntries(Object.entries(domain).map(([key, value]) => [key, typeof value === "string" && require_spec.BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value)]));
 	return walk(params);
 }
 //#endregion

package/dist/template/template_relocate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.cjs","names":["remapColumnIdBlockIds","isColumnUniversalKey"],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and\n * what re-sorts a qualifications map whose keys are identifiers.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAOA,YAAAA,sBAAsB,MAAM,YAAY;EAK7E,IAAIC,YAAAA,qBAAqB,IAAI,GAAG,OAAOD,YAAAA,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzCA,YAAAA,sBAAsB,KAAK,YAAY,GACvC,KAAK,KAAK,CACZ,CAAC,CACH;EAGF,OAAO;CACT;CAEA,OAAO,KAAK,MAAM;AACpB"}
+{"version":3,"file":"template_relocate.cjs","names":["remapColumnIdBlockIds","isColumnUniversalKey","BlockScopedDomain"],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isPlainObject } from \"es-toolkit\";\n\nimport { BlockScopedDomain, isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — an axis filter, a domain this package can see belongs to an identifier it\n * knows — from being rewritten along with it, and what re-sorts a qualifications map whose\n * keys are identifiers.\n *\n * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is\n * qualified by the block that produced it. Only the domain keys known to name a block are\n * repointed — matching an entry id is not on its own evidence of a reference.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          key === \"domain\" && isPlainObject(value) ? relocateDomain(value) : walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  /**\n   * The block-naming entries of a domain, repointed at the project being built: an axis a block\n   * produced names that block in its domain, so those are references like any other.\n   *\n   * Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary\n   * non-empty strings — a hand-written template may name an entry `closest`, and a qualifier\n   * reading `closest` is not a reference to it. Matching the map is not on its own enough to\n   * tell one from the other; the key is.\n   *\n   * Reached only from the generic object case — inside an identifier this package recognizes a\n   * domain is spec data and stays as it is, which is what keeps an overridden column's\n   * `specOverrides.domain` untouched.\n   */\n  const relocateDomain = (domain: Record<string, unknown>): Record<string, unknown> =>\n    Object.fromEntries(\n      Object.entries(domain).map(([key, value]) => [\n        key,\n        typeof value === \"string\" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value),\n      ]),\n    );\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAOA,YAAAA,sBAAsB,MAAM,YAAY;EAK7E,IAAIC,YAAAA,qBAAqB,IAAI,GAAG,OAAOD,YAAAA,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzCA,YAAAA,sBAAsB,KAAK,YAAY,GACvC,QAAQ,aAAA,GAAA,WAAA,cAAA,CAA0B,KAAK,IAAI,eAAe,KAAK,IAAI,KAAK,KAAK,CAC/E,CAAC,CACH;EAGF,OAAO;CACT;;;;;;;;;;;;;;CAeA,MAAM,kBAAkB,WACtB,OAAO,YACL,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC3C,KACA,OAAO,UAAU,YAAYE,aAAAA,kBAAkB,IAAI,GAAG,IAAI,aAAa,KAAK,IAAI,KAAK,KAAK,CAC5F,CAAC,CACH;CAEF,OAAO,KAAK,MAAM;AACpB"}

package/dist/template/template_relocate.d.ts

@@ -14,8 +14,13 @@
  *
  * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
  * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
- * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
- * what re-sorts a qualifications map whose keys are identifiers.
+ * like an id — an axis filter, a domain this package can see belongs to an identifier it
+ * knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+ * keys are identifiers.
+ *
+ * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+ * qualified by the block that produced it. Only the domain keys known to name a block are
+ * repointed — matching an entry id is not on its own evidence of a reference.
  *
  * An id the map does not mention is left as it is. That is the ordering rule doing its work:
  * a caller building the map as it creates blocks passes only the entries already created, so
@@ -26,7 +31,6 @@
  * @param params Whatever the block projected, as the document stored it
  * @param blockIds template-local entry id → the block id that entry was given
  */
-declare function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T;
+export declare function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T;
 //#endregion
-export { relocateBlockIds };
 //# sourceMappingURL=template_relocate.d.ts.map

package/dist/template/template_relocate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.d.ts","names":[],"sources":["../../src/template/template_relocate.ts"],"mappings":";;AA6BA;;;;;;;;;;;;;;;AAAwF;;;;;;;;;;;iBAAxE,gBAAA,IAAoB,MAAA,EAAQ,CAAA,EAAG,QAAA,EAAU,WAAA,mBAA8B,CAAA"}
+{"version":3,"file":"template_relocate.d.ts","names":[],"sources":["../../src/template/template_relocate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoCgB,iBAAiB,GAAG,QAAQ,GAAG,UAAU,8BAA8B"}

package/dist/template/template_relocate.js

@@ -1,5 +1,7 @@
+import { BlockScopedDomain } from "../drivers/pframe/spec/spec.js";
 import { isColumnUniversalKey, remapColumnIdBlockIds } from "../drivers/pframe/spec/ids.js";
 import "../drivers/index.js";
+import { isPlainObject } from "es-toolkit";
 //#region src/template/template_relocate.ts
 /**
 * Point every column identifier in a block's params at the blocks of the project being built.
@@ -16,8 +18,13 @@ import "../drivers/index.js";
 *
 * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
 * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
-* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
-* what re-sorts a qualifications map whose keys are identifiers.
+* like an id — an axis filter, a domain this package can see belongs to an identifier it
+* knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+* keys are identifiers.
+*
+* A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+* qualified by the block that produced it. Only the domain keys known to name a block are
+* repointed — matching an entry id is not on its own evidence of a reference.
 *
 * An id the map does not mention is left as it is. That is the ordering rule doing its work:
 * a caller building the map as it creates blocks passes only the entries already created, so
@@ -35,9 +42,23 @@ function relocateBlockIds(params, blockIds) {
 		if (typeof node === "string") return remapColumnIdBlockIds(node, remapBlockId);
 		if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);
 		if (Array.isArray(node)) return node.map(walk);
-		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), key === "domain" && isPlainObject(value) ? relocateDomain(value) : walk(value)]));
 		return node;
 	};
+	/**
+	* The block-naming entries of a domain, repointed at the project being built: an axis a block
+	* produced names that block in its domain, so those are references like any other.
+	*
+	* Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary
+	* non-empty strings — a hand-written template may name an entry `closest`, and a qualifier
+	* reading `closest` is not a reference to it. Matching the map is not on its own enough to
+	* tell one from the other; the key is.
+	*
+	* Reached only from the generic object case — inside an identifier this package recognizes a
+	* domain is spec data and stays as it is, which is what keeps an overridden column's
+	* `specOverrides.domain` untouched.
+	*/
+	const relocateDomain = (domain) => Object.fromEntries(Object.entries(domain).map(([key, value]) => [key, typeof value === "string" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value)]));
 	return walk(params);
 }
 //#endregion

package/dist/template/template_relocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.js","names":[],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and\n * what re-sorts a qualifications map whose keys are identifiers.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAO,sBAAsB,MAAM,YAAY;EAK7E,IAAI,qBAAqB,IAAI,GAAG,OAAO,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzC,sBAAsB,KAAK,YAAY,GACvC,KAAK,KAAK,CACZ,CAAC,CACH;EAGF,OAAO;CACT;CAEA,OAAO,KAAK,MAAM;AACpB"}
+{"version":3,"file":"template_relocate.js","names":[],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isPlainObject } from \"es-toolkit\";\n\nimport { BlockScopedDomain, isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — an axis filter, a domain this package can see belongs to an identifier it\n * knows — from being rewritten along with it, and what re-sorts a qualifications map whose\n * keys are identifiers.\n *\n * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is\n * qualified by the block that produced it. Only the domain keys known to name a block are\n * repointed — matching an entry id is not on its own evidence of a reference.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          key === \"domain\" && isPlainObject(value) ? relocateDomain(value) : walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  /**\n   * The block-naming entries of a domain, repointed at the project being built: an axis a block\n   * produced names that block in its domain, so those are references like any other.\n   *\n   * Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary\n   * non-empty strings — a hand-written template may name an entry `closest`, and a qualifier\n   * reading `closest` is not a reference to it. Matching the map is not on its own enough to\n   * tell one from the other; the key is.\n   *\n   * Reached only from the generic object case — inside an identifier this package recognizes a\n   * domain is spec data and stays as it is, which is what keeps an overridden column's\n   * `specOverrides.domain` untouched.\n   */\n  const relocateDomain = (domain: Record<string, unknown>): Record<string, unknown> =>\n    Object.fromEntries(\n      Object.entries(domain).map(([key, value]) => [\n        key,\n        typeof value === \"string\" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value),\n      ]),\n    );\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAO,sBAAsB,MAAM,YAAY;EAK7E,IAAI,qBAAqB,IAAI,GAAG,OAAO,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzC,sBAAsB,KAAK,YAAY,GACvC,QAAQ,YAAY,cAAc,KAAK,IAAI,eAAe,KAAK,IAAI,KAAK,KAAK,CAC/E,CAAC,CACH;EAGF,OAAO;CACT;;;;;;;;;;;;;;CAeA,MAAM,kBAAkB,WACtB,OAAO,YACL,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC3C,KACA,OAAO,UAAU,YAAY,kBAAkB,IAAI,GAAG,IAAI,aAAa,KAAK,IAAI,KAAK,KAAK,CAC5F,CAAC,CACH;CAEF,OAAO,KAAK,MAAM;AACpB"}

package/dist/utag.d.ts

@@ -1,8 +1,7 @@
 import { AuthorMarker } from "./author_marker.js";
-
 //#region src/utag.d.ts
 /** Value returned for changing states supporting reactive listening for changes */
-interface ValueWithUTag<V> {
+export interface ValueWithUTag<V> {
   /** Value snapshot. */
   readonly value: V;
   /**
@@ -14,9 +13,8 @@ interface ValueWithUTag<V> {
    * */
   readonly uTag: string;
 }
-interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
+export interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
   readonly author?: AuthorMarker;
 }
 //#endregion
-export { ValueWithUTag, ValueWithUTagAndAuthor };
 //# sourceMappingURL=utag.d.ts.map

package/dist/utag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utag.d.ts","names":[],"sources":["../src/utag.ts"],"mappings":";;;;UAGiB,aAAA;EAAA;EAAA,SAEN,KAAA,EAAO,CAAC;EAFW;;;;;;;EAAA,SAWnB,IAAA;AAAA;AAAA,UAGM,sBAAA,YAAkC,aAAA,CAAc,CAAA;EAAA,SACtD,MAAA,GAAS,YAAA;AAAA"}
+{"version":3,"file":"utag.d.ts","names":[],"sources":["../src/utag.ts"],"mappings":";;;iBAGiB,cAAc;;WAEpB,OAAO;;;;;;;;WASP;;iBAGM,uBAAuB,WAAW,cAAc;WACtD,SAAS"}

package/dist/util.d.ts

@@ -1,10 +1,9 @@
 //#region src/util.d.ts
-declare function assertNever(x: never): never;
+export declare function assertNever(x: never): never;
 /**
  * Return unique entries of the array by the provided id
  * For each id, the last entry is kept
  */
-declare function uniqueBy<T>(array: T[], makeId: (entry: T) => string): T[];
+export declare function uniqueBy<T>(array: T[], makeId: (entry: T) => string): T[];
 //#endregion
-export { assertNever, uniqueBy };
 //# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","names":[],"sources":["../src/util.ts"],"mappings":";iBAAgB,WAAA,CAAY,CAAQ;AAApC;;;;AAAA,iBAQgB,QAAA,IAAY,KAAA,EAAO,CAAA,IAAK,MAAA,GAAS,KAAA,EAAO,CAAA,cAAe,CAAA"}
+{"version":3,"file":"util.d.ts","names":[],"sources":["../src/util.ts"],"mappings":";wBAAgB,YAAY;;;;;wBAQZ,SAAS,GAAG,OAAO,KAAK,SAAS,OAAO,eAAe"}

package/dist/value_or_error.d.ts

@@ -1,12 +1,11 @@
 //#region src/value_or_error.d.ts
-type ValueOrError<V, E> = {
+export type ValueOrError<V, E> = {
   ok: true;
   value: V;
 } | {
   ok: false;
   error: E;
 };
-declare function mapValueInVOE<V1, V2, E>(voe: ValueOrError<V1, E>, cb: (value: V1) => V2): ValueOrError<V2, E>;
+export declare function mapValueInVOE<V1, V2, E>(voe: ValueOrError<V1, E>, cb: (value: V1) => V2): ValueOrError<V2, E>;
 //#endregion
-export { ValueOrError, mapValueInVOE };
 //# sourceMappingURL=value_or_error.d.ts.map

package/dist/value_or_error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value_or_error.d.ts","names":[],"sources":["../src/value_or_error.ts"],"mappings":";KAAY,YAAA;EAEN,EAAA;EACA,KAAA,EAAO,CAAA;AAAA;EAGP,EAAA;EACA,KAAA,EAAO,CAAC;AAAA;AAAA,iBAGE,aAAA,YACd,GAAA,EAAK,YAAA,CAAa,EAAA,EAAI,CAAA,GACtB,EAAA,GAAK,KAAA,EAAO,EAAA,KAAO,EAAA,GAClB,YAAA,CAAa,EAAA,EAAI,CAAA"}
+{"version":3,"file":"value_or_error.d.ts","names":[],"sources":["../src/value_or_error.ts"],"mappings":";YAAY,aAAa,GAAG;EAEtB;EACA,OAAO;;EAGP;EACA,OAAO;;wBAGG,cAAc,IAAI,IAAI,GACpC,KAAK,aAAa,IAAI,IACtB,KAAK,OAAO,OAAO,KAClB,aAAa,IAAI"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.48.0",
+  "version": "1.50.0",
   "description": "Platforma SDK Model",
   "files": [
     "./dist/**/*",
@@ -25,11 +25,11 @@
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^4.1.3",
-    "typescript": "~5.9.3",
+    "typescript": "7.0.2",
     "vitest": "^4.1.3",
+    "@milaboratories/build-configs": "2.0.2",
     "@milaboratories/ts-configs": "1.4.0",
-    "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-builder": "1.7.0"
+    "@milaboratories/ts-builder": "1.7.2"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/drivers/pframe/spec/spec.ts

@@ -83,6 +83,37 @@ export const Domain = {
   },
 } as const;
 
+/**
+ * Domain keys whose value is the id of a block, rather than a qualifier of the data.
+ *
+ * Applying a template repoints these at the blocks of the project being built: an axis a block
+ * produced names that block in its domain, so an axis left naming the exported-from project
+ * resolves to nothing. Listing the keys is what makes that safe — a template's entry ids are
+ * arbitrary non-empty strings, so a hand-written template may name an entry `closest`, and a
+ * qualifier that happens to read `closest` must not be mistaken for a reference to it.
+ *
+ * A key absent from here is simply left alone, which is the behaviour from before relocation
+ * reached domains at all. Adding one is therefore safe; omitting one costs only that a template
+ * carrying it applies still pointing at the project it came from.
+ */
+export const BlockScopedDomain: ReadonlySet<string> = new Set<string>([
+  "pl7.app/blockId",
+  "pl7.app/block",
+  "pl7.app/redefined-by",
+  "pl7.app/annotationRunId",
+  "pl7.app/clonotypeAnnotationRunId",
+  "pl7.app/clustering/blockId",
+  "pl7.app/umap/blockId",
+  "pl7.app/peptide/extractionRunId",
+  "pl7.app/repertoire/extractionRunId",
+  "pl7.app/antibodyVariantDesigner/designRunId",
+  "pl7.app/vdj/clonotypingRunId",
+  "pl7.app/vdj/clustering/blockId",
+  "pl7.app/vdj/integration/blockId",
+  "pl7.app/vdj/spatiotemporalAnalysis/blockId",
+  "pl7.app/vdj/libraryId",
+]);
+
 export type Domain = Metadata &
   Partial<{
     [Domain.Alphabet]: "nucleotide" | "aminoacid" | (string & {});
@@ -135,6 +166,7 @@ export const Annotation = {
     IsDenseAxis: "pl7.app/graph/isDenseAxis",
     IsVirtual: "pl7.app/graph/isVirtual",
     Palette: "pl7.app/graph/palette",
+    Shape: "pl7.app/graph/shape",
     Thresholds: "pl7.app/graph/thresholds",
     TreatAbsentValuesAs: "pl7.app/graph/treatAbsentValuesAs",
   },
@@ -196,7 +228,15 @@ export type Annotation = Metadata &
     [Annotation.Graph.Axis.UpperLimit]: StringifiedJson<number>;
     [Annotation.Graph.IsDenseAxis]: StringifiedJson<boolean>;
     [Annotation.Graph.IsVirtual]: StringifiedJson<boolean>;
-    [Annotation.Graph.Palette]: StringifiedJson<{ mapping: Record<string, number>; name: string }>;
+    [Annotation.Graph.Palette]: StringifiedJson<{
+      name: string;
+      mapping?: Record<string, number>;
+      midPoint?: number;
+      min?: number;
+      max?: number;
+      log?: boolean;
+    }>;
+    [Annotation.Graph.Shape]: StringifiedJson<{ mapping: Record<string, string> }>;
     [Annotation.Graph.Thresholds]: StringifiedJson<
       { columnId: { valueType: ValueType; name: string }; value: number }[]
     >;
@@ -262,7 +302,15 @@ export const AnnotationJson: AnnotationJson = {
   [Annotation.Graph.Axis.UpperLimit]: z.number(),
   [Annotation.Graph.Axis.SymmetricRange]: z.boolean(),
   [Annotation.Graph.IsDenseAxis]: z.boolean(),
-  [Annotation.Graph.Palette]: z.object({ mapping: z.record(z.number()), name: z.string() }),
+  [Annotation.Graph.Palette]: z.object({
+    name: z.string(),
+    mapping: z.record(z.coerce.number()).optional(),
+    midPoint: z.number().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    log: z.boolean().optional(),
+  }),
+  [Annotation.Graph.Shape]: z.object({ mapping: z.record(z.string()) }),
   [Annotation.Graph.Thresholds]: z.array(
     z.object({
       columnId: z.object({ valueType: ValueTypeSchema, name: z.string() }),

package/src/flags/block_flags.ts

@@ -13,7 +13,7 @@ export type BlockCodeFeatureFlags = Record<`supports${string}`, boolean | number
   Record<`requires${string}`, boolean | number | undefined>;
 
 /**
- * Known block flags. Flags are set during model compilation, see `BlockModel.create` for more details and for initial values.
+ * Known block flags. Flags are set during model compilation, see `BlockModelV3` feature flags for more details and for initial values.
  */
 export type BlockCodeKnownFeatureFlags = {
   readonly supportsLazyState?: boolean;

package/src/template/template_relocate.test.ts

@@ -109,6 +109,63 @@ describe("relocateBlockIds", () => {
     });
   });
 
+  describe("a domain that qualifies an axis", () => {
+    // An axis a block produced names that block in its domain — `pl7.app/sampleId` is
+    // qualified by the block that defined the samples, a clonotype key by the run that called
+    // the clonotypes. A chart bound to such an axis is bound to a reference.
+    const axis = (runId: string) => ({
+      kind: "axis",
+      name: "pl7.app/vdj/clonotypeKey",
+      type: "String",
+      domain: { "pl7.app/vdj/chain": "IGHeavy", "pl7.app/vdj/clonotypingRunId": runId },
+    });
+
+    test("an entry naming one of this template's entries is repointed", () => {
+      expect(relocateBlockIds({ x: axis("old") }, to("old", "new"))).toEqual({ x: axis("new") });
+    });
+
+    test("an entry that is not an entry id is left alone", () => {
+      // The map is the whole test of what is a reference: nothing reads a value's shape, so an
+      // ordinary qualifier cannot be caught by it.
+      const moved = relocateBlockIds({ x: axis("old") }, to("old", "new")) as {
+        x: { domain: Record<string, string> };
+      };
+
+      expect(moved.x.domain["pl7.app/vdj/chain"]).toBe("IGHeavy");
+    });
+
+    test("a domain naming a block this template does not carry keeps it", () => {
+      // The ordering rule again: an entry created later is not in the map yet, and the applied
+      // block reports itself as missing references rather than pointing at the wrong block.
+      expect(relocateBlockIds({ x: axis("later") }, to("earlier", "new"))).toEqual({
+        x: axis("later"),
+      });
+    });
+
+    test("a qualifier that merely collides with an entry id is NOT a reference", () => {
+      // Entry ids are validated only as non-empty strings, so a hand-written template names its
+      // entries readably. `algo` is a qualifier of the data, and an entry called `closest` does
+      // not make it one: matching the map is not evidence, the key is.
+      const params = { method: { domain: { algo: "closest", chain: "IGHeavy" } } };
+
+      expect(relocateBlockIds(params, to("closest", "new"))).toEqual(params);
+    });
+
+    test("a domain INSIDE a recognized identifier is still spec data, and stays", () => {
+      // The boundary of the rule above. This id is taken apart by the structural remapper,
+      // which never descends to the generic object case, so its overrides are untouched.
+      const id = createColumnOverriddenId({
+        source: leafId("old", "clonotypes"),
+        specOverrides: { domain: { producedBy: "old" } },
+      });
+
+      const moved = relocateBlockIds({ a: id }, to("old", "new")) as { a: string };
+      const key = JSON.parse(moved.a) as { specOverrides: { domain: unknown } };
+
+      expect(key.specOverrides.domain).toEqual({ producedBy: "old" });
+    });
+  });
+
   describe("depth", () => {
     test("three nested forms are repointed at the bottom and rebuilt on the way up", () => {
       const deep = (block: string) =>