@milaboratories/pl-middle-layer 1.55.22 → 1.55.24

package/dist/model/args.cjs

@@ -17,37 +17,67 @@ function outputRef(blockId, name, requireEnrichments) {
 function isBlockOutputReference(obj) {
 	return typeof obj === "object" && obj !== null && "__isRef" in obj && obj.__isRef === true && "blockId" in obj && "name" in obj;
 }
+/** Extracts all resource ids referenced by args object. */
+function inferAllReferencedBlocks(args, allowed) {
+	const result = {
+		upstreams: /* @__PURE__ */ new Set(),
+		upstreamsRequiringEnrichments: /* @__PURE__ */ new Set(),
+		missingReferences: false
+	};
+	addAllReferencedBlocks(result, args, allowed);
+	return result;
+}
 function addAllReferencedBlocks(result, node, allowed) {
 	const type = typeof node;
 	switch (type) {
 		case "function":
 		case "bigint":
 		case "number":
-		case "string":
 		case "boolean":
 		case "symbol":
 		case "undefined": return;
+		case "string":
+			unwrapEmbeddedRef(node, (parsed) => addAllReferencedBlocks(result, parsed, allowed));
+			return;
 		case "object":
 			if (node === null) return;
-			if (isBlockOutputReference(node)) if (allowed === void 0 || allowed.has(node.blockId)) {
-				result.upstreams.add(node.blockId);
-				if (node.requireEnrichments) result.upstreamsRequiringEnrichments.add(node.blockId);
-			} else result.missingReferences = true;
+			if (isBlockOutputReference(node)) recordRef(result, node.blockId, node.requireEnrichments === true, allowed);
 			else if (Array.isArray(node)) for (const child of node) addAllReferencedBlocks(result, child, allowed);
 			else for (const [, child] of Object.entries(node)) addAllReferencedBlocks(result, child, allowed);
 			return;
 		default: (0, _milaboratories_ts_helpers.assertNever)(type);
 	}
 }
-/** Extracts all resource ids referenced by args object. */
-function inferAllReferencedBlocks(args, allowed) {
-	const result = {
-		upstreams: /* @__PURE__ */ new Set(),
-		upstreamsRequiringEnrichments: /* @__PURE__ */ new Set(),
-		missingReferences: false
-	};
-	addAllReferencedBlocks(result, args, allowed);
-	return result;
+/**
+* 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, onParsed) {
+	const c0 = s.charCodeAt(0);
+	if (c0 !== 123 && c0 !== 34) return;
+	const m = EMBEDDED_REF_RE.exec(s);
+	if (m === null) return;
+	if (m.groups.pre.length !== m.groups.suf.length) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(s);
+	} catch {
+		return;
+	}
+	if (parsed !== s) onParsed(parsed);
+}
+function recordRef(result, blockId, requireEnrichments, allowed) {
+	if (allowed === void 0 || allowed.has(blockId)) {
+		result.upstreams.add(blockId);
+		if (requireEnrichments) result.upstreamsRequiringEnrichments.add(blockId);
+	} else result.missingReferences = true;
 }
 //#endregion
 exports.inferAllReferencedBlocks = inferAllReferencedBlocks;

package/dist/model/args.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"args.cjs","names":[],"sources":["../../src/model/args.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/ts-helpers\";\nimport type { PlRef } from \"@platforma-sdk/model\";\n\nexport function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {\n  if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };\n  else return { __isRef: true, blockId, name };\n}\n\nexport function isBlockOutputReference(obj: unknown): obj is PlRef {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"__isRef\" in obj &&\n    obj.__isRef === true &&\n    \"blockId\" in obj &&\n    \"name\" in obj\n  );\n}\n\nfunction addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?: Set<string>) {\n  const type = typeof node;\n  switch (type) {\n    case \"function\":\n    case \"bigint\":\n    case \"number\":\n    case \"string\":\n    case \"boolean\":\n    case \"symbol\":\n    case \"undefined\":\n      return;\n\n    case \"object\":\n      if (node === null) return;\n\n      if (isBlockOutputReference(node)) {\n        if (allowed === undefined || allowed.has(node.blockId)) {\n          result.upstreams.add(node.blockId);\n          if (node.requireEnrichments) result.upstreamsRequiringEnrichments.add(node.blockId);\n        } else result.missingReferences = true;\n      } else if (Array.isArray(node)) {\n        for (const child of node) addAllReferencedBlocks(result, child, allowed);\n      } else {\n        for (const [, child] of Object.entries(node as object))\n          addAllReferencedBlocks(result, child, allowed);\n      }\n\n      return;\n\n    default:\n      assertNever(type);\n  }\n}\n\nexport interface BlockUpstreams {\n  /** All direct block dependencies */\n  upstreams: Set<string>;\n  /** Direct block dependencies which enrichments are also required by current block */\n  upstreamsRequiringEnrichments: Set<string>;\n  /** True if not-allowed references was encountered */\n  missingReferences: boolean;\n}\n\n/** Extracts all resource ids referenced by args object. */\nexport function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {\n  const result = {\n    upstreams: new Set<string>(),\n    upstreamsRequiringEnrichments: new Set<string>(),\n    missingReferences: false,\n  };\n  addAllReferencedBlocks(result, args, allowed);\n  return result;\n}\n"],"mappings":";;;AAGA,SAAgB,UAAU,SAAiB,MAAc,oBAAqC;AAC5F,KAAI,mBAAoB,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;EAAoB;KAC9E,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;;AAG9C,SAAgB,uBAAuB,KAA4B;AACjE,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,aAAa,OACb,IAAI,YAAY,QAChB,aAAa,OACb,UAAU;;AAId,SAAS,uBAAuB,QAAwB,MAAe,SAAuB;CAC5F,MAAM,OAAO,OAAO;AACpB,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,YACH;EAEF,KAAK;AACH,OAAI,SAAS,KAAM;AAEnB,OAAI,uBAAuB,KAAK,CAC9B,KAAI,YAAY,KAAA,KAAa,QAAQ,IAAI,KAAK,QAAQ,EAAE;AACtD,WAAO,UAAU,IAAI,KAAK,QAAQ;AAClC,QAAI,KAAK,mBAAoB,QAAO,8BAA8B,IAAI,KAAK,QAAQ;SAC9E,QAAO,oBAAoB;YACzB,MAAM,QAAQ,KAAK,CAC5B,MAAK,MAAM,SAAS,KAAM,wBAAuB,QAAQ,OAAO,QAAQ;OAExE,MAAK,MAAM,GAAG,UAAU,OAAO,QAAQ,KAAe,CACpD,wBAAuB,QAAQ,OAAO,QAAQ;AAGlD;EAEF,QACE,EAAA,GAAA,2BAAA,aAAY,KAAK;;;;AAcvB,SAAgB,yBAAyB,MAAe,SAAuC;CAC7F,MAAM,SAAS;EACb,2BAAW,IAAI,KAAa;EAC5B,+CAA+B,IAAI,KAAa;EAChD,mBAAmB;EACpB;AACD,wBAAuB,QAAQ,MAAM,QAAQ;AAC7C,QAAO"}
+{"version":3,"file":"args.cjs","names":[],"sources":["../../src/model/args.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/ts-helpers\";\nimport type { PlRef } from \"@platforma-sdk/model\";\n\nexport function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {\n  if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };\n  else return { __isRef: true, blockId, name };\n}\n\nexport function isBlockOutputReference(obj: unknown): obj is PlRef {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"__isRef\" in obj &&\n    obj.__isRef === true &&\n    \"blockId\" in obj &&\n    \"name\" in obj\n  );\n}\n\nexport interface BlockUpstreams {\n  /** All direct block dependencies */\n  upstreams: Set<string>;\n  /** Direct block dependencies which enrichments are also required by current block */\n  upstreamsRequiringEnrichments: Set<string>;\n  /** True if not-allowed references was encountered */\n  missingReferences: boolean;\n}\n\n/** Extracts all resource ids referenced by args object. */\nexport function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {\n  const result = {\n    upstreams: new Set<string>(),\n    upstreamsRequiringEnrichments: new Set<string>(),\n    missingReferences: false,\n  };\n  addAllReferencedBlocks(result, args, allowed);\n  return result;\n}\n\nfunction addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?: Set<string>) {\n  const type = typeof node;\n  switch (type) {\n    case \"function\":\n    case \"bigint\":\n    case \"number\":\n    case \"boolean\":\n    case \"symbol\":\n    case \"undefined\":\n      return;\n    case \"string\": {\n      unwrapEmbeddedRef(node as string, (parsed) =>\n        addAllReferencedBlocks(result, parsed, allowed),\n      );\n      return;\n    }\n    case \"object\": {\n      if (node === null) return;\n      if (isBlockOutputReference(node)) {\n        recordRef(result, node.blockId, node.requireEnrichments === true, allowed);\n      } else if (Array.isArray(node)) {\n        for (const child of node) addAllReferencedBlocks(result, child, allowed);\n      } else {\n        for (const [, child] of Object.entries(node as object))\n          addAllReferencedBlocks(result, child, allowed);\n      }\n\n      return;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\n/**\n * Detect a PlRef carried inside a string and hand the decoded value to `onParsed`.\n *\n * A PlRef-as-string is canonical `{...}` optionally wrapped by N `JSON.stringify`\n * passes. Each pass adds a symmetric prefix/suffix made only of `\"` and `\\`\n * chars (the escape padding) of equal length. The regex below is the strict\n * shape gate — non-ref strings fail at the very first character, so we never\n * scan their body. One pass is peeled per call; deeper nesting is unwrapped\n * via recursion in the caller.\n */\nconst EMBEDDED_REF_RE = /^(?<pre>[\\\\\"]*)\\{[\\s\\S]*?__isRef[\\s\\S]*\\}(?<suf>[\\\\\"]*)$/;\n\nfunction unwrapEmbeddedRef(s: string, onParsed: (value: unknown) => void) {\n  const c0 = s.charCodeAt(0);\n  if (c0 !== 0x7b /* { */ && c0 !== 0x22 /* \" */) return;\n  const m = EMBEDDED_REF_RE.exec(s);\n  if (m === null) return;\n  if (m.groups!.pre.length !== m.groups!.suf.length) return;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(s);\n  } catch {\n    return;\n  }\n  if (parsed !== s) onParsed(parsed);\n}\n\nfunction recordRef(\n  result: BlockUpstreams,\n  blockId: string,\n  requireEnrichments: boolean,\n  allowed?: Set<string>,\n) {\n  if (allowed === undefined || allowed.has(blockId)) {\n    result.upstreams.add(blockId);\n    if (requireEnrichments) result.upstreamsRequiringEnrichments.add(blockId);\n  } else result.missingReferences = true;\n}\n"],"mappings":";;;AAGA,SAAgB,UAAU,SAAiB,MAAc,oBAAqC;AAC5F,KAAI,mBAAoB,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;EAAoB;KAC9E,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;;AAG9C,SAAgB,uBAAuB,KAA4B;AACjE,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,aAAa,OACb,IAAI,YAAY,QAChB,aAAa,OACb,UAAU;;;AAcd,SAAgB,yBAAyB,MAAe,SAAuC;CAC7F,MAAM,SAAS;EACb,2BAAW,IAAI,KAAa;EAC5B,+CAA+B,IAAI,KAAa;EAChD,mBAAmB;EACpB;AACD,wBAAuB,QAAQ,MAAM,QAAQ;AAC7C,QAAO;;AAGT,SAAS,uBAAuB,QAAwB,MAAe,SAAuB;CAC5F,MAAM,OAAO,OAAO;AACpB,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,YACH;EACF,KAAK;AACH,qBAAkB,OAAiB,WACjC,uBAAuB,QAAQ,QAAQ,QAAQ,CAChD;AACD;EAEF,KAAK;AACH,OAAI,SAAS,KAAM;AACnB,OAAI,uBAAuB,KAAK,CAC9B,WAAU,QAAQ,KAAK,SAAS,KAAK,uBAAuB,MAAM,QAAQ;YACjE,MAAM,QAAQ,KAAK,CAC5B,MAAK,MAAM,SAAS,KAAM,wBAAuB,QAAQ,OAAO,QAAQ;OAExE,MAAK,MAAM,GAAG,UAAU,OAAO,QAAQ,KAAe,CACpD,wBAAuB,QAAQ,OAAO,QAAQ;AAGlD;EAEF,QACE,EAAA,GAAA,2BAAA,aAAY,KAAK;;;;;;;;;;;;;AAcvB,MAAM,kBAAkB;AAExB,SAAS,kBAAkB,GAAW,UAAoC;CACxE,MAAM,KAAK,EAAE,WAAW,EAAE;AAC1B,KAAI,OAAO,OAAgB,OAAO,GAAc;CAChD,MAAM,IAAI,gBAAgB,KAAK,EAAE;AACjC,KAAI,MAAM,KAAM;AAChB,KAAI,EAAE,OAAQ,IAAI,WAAW,EAAE,OAAQ,IAAI,OAAQ;CACnD,IAAI;AACJ,KAAI;AACF,WAAS,KAAK,MAAM,EAAE;SAChB;AACN;;AAEF,KAAI,WAAW,EAAG,UAAS,OAAO;;AAGpC,SAAS,UACP,QACA,SACA,oBACA,SACA;AACA,KAAI,YAAY,KAAA,KAAa,QAAQ,IAAI,QAAQ,EAAE;AACjD,SAAO,UAAU,IAAI,QAAQ;AAC7B,MAAI,mBAAoB,QAAO,8BAA8B,IAAI,QAAQ;OACpE,QAAO,oBAAoB"}

package/dist/model/args.js

@@ -16,37 +16,67 @@ function outputRef(blockId, name, requireEnrichments) {
 function isBlockOutputReference(obj) {
 	return typeof obj === "object" && obj !== null && "__isRef" in obj && obj.__isRef === true && "blockId" in obj && "name" in obj;
 }
+/** Extracts all resource ids referenced by args object. */
+function inferAllReferencedBlocks(args, allowed) {
+	const result = {
+		upstreams: /* @__PURE__ */ new Set(),
+		upstreamsRequiringEnrichments: /* @__PURE__ */ new Set(),
+		missingReferences: false
+	};
+	addAllReferencedBlocks(result, args, allowed);
+	return result;
+}
 function addAllReferencedBlocks(result, node, allowed) {
 	const type = typeof node;
 	switch (type) {
 		case "function":
 		case "bigint":
 		case "number":
-		case "string":
 		case "boolean":
 		case "symbol":
 		case "undefined": return;
+		case "string":
+			unwrapEmbeddedRef(node, (parsed) => addAllReferencedBlocks(result, parsed, allowed));
+			return;
 		case "object":
 			if (node === null) return;
-			if (isBlockOutputReference(node)) if (allowed === void 0 || allowed.has(node.blockId)) {
-				result.upstreams.add(node.blockId);
-				if (node.requireEnrichments) result.upstreamsRequiringEnrichments.add(node.blockId);
-			} else result.missingReferences = true;
+			if (isBlockOutputReference(node)) recordRef(result, node.blockId, node.requireEnrichments === true, allowed);
 			else if (Array.isArray(node)) for (const child of node) addAllReferencedBlocks(result, child, allowed);
 			else for (const [, child] of Object.entries(node)) addAllReferencedBlocks(result, child, allowed);
 			return;
 		default: assertNever(type);
 	}
 }
-/** Extracts all resource ids referenced by args object. */
-function inferAllReferencedBlocks(args, allowed) {
-	const result = {
-		upstreams: /* @__PURE__ */ new Set(),
-		upstreamsRequiringEnrichments: /* @__PURE__ */ new Set(),
-		missingReferences: false
-	};
-	addAllReferencedBlocks(result, args, allowed);
-	return result;
+/**
+* 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, onParsed) {
+	const c0 = s.charCodeAt(0);
+	if (c0 !== 123 && c0 !== 34) return;
+	const m = EMBEDDED_REF_RE.exec(s);
+	if (m === null) return;
+	if (m.groups.pre.length !== m.groups.suf.length) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(s);
+	} catch {
+		return;
+	}
+	if (parsed !== s) onParsed(parsed);
+}
+function recordRef(result, blockId, requireEnrichments, allowed) {
+	if (allowed === void 0 || allowed.has(blockId)) {
+		result.upstreams.add(blockId);
+		if (requireEnrichments) result.upstreamsRequiringEnrichments.add(blockId);
+	} else result.missingReferences = true;
 }
 //#endregion
 export { inferAllReferencedBlocks, outputRef };

package/dist/model/args.js.map

@@ -1 +1 @@
-{"version":3,"file":"args.js","names":[],"sources":["../../src/model/args.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/ts-helpers\";\nimport type { PlRef } from \"@platforma-sdk/model\";\n\nexport function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {\n  if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };\n  else return { __isRef: true, blockId, name };\n}\n\nexport function isBlockOutputReference(obj: unknown): obj is PlRef {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"__isRef\" in obj &&\n    obj.__isRef === true &&\n    \"blockId\" in obj &&\n    \"name\" in obj\n  );\n}\n\nfunction addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?: Set<string>) {\n  const type = typeof node;\n  switch (type) {\n    case \"function\":\n    case \"bigint\":\n    case \"number\":\n    case \"string\":\n    case \"boolean\":\n    case \"symbol\":\n    case \"undefined\":\n      return;\n\n    case \"object\":\n      if (node === null) return;\n\n      if (isBlockOutputReference(node)) {\n        if (allowed === undefined || allowed.has(node.blockId)) {\n          result.upstreams.add(node.blockId);\n          if (node.requireEnrichments) result.upstreamsRequiringEnrichments.add(node.blockId);\n        } else result.missingReferences = true;\n      } else if (Array.isArray(node)) {\n        for (const child of node) addAllReferencedBlocks(result, child, allowed);\n      } else {\n        for (const [, child] of Object.entries(node as object))\n          addAllReferencedBlocks(result, child, allowed);\n      }\n\n      return;\n\n    default:\n      assertNever(type);\n  }\n}\n\nexport interface BlockUpstreams {\n  /** All direct block dependencies */\n  upstreams: Set<string>;\n  /** Direct block dependencies which enrichments are also required by current block */\n  upstreamsRequiringEnrichments: Set<string>;\n  /** True if not-allowed references was encountered */\n  missingReferences: boolean;\n}\n\n/** Extracts all resource ids referenced by args object. */\nexport function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {\n  const result = {\n    upstreams: new Set<string>(),\n    upstreamsRequiringEnrichments: new Set<string>(),\n    missingReferences: false,\n  };\n  addAllReferencedBlocks(result, args, allowed);\n  return result;\n}\n"],"mappings":";;AAGA,SAAgB,UAAU,SAAiB,MAAc,oBAAqC;AAC5F,KAAI,mBAAoB,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;EAAoB;KAC9E,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;;AAG9C,SAAgB,uBAAuB,KAA4B;AACjE,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,aAAa,OACb,IAAI,YAAY,QAChB,aAAa,OACb,UAAU;;AAId,SAAS,uBAAuB,QAAwB,MAAe,SAAuB;CAC5F,MAAM,OAAO,OAAO;AACpB,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,YACH;EAEF,KAAK;AACH,OAAI,SAAS,KAAM;AAEnB,OAAI,uBAAuB,KAAK,CAC9B,KAAI,YAAY,KAAA,KAAa,QAAQ,IAAI,KAAK,QAAQ,EAAE;AACtD,WAAO,UAAU,IAAI,KAAK,QAAQ;AAClC,QAAI,KAAK,mBAAoB,QAAO,8BAA8B,IAAI,KAAK,QAAQ;SAC9E,QAAO,oBAAoB;YACzB,MAAM,QAAQ,KAAK,CAC5B,MAAK,MAAM,SAAS,KAAM,wBAAuB,QAAQ,OAAO,QAAQ;OAExE,MAAK,MAAM,GAAG,UAAU,OAAO,QAAQ,KAAe,CACpD,wBAAuB,QAAQ,OAAO,QAAQ;AAGlD;EAEF,QACE,aAAY,KAAK;;;;AAcvB,SAAgB,yBAAyB,MAAe,SAAuC;CAC7F,MAAM,SAAS;EACb,2BAAW,IAAI,KAAa;EAC5B,+CAA+B,IAAI,KAAa;EAChD,mBAAmB;EACpB;AACD,wBAAuB,QAAQ,MAAM,QAAQ;AAC7C,QAAO"}
+{"version":3,"file":"args.js","names":[],"sources":["../../src/model/args.ts"],"sourcesContent":["import { assertNever } from \"@milaboratories/ts-helpers\";\nimport type { PlRef } from \"@platforma-sdk/model\";\n\nexport function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {\n  if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };\n  else return { __isRef: true, blockId, name };\n}\n\nexport function isBlockOutputReference(obj: unknown): obj is PlRef {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"__isRef\" in obj &&\n    obj.__isRef === true &&\n    \"blockId\" in obj &&\n    \"name\" in obj\n  );\n}\n\nexport interface BlockUpstreams {\n  /** All direct block dependencies */\n  upstreams: Set<string>;\n  /** Direct block dependencies which enrichments are also required by current block */\n  upstreamsRequiringEnrichments: Set<string>;\n  /** True if not-allowed references was encountered */\n  missingReferences: boolean;\n}\n\n/** Extracts all resource ids referenced by args object. */\nexport function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {\n  const result = {\n    upstreams: new Set<string>(),\n    upstreamsRequiringEnrichments: new Set<string>(),\n    missingReferences: false,\n  };\n  addAllReferencedBlocks(result, args, allowed);\n  return result;\n}\n\nfunction addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?: Set<string>) {\n  const type = typeof node;\n  switch (type) {\n    case \"function\":\n    case \"bigint\":\n    case \"number\":\n    case \"boolean\":\n    case \"symbol\":\n    case \"undefined\":\n      return;\n    case \"string\": {\n      unwrapEmbeddedRef(node as string, (parsed) =>\n        addAllReferencedBlocks(result, parsed, allowed),\n      );\n      return;\n    }\n    case \"object\": {\n      if (node === null) return;\n      if (isBlockOutputReference(node)) {\n        recordRef(result, node.blockId, node.requireEnrichments === true, allowed);\n      } else if (Array.isArray(node)) {\n        for (const child of node) addAllReferencedBlocks(result, child, allowed);\n      } else {\n        for (const [, child] of Object.entries(node as object))\n          addAllReferencedBlocks(result, child, allowed);\n      }\n\n      return;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\n/**\n * Detect a PlRef carried inside a string and hand the decoded value to `onParsed`.\n *\n * A PlRef-as-string is canonical `{...}` optionally wrapped by N `JSON.stringify`\n * passes. Each pass adds a symmetric prefix/suffix made only of `\"` and `\\`\n * chars (the escape padding) of equal length. The regex below is the strict\n * shape gate — non-ref strings fail at the very first character, so we never\n * scan their body. One pass is peeled per call; deeper nesting is unwrapped\n * via recursion in the caller.\n */\nconst EMBEDDED_REF_RE = /^(?<pre>[\\\\\"]*)\\{[\\s\\S]*?__isRef[\\s\\S]*\\}(?<suf>[\\\\\"]*)$/;\n\nfunction unwrapEmbeddedRef(s: string, onParsed: (value: unknown) => void) {\n  const c0 = s.charCodeAt(0);\n  if (c0 !== 0x7b /* { */ && c0 !== 0x22 /* \" */) return;\n  const m = EMBEDDED_REF_RE.exec(s);\n  if (m === null) return;\n  if (m.groups!.pre.length !== m.groups!.suf.length) return;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(s);\n  } catch {\n    return;\n  }\n  if (parsed !== s) onParsed(parsed);\n}\n\nfunction recordRef(\n  result: BlockUpstreams,\n  blockId: string,\n  requireEnrichments: boolean,\n  allowed?: Set<string>,\n) {\n  if (allowed === undefined || allowed.has(blockId)) {\n    result.upstreams.add(blockId);\n    if (requireEnrichments) result.upstreamsRequiringEnrichments.add(blockId);\n  } else result.missingReferences = true;\n}\n"],"mappings":";;AAGA,SAAgB,UAAU,SAAiB,MAAc,oBAAqC;AAC5F,KAAI,mBAAoB,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;EAAoB;KAC9E,QAAO;EAAE,SAAS;EAAM;EAAS;EAAM;;AAG9C,SAAgB,uBAAuB,KAA4B;AACjE,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,aAAa,OACb,IAAI,YAAY,QAChB,aAAa,OACb,UAAU;;;AAcd,SAAgB,yBAAyB,MAAe,SAAuC;CAC7F,MAAM,SAAS;EACb,2BAAW,IAAI,KAAa;EAC5B,+CAA+B,IAAI,KAAa;EAChD,mBAAmB;EACpB;AACD,wBAAuB,QAAQ,MAAM,QAAQ;AAC7C,QAAO;;AAGT,SAAS,uBAAuB,QAAwB,MAAe,SAAuB;CAC5F,MAAM,OAAO,OAAO;AACpB,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,YACH;EACF,KAAK;AACH,qBAAkB,OAAiB,WACjC,uBAAuB,QAAQ,QAAQ,QAAQ,CAChD;AACD;EAEF,KAAK;AACH,OAAI,SAAS,KAAM;AACnB,OAAI,uBAAuB,KAAK,CAC9B,WAAU,QAAQ,KAAK,SAAS,KAAK,uBAAuB,MAAM,QAAQ;YACjE,MAAM,QAAQ,KAAK,CAC5B,MAAK,MAAM,SAAS,KAAM,wBAAuB,QAAQ,OAAO,QAAQ;OAExE,MAAK,MAAM,GAAG,UAAU,OAAO,QAAQ,KAAe,CACpD,wBAAuB,QAAQ,OAAO,QAAQ;AAGlD;EAEF,QACE,aAAY,KAAK;;;;;;;;;;;;;AAcvB,MAAM,kBAAkB;AAExB,SAAS,kBAAkB,GAAW,UAAoC;CACxE,MAAM,KAAK,EAAE,WAAW,EAAE;AAC1B,KAAI,OAAO,OAAgB,OAAO,GAAc;CAChD,MAAM,IAAI,gBAAgB,KAAK,EAAE;AACjC,KAAI,MAAM,KAAM;AAChB,KAAI,EAAE,OAAQ,IAAI,WAAW,EAAE,OAAQ,IAAI,OAAQ;CACnD,IAAI;AACJ,KAAI;AACF,WAAS,KAAK,MAAM,EAAE;SAChB;AACN;;AAEF,KAAI,WAAW,EAAG,UAAS,OAAO;;AAGpC,SAAS,UACP,QACA,SACA,oBACA,SACA;AACA,KAAI,YAAY,KAAA,KAAa,QAAQ,IAAI,QAAQ,EAAE;AACjD,SAAO,UAAU,IAAI,QAAQ;AAC7B,MAAI,mBAAoB,QAAO,8BAA8B,IAAI,QAAQ;OACpE,QAAO,oBAAoB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-middle-layer",
-  "version": "1.55.22",
+  "version": "1.55.24",
   "description": "Pl Middle Layer",
   "keywords": [],
   "license": "UNLICENSED",
@@ -30,24 +30,24 @@
     "utility-types": "^3.11.0",
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
-    "@milaboratories/pf-driver": "1.4.0",
     "@milaboratories/computable": "2.9.2",
-    "@milaboratories/pl-client": "3.1.8",
-    "@milaboratories/pf-spec-driver": "1.3.4",
     "@milaboratories/helpers": "1.14.1",
-    "@milaboratories/pl-drivers": "1.12.19",
-    "@milaboratories/pl-errors": "1.3.7",
+    "@milaboratories/pf-spec-driver": "1.3.4",
     "@milaboratories/pl-deployments": "2.17.7",
+    "@milaboratories/pl-errors": "1.3.8",
+    "@milaboratories/pf-driver": "1.4.0",
+    "@milaboratories/pl-client": "3.2.0",
+    "@milaboratories/pl-drivers": "1.12.20",
+    "@milaboratories/pl-model-backend": "1.2.16",
     "@milaboratories/pl-http": "1.2.4",
     "@milaboratories/pl-model-common": "1.36.0",
-    "@milaboratories/pl-model-middle-layer": "1.18.5",
-    "@milaboratories/pl-model-backend": "1.2.15",
     "@milaboratories/resolve-helper": "1.1.3",
+    "@milaboratories/pl-tree": "1.9.18",
+    "@milaboratories/pl-model-middle-layer": "1.18.5",
     "@milaboratories/ts-helpers": "1.8.1",
-    "@platforma-sdk/block-tools": "2.7.14",
     "@platforma-sdk/model": "1.68.0",
-    "@platforma-sdk/workflow-tengo": "5.15.0",
-    "@milaboratories/pl-tree": "1.9.17"
+    "@platforma-sdk/block-tools": "2.7.14",
+    "@platforma-sdk/workflow-tengo": "5.15.1"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",

package/src/model/args.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import canonicalize from "canonicalize";
 import { inferAllReferencedBlocks, outputRef } from "./args";
 
 describe("inferAllReferencedBlocks", () => {
@@ -29,4 +30,106 @@ describe("inferAllReferencedBlocks", () => {
     expect(result.upstreams).toContain("block1");
     expect(result.upstreams.size).toBe(1);
   });
+
+  it("extracts PlRef embedded as canonicalized JSON string (global-form PObjectId)", () => {
+    const id = canonicalize(outputRef("blockA", "exportName"))!;
+
+    const result = inferAllReferencedBlocks({ columnId: id });
+
+    expect(result.upstreams).toContain("blockA");
+    expect(result.upstreams.size).toBe(1);
+    expect(result.upstreamsRequiringEnrichments.size).toBe(0);
+    expect(result.missingReferences).toBe(false);
+  });
+
+  it("propagates requireEnrichments from canonicalized PlRef string", () => {
+    const id = canonicalize(outputRef("blockA", "exportName", true))!;
+
+    const result = inferAllReferencedBlocks(id);
+
+    expect(result.upstreams).toContain("blockA");
+    expect(result.upstreamsRequiringEnrichments).toContain("blockA");
+  });
+
+  it("finds multiple PlRef strings inside an args object", () => {
+    const a = canonicalize(outputRef("blockA", "n1"))!;
+    const b = canonicalize(outputRef("blockB", "n2", true))!;
+
+    const result = inferAllReferencedBlocks({ first: a, second: b });
+
+    expect(result.upstreams).toEqual(new Set(["blockA", "blockB"]));
+    expect(result.upstreamsRequiringEnrichments).toEqual(new Set(["blockB"]));
+  });
+
+  it("respects allowed set for embedded refs", () => {
+    const id = canonicalize(outputRef("blockX", "n"))!;
+
+    const result = inferAllReferencedBlocks({ id }, new Set(["blockY"]));
+
+    expect(result.upstreams.size).toBe(0);
+    expect(result.missingReferences).toBe(true);
+  });
+
+  it("decodes JSON escapes inside blockId", () => {
+    const id = canonicalize(outputRef('weird"id\\with\nescapes', "n"))!;
+
+    const result = inferAllReferencedBlocks({ id });
+
+    expect(result.upstreams).toContain('weird"id\\with\nescapes');
+  });
+
+  it("ignores strings without __isRef marker", () => {
+    const result = inferAllReferencedBlocks({
+      a: "plain text",
+      b: '{"some":"json","without":"ref"}',
+    });
+
+    expect(result.upstreams.size).toBe(0);
+    expect(result.missingReferences).toBe(false);
+  });
+
+  it("detects PlRef string regardless of JSON.stringify nesting depth (depth 0..10)", () => {
+    const id = canonicalize(outputRef("blockA", "n", true))!;
+
+    for (let depth = 0; depth <= 10; depth++) {
+      let value: string = id;
+      for (let i = 0; i < depth; i++) value = JSON.stringify(value);
+
+      const result = inferAllReferencedBlocks({ raw: value });
+
+      expect(result.upstreams, `depth=${depth}`).toContain("blockA");
+      expect(result.upstreamsRequiringEnrichments, `depth=${depth}`).toContain("blockA");
+    }
+  });
+
+  it("detects PlRef when the entire args container is stringified multiple times", () => {
+    const ref = outputRef("blockZ", "n");
+    const container: { col: unknown } = { col: ref };
+
+    let value: unknown = container;
+    for (let i = 0; i < 5; i++) value = JSON.stringify(value);
+
+    const result = inferAllReferencedBlocks({ wrapper: value });
+
+    expect(result.upstreams).toContain("blockZ");
+  });
+
+  it("detects PlRef when args itself is the multi-stringified ref string", () => {
+    let value: string = canonicalize(outputRef("blockTop", "n"))!;
+    for (let i = 0; i < 4; i++) value = JSON.stringify(value);
+
+    const result = inferAllReferencedBlocks(value);
+
+    expect(result.upstreams).toContain("blockTop");
+  });
+
+  it("ignores malformed __isRef occurrences", () => {
+    const result = inferAllReferencedBlocks({
+      a: '{"__isRef":true,"blockId"', // truncated
+      b: '"__isRef":false', // wrong value
+      c: "__isRef without quotes",
+    });
+
+    expect(result.upstreams.size).toBe(0);
+  });
 });

package/src/model/args.ts

@@ -17,26 +17,46 @@ export function isBlockOutputReference(obj: unknown): obj is PlRef {
   );
 }
 
+export interface BlockUpstreams {
+  /** All direct block dependencies */
+  upstreams: Set<string>;
+  /** Direct block dependencies which enrichments are also required by current block */
+  upstreamsRequiringEnrichments: Set<string>;
+  /** True if not-allowed references was encountered */
+  missingReferences: boolean;
+}
+
+/** Extracts all resource ids referenced by args object. */
+export function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {
+  const result = {
+    upstreams: new Set<string>(),
+    upstreamsRequiringEnrichments: new Set<string>(),
+    missingReferences: false,
+  };
+  addAllReferencedBlocks(result, args, allowed);
+  return result;
+}
+
 function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?: Set<string>) {
   const type = typeof node;
   switch (type) {
     case "function":
     case "bigint":
     case "number":
-    case "string":
     case "boolean":
     case "symbol":
     case "undefined":
       return;
-
-    case "object":
+    case "string": {
+      unwrapEmbeddedRef(node as string, (parsed) =>
+        addAllReferencedBlocks(result, parsed, allowed),
+      );
+      return;
+    }
+    case "object": {
       if (node === null) return;
-
       if (isBlockOutputReference(node)) {
-        if (allowed === undefined || allowed.has(node.blockId)) {
-          result.upstreams.add(node.blockId);
-          if (node.requireEnrichments) result.upstreamsRequiringEnrichments.add(node.blockId);
-        } else result.missingReferences = true;
+        recordRef(result, node.blockId, node.requireEnrichments === true, allowed);
       } else if (Array.isArray(node)) {
         for (const child of node) addAllReferencedBlocks(result, child, allowed);
       } else {
@@ -45,28 +65,47 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
       }
 
       return;
-
+    }
     default:
       assertNever(type);
   }
 }
 
-export interface BlockUpstreams {
-  /** All direct block dependencies */
-  upstreams: Set<string>;
-  /** Direct block dependencies which enrichments are also required by current block */
-  upstreamsRequiringEnrichments: Set<string>;
-  /** True if not-allowed references was encountered */
-  missingReferences: boolean;
+/**
+ * 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);
 }
 
-/** Extracts all resource ids referenced by args object. */
-export function inferAllReferencedBlocks(args: unknown, allowed?: Set<string>): BlockUpstreams {
-  const result = {
-    upstreams: new Set<string>(),
-    upstreamsRequiringEnrichments: new Set<string>(),
-    missingReferences: false,
-  };
-  addAllReferencedBlocks(result, args, allowed);
-  return result;
+function recordRef(
+  result: BlockUpstreams,
+  blockId: string,
+  requireEnrichments: boolean,
+  allowed?: Set<string>,
+) {
+  if (allowed === undefined || allowed.has(blockId)) {
+    result.upstreams.add(blockId);
+    if (requireEnrichments) result.upstreamsRequiringEnrichments.add(blockId);
+  } else result.missingReferences = true;
 }