@milaboratories/pl-middle-layer 1.58.4 → 1.59.1

package/src/middle_layer/project_list.ts

@@ -1,11 +1,11 @@
 import type { PruningFunction } from "@milaboratories/pl-tree";
 import { SynchronizedTreeState } from "@milaboratories/pl-tree";
-import type { PlClient, ResourceId, ResourceType } from "@milaboratories/pl-client";
-import { resourceTypesEqual } from "@milaboratories/pl-client";
+import type { PlClient, SignedResourceId, ResourceType } from "@milaboratories/pl-client";
+import { resourceIdToString, resourceTypesEqual } from "@milaboratories/pl-client";
 import type { TreeAndComputableU } from "./types";
 import type { WatchableValue } from "@milaboratories/computable";
 import { Computable } from "@milaboratories/computable";
-import type { ProjectListEntry } from "../model/project_model";
+import type { ProjectId, ProjectListEntry } from "../model/project_model";
 import {
   ProjectCreatedTimestamp,
   ProjectLastModifiedTimestamp,
@@ -25,8 +25,8 @@ export const ProjectsListTreePruningFunction: PruningFunction = (resource) => {
 
 export async function createProjectList(
   pl: PlClient,
-  rid: ResourceId,
-  openedProjects: WatchableValue<ResourceId[]>,
+  rid: SignedResourceId,
+  openedProjects: WatchableValue<ProjectId[]>,
   env: MiddleLayerEnvironment,
 ): Promise<TreeAndComputableU<ProjectListEntry[]>> {
   const tree = await SynchronizedTreeState.init(
@@ -44,18 +44,20 @@ export async function createProjectList(
     const oProjects = openedProjects.getValue(ctx);
     if (node === undefined) return undefined;
     const result: ProjectListEntry[] = [];
+
+    // Projects list resource keeps projects assigned to fields. Each field name is project's UUID
     for (const field of node.listDynamicFields()) {
       const prj = node.traverse(field);
       if (prj === undefined) continue;
       const meta = notEmpty(prj.getKeyValueAsJson<ProjectMeta>(ProjectMetaKey));
       const created = notEmpty(prj.getKeyValueAsJson<number>(ProjectCreatedTimestamp));
       const lastModified = notEmpty(prj.getKeyValueAsJson<number>(ProjectLastModifiedTimestamp));
+      const projectId = resourceIdToString(prj.id) as ProjectId;
       result.push({
-        id: field,
-        rid: prj.id,
+        id: projectId,
         created: new Date(created),
         lastModified: new Date(lastModified),
-        opened: oProjects.indexOf(prj.id) >= 0,
+        opened: oProjects.indexOf(projectId) >= 0,
         meta,
       });
     }

package/src/middle_layer/project_overview.ts

@@ -28,12 +28,12 @@ import { extractCodeWithInfo, wrapCallback } from "@platforma-sdk/model";
 import { computableFromCfgOrRF } from "./render";
 import type { NavigationStates } from "./navigation_states";
 import { getBlockPackInfo } from "./util";
-import { resourceIdToString, type ResourceId } from "@milaboratories/pl-client";
+import { resourceIdToString, type SignedResourceId } from "@milaboratories/pl-client";
 import { omitBy, isEqual } from "es-toolkit";
 import { getDebugFlags } from "../debug";
 
 type BlockInfo = {
-  argsRid?: ResourceId;
+  argsRid?: SignedResourceId;
   currentArguments: unknown;
   prod?: ProdState;
 };

package/src/middle_layer/render.test.ts

@@ -60,9 +60,9 @@ export async function awaitBlockDone(prj: Project, blockId: string, timeout: num
 
 test("test JS render enter numbers", async () => {
   await withMl(async (ml) => {
-    const pRid1 = await ml.createProject({ label: "Project 1" }, "id1");
-    await ml.openProject(pRid1);
-    const prj = ml.getOpenedProject(pRid1);
+    const prj1Id = await ml.createProject({ label: "Project 1" });
+    await ml.openProject(prj1Id);
+    const prj = ml.getOpenedProject(prj1Id);
 
     const block1Id = await prj.addBlock("Block 1", {
       type: "from-registry-v1",
@@ -82,9 +82,9 @@ test("test JS render enter numbers", async () => {
 
 test.skip("test JS render options", async () => {
   await withMl(async (ml) => {
-    const pRid1 = await ml.createProject({ label: "Project 1" }, "id1");
-    await ml.openProject(pRid1);
-    const prj = ml.getOpenedProject(pRid1);
+    const prj1Id = await ml.createProject({ label: "Project 1" });
+    await ml.openProject(prj1Id);
+    const prj = ml.getOpenedProject(prj1Id);
 
     const block1Id = await prj.addBlock("Block 1", {
       type: "from-registry-v1",
@@ -118,9 +118,9 @@ test.skip("test JS render options", async () => {
 
 test.skip("test JS render download", async () => {
   await withMl(async (ml) => {
-    const pRid1 = await ml.createProject({ label: "Project 1" }, "id1");
-    await ml.openProject(pRid1);
-    const prj = ml.getOpenedProject(pRid1);
+    const prj1Id = await ml.createProject({ label: "Project 1" });
+    await ml.openProject(prj1Id);
+    const prj = ml.getOpenedProject(prj1Id);
 
     const block1Id = await prj.addBlock("Block 1", {
       type: "from-registry-v1",

package/src/middle_layer/util.ts

@@ -1,6 +1,6 @@
 import type { PlTreeNodeAccessor } from "@milaboratories/pl-tree";
 import { projectFieldName } from "../model/project_model";
-import type { ResourceId } from "@milaboratories/pl-client";
+import type { SignedResourceId } from "@milaboratories/pl-client";
 import { Pl } from "@milaboratories/pl-client";
 import { ifNotUndef } from "../cfg_render/util";
 import type { BlockPackInfo } from "../model/block_pack";
@@ -8,7 +8,7 @@ import type { BlockConfig } from "@platforma-sdk/model";
 import { extractConfig } from "@platforma-sdk/model";
 
 export type BlockPackInfoAndId = {
-  readonly bpResourceId: ResourceId;
+  readonly bpResourceId: SignedResourceId;
   /** To be added to computable keys, to force reload on config change */
   readonly bpId: string;
   /** Full block-pack info */

package/src/model/index.ts

@@ -1,5 +1,5 @@
 export * from "./block_pack_spec";
-export { type ProjectListEntry, type ProjectField } from "./project_model";
+export { type ProjectId, type ProjectListEntry, type ProjectField } from "./project_model";
 
 export {
   ProjectMetaKey,

package/src/model/project_helper.ts

@@ -9,7 +9,7 @@ import {
 import { LRUCache } from "lru-cache";
 import type { QuickJSWASMModule } from "quickjs-emscripten";
 import { executeSingleLambda } from "../js_render";
-import type { ResourceId } from "@milaboratories/pl-client";
+import type { SignedResourceId } from "@milaboratories/pl-client";
 import { ConsoleLoggerAdapter, type MiLogger } from "@milaboratories/ts-helpers";
 import type { StorageDebugView } from "@milaboratories/pl-model-middle-layer";
 
@@ -146,7 +146,7 @@ export class ProjectHelper {
   public getEnrichmentTargets(
     blockConfig: () => BlockConfig,
     args: () => unknown,
-    key?: { argsRid: ResourceId; blockPackRid: ResourceId },
+    key?: { argsRid: SignedResourceId; blockPackRid: SignedResourceId },
   ): PlRef[] | undefined {
     const req = { blockConfig, args };
     if (key === undefined) return this.calculateEnrichmentTargets(req);

package/src/model/project_model.ts

@@ -1,13 +1,16 @@
-import type { ResourceId, ResourceType } from "@milaboratories/pl-client";
+import type { ResourceType } from "@milaboratories/pl-client";
+import type { ProjectId } from "@milaboratories/pl-model-common";
 import type {
   ProjectListEntry as ProjectListEntryFromModel,
   ProjectMeta,
 } from "@milaboratories/pl-model-middle-layer";
 import type { BlockRenderingMode } from "@platforma-sdk/model";
 
-export interface ProjectListEntry extends ProjectListEntryFromModel {
-  /** Project resource ID. */
-  rid: ResourceId;
+export type { ProjectId };
+
+export interface ProjectListEntry extends Omit<ProjectListEntryFromModel, "id"> {
+  /** Unique project identifier in middle layer. Use to operate with given project. */
+  id: ProjectId;
 }
 
 /** Entry representing a single block in block structure */

package/src/model/template_spec.ts

@@ -1,4 +1,4 @@
-import type { ResourceId } from "@milaboratories/pl-client";
+import type { SignedResourceId } from "@milaboratories/pl-client";
 import type { CompiledTemplateV3, TemplateData } from "@milaboratories/pl-model-backend";
 
 export interface TemplateFromRegistry {
@@ -19,7 +19,7 @@ export interface PreparedTemplate {
 
 export interface CachedTemplate {
   readonly type: "cached";
-  readonly resourceId: ResourceId;
+  readonly resourceId: SignedResourceId;
 }
 
 export interface TemplateFromFile {

package/src/mutator/block-pack/block_pack.test.ts

@@ -1,4 +1,9 @@
-import { isNullResourceId, poll, TestHelpers, toGlobalResourceId } from "@milaboratories/pl-client";
+import {
+  isNullSignedResourceId,
+  poll,
+  TestHelpers,
+  toGlobalResourceId,
+} from "@milaboratories/pl-client";
 import { defaultHttpDispatcher } from "@milaboratories/pl-http";
 import { HmacSha256Signer } from "@milaboratories/ts-helpers";
 import path from "node:path";
@@ -50,7 +55,7 @@ test.each([
 
     await poll(pl, async (a) => {
       const r = await a.get(bp).then((r) => r.final()); // this will await final state
-      expect(isNullResourceId(r.data.error)).toBe(true);
+      expect(isNullSignedResourceId(r.data.error)).toBe(true);
     });
   });
 });

package/src/mutator/migration.ts

@@ -1,5 +1,5 @@
 import { UiError } from "@milaboratories/pl-model-common";
-import type { PlClient, PlTransaction, ResourceId } from "@milaboratories/pl-client";
+import type { PlClient, PlTransaction, SignedResourceId } from "@milaboratories/pl-client";
 import type { ProjectField, ProjectStructure } from "../model/project_model";
 import {
   projectFieldName,
@@ -10,7 +10,7 @@ import {
   SchemaVersionV3,
 } from "../model/project_model";
 import { BlockFrontendStateKeyPrefixV1, SchemaVersionV1 } from "../model/project_model_v1";
-import { field, isNullResourceId } from "@milaboratories/pl-client";
+import { field, isNullSignedResourceId } from "@milaboratories/pl-client";
 import { cachedDeserialize } from "@milaboratories/ts-helpers";
 import { allBlocks } from "../model/project_model_util";
 
@@ -20,7 +20,7 @@ import { allBlocks } from "../model/project_model_util";
  * @param pl - The client to use.
  * @param rid - The resource id of the project.
  */
-export async function applyProjectMigrations(pl: PlClient, rid: ResourceId) {
+export async function applyProjectMigrations(pl: PlClient, rid: SignedResourceId) {
   await pl.withWriteTx("ProjectMigration", async (tx) => {
     let schemaVersion = await tx.getKValueJson<string>(rid, SchemaVersionKey);
     if (schemaVersion === SchemaVersionCurrent) return;
@@ -64,7 +64,7 @@ export async function applyProjectMigrations(pl: PlClient, rid: ResourceId) {
  * @param tx - The transaction to use.
  * @param rid - The resource id of the project.
  */
-async function migrateV1ToV2(tx: PlTransaction, rid: ResourceId) {
+async function migrateV1ToV2(tx: PlTransaction, rid: SignedResourceId) {
   const [structure, allKV] = await Promise.all([
     tx.getKValueJson<ProjectStructure>(rid, ProjectStructureKey),
     tx.listKeyValues(rid),
@@ -98,16 +98,16 @@ async function migrateV1ToV2(tx: PlTransaction, rid: ResourceId) {
  * @param tx - The transaction to use.
  * @param rid - The resource id of the project.
  */
-async function migrateV2ToV3(tx: PlTransaction, rid: ResourceId) {
+async function migrateV2ToV3(tx: PlTransaction, rid: SignedResourceId) {
   const [structure, fullResourceState] = await Promise.all([
     tx.getKValueJson<ProjectStructure>(rid, ProjectStructureKey),
     tx.getResourceData(rid, true),
   ]);
 
   // Build a map of field name -> resource id for quick lookup
-  const fieldMap = new Map<string, ResourceId>();
+  const fieldMap = new Map<string, SignedResourceId>();
   for (const f of fullResourceState.fields) {
-    if (!isNullResourceId(f.value)) {
+    if (!isNullSignedResourceId(f.value)) {
       fieldMap.set(f.name, f.value);
     }
   }

package/src/mutator/project.ts

@@ -2,16 +2,17 @@ import type {
   AnyRef,
   AnyResourceRef,
   BasicResourceData,
+  ResourceRef,
   PlTransaction,
   ResourceData,
-  ResourceId,
+  SignedResourceId,
   TxOps,
 } from "@milaboratories/pl-client";
 import {
-  ensureResourceIdNotNull,
+  ensureSignedResourceIdNotNull,
   field,
-  isNotNullResourceId,
-  isNullResourceId,
+  isNotNullSignedResourceId,
+  isNullSignedResourceId,
   isResource,
   isResourceId,
   isResourceRef,
@@ -341,7 +342,7 @@ export class ProjectMutator {
   private readonly blocksWithChangedInputs = new Set<string>();
 
   constructor(
-    public readonly rid: ResourceId,
+    public readonly rid: SignedResourceId,
     private readonly tx: PlTransaction,
     private readonly author: AuthorMarker | undefined,
     private readonly schema: string,
@@ -359,7 +360,7 @@ export class ProjectMutator {
     // Fix inconsistent production fields.
     // All four fields (prodArgs, prodOutput, prodCtx, prodUiCtx) must be present together.
     // prodUiCtx can be missing after project duplication: prodCtx uses a holder wrapper
-    // (always non-null), but prodUiCtx is a raw FieldRef that may still be NullResourceId
+    // (always non-null), but prodUiCtx is a raw FieldRef that may still be NullSignedResourceId
     // at snapshot time and thus not copied.
     this.blockInfos.forEach((blockInfo) => {
       if (
@@ -1716,7 +1717,7 @@ export class ProjectMutator {
   public static async load(
     projectHelper: ProjectHelper,
     tx: PlTransaction,
-    rid: ResourceId,
+    rid: SignedResourceId,
     author?: AuthorMarker,
   ): Promise<ProjectMutator> {
     //
@@ -1749,7 +1750,7 @@ export class ProjectMutator {
         blockInfoStates.set(projectField.blockId, info);
       }
 
-      info.fields[projectField.fieldName] = isNullResourceId(f.value)
+      info.fields[projectField.fieldName] = isNullSignedResourceId(f.value)
         ? { modCount: 0 }
         : { modCount: 0, ref: f.value };
     }
@@ -1811,8 +1812,8 @@ export class ProjectMutator {
     for (const [info, fieldName, state, response] of blockFieldRequests) {
       const result = await response;
       state.value = result.data;
-      if (isNotNullResourceId(result.error)) state.status = "Error";
-      else if (result.resourceReady || isNotNullResourceId(result.originalResourceId))
+      if (isNotNullSignedResourceId(result.error)) state.status = "Error";
+      else if (result.resourceReady || isNotNullSignedResourceId(result.originalResourceId))
         state.status = "Ready";
       else state.status = "NotReady";
 
@@ -1822,7 +1823,7 @@ export class ProjectMutator {
         if (refField === undefined) throw new Error("Block pack ref field is missing");
         blockPackRequests.push([
           info,
-          tx.getResourceData(ensureResourceIdNotNull(refField.value), false),
+          tx.getResourceData(ensureSignedResourceIdNotNull(refField.value), false),
         ]);
       }
     }
@@ -1852,7 +1853,7 @@ export class ProjectMutator {
     );
     let ctxExportTplHolder: AnyResourceRef;
     if (ctxExportTplField !== undefined)
-      ctxExportTplHolder = ensureResourceIdNotNull(ctxExportTplField.value);
+      ctxExportTplHolder = ensureSignedResourceIdNotNull(ctxExportTplField.value);
     else {
       ctxExportTplHolder = Pl.wrapInHolder(tx, loadTemplate(tx, ctxExportTplEnvelope.spec));
       tx.createField(
@@ -1917,7 +1918,7 @@ export interface ProjectState {
 export async function createProject(
   tx: PlTransaction,
   meta: ProjectMeta = InitialBlockMeta,
-): Promise<AnyResourceRef> {
+): Promise<ResourceRef> {
   const prj = tx.createEphemeral(ProjectResourceType);
   tx.lock(prj);
   const ts = String(Date.now());
@@ -1950,9 +1951,9 @@ export async function createProject(
  */
 export async function duplicateProject(
   tx: PlTransaction,
-  sourceRid: ResourceId,
+  sourceRid: SignedResourceId,
   options?: { label?: string },
-): Promise<AnyResourceRef> {
+): Promise<ResourceRef> {
   // Read source resource data (with fields) and all KV pairs
   const sourceDataP = tx.getResourceData(sourceRid, true);
   const sourceKVsP = tx.listKeyValuesString(sourceRid);
@@ -2006,10 +2007,10 @@ export async function duplicateProject(
   // Copy only persistent block fields (FieldsToDuplicate).
   // Transient fields (prodChainCtx, staging*, *Previous) are rebuilt on project open
   // by fixProblemsAndMigrate(). Copying them is both unnecessary and dangerous:
-  // some fields use raw FieldRefs (not holder-wrapped) whose values may be NullResourceId
+  // some fields use raw FieldRefs (not holder-wrapped) whose values may be NullSignedResourceId
   // at snapshot time, leading to partially copied field groups and broken project state.
   for (const f of sourceData.fields) {
-    if (isNullResourceId(f.value)) continue;
+    if (isNullSignedResourceId(f.value)) continue;
     const parsed = parseProjectField(f.name);
     if (parsed !== undefined && !FieldsToDuplicate.has(parsed.fieldName)) continue;
     tx.createField(field(newPrj, f.name), "Dynamic", f.value);
@@ -2021,7 +2022,7 @@ export async function duplicateProject(
 export async function withProject<T>(
   projectHelper: ProjectHelper,
   txOrPl: PlTransaction | PlClient,
-  rid: ResourceId,
+  rid: SignedResourceId,
   cb: (p: ProjectMutator) => T | Promise<T>,
   ops?: Partial<TxOps>,
 ): Promise<T> {
@@ -2031,7 +2032,7 @@ export async function withProject<T>(
 export async function withProjectAuthored<T>(
   projectHelper: ProjectHelper,
   txOrPl: PlTransaction | PlClient,
-  rid: ResourceId,
+  rid: SignedResourceId,
   author: AuthorMarker | undefined,
   cb: (p: ProjectMutator) => T | Promise<T>,
   ops: Partial<TxOps> = {},

package/src/mutator/template/template_cache.test.ts

@@ -1,7 +1,7 @@
 import {
-  ensureResourceIdNotNull,
+  ensureSignedResourceIdNotNull,
   field,
-  isNotNullResourceId,
+  isNotNullSignedResourceId,
   poll,
   TestHelpers,
   toGlobalResourceId,
@@ -103,7 +103,7 @@ describe("dropTemplateCache", () => {
 // ─── loadTemplateCached ──────────────────────────────────────────────────────
 
 describe("loadTemplateCached", () => {
-  test("cache miss then cache hit returns same ResourceId", async () => {
+  test("cache miss then cache hit returns same SignedResourceId", async () => {
     await TestHelpers.withTempRoot(async (pl) => {
       const testCache = await createTestCacheInTx(pl);
 
@@ -151,7 +151,7 @@ describe("loadTemplateCached", () => {
       // Verify the field was set correctly
       await pl.withReadTx("verify", async (tx) => {
         const fd = await tx.getField(field(pl.clientRoot, "test_result"));
-        expect(ensureResourceIdNotNull(fd.value)).toBe(resultId);
+        expect(ensureSignedResourceIdNotNull(fd.value)).toBe(resultId);
       });
     });
   }, 15000);
@@ -265,8 +265,8 @@ describe("template cache produces equivalent resources", () => {
 
       // After dedup, both should resolve to the same canonical resource.
       // Either one points to the other, or both point to a common original.
-      const resolvedCached = isNotNullResourceId(cachedOriginal) ? cachedOriginal : cachedId;
-      const resolvedLegacy = isNotNullResourceId(legacyOriginal) ? legacyOriginal : legacyId;
+      const resolvedCached = isNotNullSignedResourceId(cachedOriginal) ? cachedOriginal : cachedId;
+      const resolvedLegacy = isNotNullSignedResourceId(legacyOriginal) ? legacyOriginal : legacyId;
       expect(resolvedCached).toBe(resolvedLegacy);
     });
   }, 30000);

package/src/mutator/template/template_cache.ts

@@ -3,11 +3,11 @@ import type {
   AnyResourceRef,
   PlClient,
   PlTransaction,
-  ResourceId,
+  SignedResourceId,
   ResourceRef,
 } from "@milaboratories/pl-client";
 import {
-  ensureResourceIdNotNull,
+  ensureSignedResourceIdNotNull,
   field,
   resourceType,
   toGlobalResourceId,
@@ -86,7 +86,7 @@ interface CacheableNode {
   /** SHA-256 content hash (includes all descendant content) */
   hash: string;
   /** Creates this node's resource in a transaction.
-   *  childRefs maps child hash → already-resolved ResourceRef or ResourceId */
+   *  childRefs maps child hash → already-resolved ResourceRef or SignedResourceId */
   create: (tx: PlTransaction, childRefs: ReadonlyMap<string, AnyResourceRef>) => ResourceRef;
   /** Hashes of direct child nodes this node depends on */
   childHashes: string[];
@@ -406,8 +406,8 @@ export function flattenTemplateTree(data: TemplateData | CompiledTemplateV3): Ca
 
 // ─── Cache operations ────────────────────────────────────────────────────────
 
-/** In-memory cache for the TemplateCache ResourceId per PlClient instance. */
-const cacheRidMap = new WeakMap<PlClient, ResourceId>();
+/** In-memory cache for the TemplateCache SignedResourceId per PlClient instance. */
+const cacheRidMap = new WeakMap<PlClient, SignedResourceId>();
 
 /** Clear the in-memory cacheRid entry (call on errors referencing the cache resource). */
 export function invalidateTemplateCacheId(pl: PlClient): void {
@@ -415,7 +415,7 @@ export function invalidateTemplateCacheId(pl: PlClient): void {
 }
 
 /** Find or create the TemplateCache/1 resource on user root. */
-export async function getOrCreateTemplateCache(pl: PlClient): Promise<ResourceId> {
+export async function getOrCreateTemplateCache(pl: PlClient): Promise<SignedResourceId> {
   // Check in-memory cache first (0ms after first call)
   const cached = cacheRidMap.get(pl);
   if (cached !== undefined) return cached;
@@ -423,7 +423,7 @@ export async function getOrCreateTemplateCache(pl: PlClient): Promise<ResourceId
   // Try read-only check
   const existing = await pl.withReadTx("templateCache:check", async (tx) => {
     const fd = await tx.getFieldIfExists(field(pl.clientRoot, TemplateCacheFieldName));
-    return fd ? ensureResourceIdNotNull(fd.value) : undefined;
+    return fd ? ensureSignedResourceIdNotNull(fd.value) : undefined;
   });
   if (existing) {
     cacheRidMap.set(pl, existing);
@@ -433,7 +433,7 @@ export async function getOrCreateTemplateCache(pl: PlClient): Promise<ResourceId
   const result = await pl.withWriteTx("templateCache:init", async (tx) => {
     // Double-check inside write tx (another instance may have created it)
     const fd = await tx.getFieldIfExists(field(pl.clientRoot, TemplateCacheFieldName));
-    if (fd) return ensureResourceIdNotNull(fd.value);
+    if (fd) return ensureSignedResourceIdNotNull(fd.value);
 
     const cache = tx.createStruct(TemplateCacheType);
     tx.createField(field(pl.clientRoot, TemplateCacheFieldName), "Dynamic", cache);
@@ -470,7 +470,7 @@ export async function dropTemplateCache(pl: PlClient): Promise<void> {
  */
 export async function runGc(
   pl: PlClient,
-  cacheRid: ResourceId,
+  cacheRid: SignedResourceId,
   maxEntries: number = GC_MAX_ENTRIES,
 ): Promise<boolean> {
   return await pl.withWriteTx("templateCache:gc", async (tx) => {
@@ -510,9 +510,9 @@ export async function runGc(
 /** Create a batch of cache nodes in the current transaction. */
 function createBatchNodes(
   tx: PlTransaction,
-  cacheRid: ResourceId,
+  cacheRid: SignedResourceId,
   batch: CacheableNode[],
-  resolvedIds: ReadonlyMap<string, ResourceId>,
+  resolvedIds: ReadonlyMap<string, SignedResourceId>,
   newRefs: Map<string, ResourceRef>,
   now: string,
 ): void {
@@ -543,17 +543,17 @@ function createBatchNodes(
  * Phase 2..N (one write tx per batch):
  *   - Create remaining missing nodes in BATCH_SIZE chunks
  *
- * @returns root ResourceId and current access count (for GC decision)
+ * @returns root SignedResourceId and current access count (for GC decision)
  */
 async function materialize(
   pl: PlClient,
-  cacheRid: ResourceId,
+  cacheRid: SignedResourceId,
   rootHash: string,
   nodes: CacheableNode[],
   stat: TemplateCacheStat,
-): Promise<{ rootId: ResourceId; accessCount: number }> {
+): Promise<{ rootId: SignedResourceId; accessCount: number }> {
   const allHashes = nodes.map((n) => n.hash);
-  const resolvedIds = new Map<string, ResourceId>();
+  const resolvedIds = new Map<string, SignedResourceId>();
 
   // Phase 1: probe all + first batch
   const phase1 = await pl.withWriteTx("templateCache:materialize", async (tx) => {
@@ -571,7 +571,7 @@ async function materialize(
     // Happy path: root already cached
     if (exists[rootIdx]) {
       const rootFd = await tx.getField(field(cacheRid, rootHash));
-      const rootRid = ensureResourceIdNotNull(rootFd.value);
+      const rootRid = ensureSignedResourceIdNotNull(rootFd.value);
       tx.setKValue(cacheRid, ACCESS_KEY_PREFIX + rootHash, now);
       tx.setKValue(cacheRid, ACCESS_COUNT_KEY, newCount.toString());
       await tx.commit();
@@ -592,7 +592,10 @@ async function materialize(
         hitIndices.map((i) => tx.getField(field(cacheRid, allHashes[i]))),
       );
       for (let j = 0; j < hitIndices.length; j++) {
-        resolvedIds.set(allHashes[hitIndices[j]], ensureResourceIdNotNull(hitFields[j].value));
+        resolvedIds.set(
+          allHashes[hitIndices[j]],
+          ensureSignedResourceIdNotNull(hitFields[j].value),
+        );
       }
     }
     stat.cacheHits = hitIndices.length;
@@ -659,13 +662,13 @@ async function materialize(
  * Materialize a template tree via the cache.
  * Manages its own transactions internally — do NOT call inside an existing tx.
  *
- * @returns concrete ResourceId of the root template
+ * @returns concrete SignedResourceId of the root template
  */
 export async function loadTemplateCached(
   pl: PlClient,
   spec: TemplateSpecPrepared,
-  options?: { cacheResourceId?: ResourceId },
-): Promise<ResourceId> {
+  options?: { cacheResourceId?: SignedResourceId },
+): Promise<SignedResourceId> {
   const stat = initialStat();
   const t0 = performance.now();
 
@@ -751,7 +754,7 @@ export async function loadTemplateCached(
 export async function cacheBlockPackTemplate(
   pl: PlClient,
   spec: BlockPackSpecPrepared,
-  options?: { cacheResourceId?: ResourceId },
+  options?: { cacheResourceId?: SignedResourceId },
 ): Promise<BlockPackSpecPrepared> {
   if (spec.template.type === "cached") return spec;
 

package/src/mutator/template/template_render.test.ts

@@ -3,13 +3,13 @@ import {
   AnyResourceRef,
   field,
   getField,
-  isNotNullResourceId,
-  isNullResourceId,
+  isNotNullSignedResourceId,
+  isNullSignedResourceId,
   Pl,
   PlClient,
   PlTransaction,
   ResourceData,
-  ResourceId,
+  SignedResourceId,
   TestHelpers,
   valErr,
 } from "@milaboratories/pl-client";
@@ -235,7 +235,7 @@ async function expectResultAndContext(
   ok: boolean;
 }> {
   const fieldData = await tx.getResourceData(root, true);
-  expect(isNullResourceId(fieldData.error)).toBe(true);
+  expect(isNullSignedResourceId(fieldData.error)).toBe(true);
   expectFields(fieldData, ["context", "result"]);
 
   const ctxField = await valErr(tx, getField(fieldData, "context"));
@@ -246,7 +246,7 @@ async function expectResultAndContext(
   const ctxId = ctxField.valueId;
   const resultId = resultField.valueId;
 
-  if (isNullResourceId(ctxId) || isNullResourceId(resultId)) return { ok: false };
+  if (isNullSignedResourceId(ctxId) || isNullSignedResourceId(resultId)) return { ok: false };
 
   const result = await tx.getResourceData(resultId, true);
   const ctx = await tx.getResourceData(ctxId, true);
@@ -260,8 +260,8 @@ async function expectResource(tx: PlTransaction, res: ResourceData, fieldName: s
   const f = getField(res, fieldName);
   const ve = await valErr(tx, f);
   expect(ve.error).toHaveLength(0);
-  expect(isNotNullResourceId(ve.valueId)).toBeTruthy();
-  return await tx.getResourceData(ve.valueId as ResourceId, true);
+  expect(isNotNullSignedResourceId(ve.valueId)).toBeTruthy();
+  return await tx.getResourceData(ve.valueId as SignedResourceId, true);
 }
 
 async function expectData(tx: PlTransaction, result: ResourceData, fieldName: string) {