@milaboratories/pl-model-middle-layer 1.16.2 → 1.16.4

package/dist/_virtual/_rolldown/runtime.cjs

@@ -7,28 +7,20 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
@@ -36,8 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
-
 exports.__exportAll = __exportAll;
-exports.__toESM = __toESM;
+exports.__toESM = __toESM;

package/dist/_virtual/_rolldown/runtime.js

@@ -2,17 +2,12 @@
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-
 //#endregion
-export { __exportAll };
+export { __exportAll };

package/dist/block_meta/block_components.cjs

@@ -1,8 +1,7 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_content_types = require('./content_types.cjs');
-const require_content_conversion = require('./content_conversion.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
+const require_content_types = require("./content_types.cjs");
+const require_content_conversion = require("./content_conversion.cjs");
 let zod = require("zod");
-
 //#region src/block_meta/block_components.ts
 function WorkflowV1(contentType) {
 	return zod.z.object({
@@ -27,11 +26,11 @@ const BlockComponentsDescriptionRaw = BlockComponents(zod.z.string(), zod.z.stri
 function BlockComponentsAbsoluteUrl(prefix) {
 	return BlockComponents(require_content_types.ContentRelativeBinary.transform(require_content_conversion.mapRemoteToAbsolute(prefix)), require_content_types.ContentRelativeBinary.transform(require_content_conversion.mapRemoteToAbsolute(prefix)));
 }
-
 //#endregion
 exports.BlockComponents = BlockComponents;
 exports.BlockComponentsAbsoluteUrl = BlockComponentsAbsoluteUrl;
 exports.BlockComponentsDescriptionRaw = BlockComponentsDescriptionRaw;
 exports.Workflow = Workflow;
 exports.WorkflowV1 = WorkflowV1;
+
 //# sourceMappingURL=block_components.cjs.map

package/dist/block_meta/block_components.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_components.cjs","names":["z","ContentRelativeBinary","mapRemoteToAbsolute"],"sources":["../../src/block_meta/block_components.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ContentRelativeBinary } from \"./content_types\";\nimport { mapRemoteToAbsolute } from \"./content_conversion\";\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal(\"workflow-v1\"),\n    main: contentType.describe(\"Main workflow\"),\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: \"workflow-v1\" as const,\n        main: value,\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion(\"type\", [WorkflowV1(contentType)]),\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny,\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui,\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n"],"mappings":";;;;;;AAIA,SAAgB,WAA+C,aAAsB;AACnF,QAAOA,MAAE,OAAO;EACd,MAAMA,MAAE,QAAQ,cAAc;EAC9B,MAAM,YAAY,SAAS,gBAAgB;EAC5C,CAAC;;AAGJ,SAAgB,SAA6C,aAAsB;AACjF,QAAOA,MAAE,MAAM,CAEb,YACG,WAAW,WAAwC;EAClD,MAAM;EACN,MAAM;EACP,EAAE,CACF,KAAK,WAAW,YAAY,CAAC,EAEhCA,MAAE,mBAAmB,QAAQ,CAAC,WAAW,YAAY,CAAC,CAAC,CACxD,CAAC;;AAGJ,SAAgB,gBAGd,YAAwB,IAAQ;AAChC,QAAOA,MAAE,OAAO;EACd,UAAU,SAAS,WAAW;EAC9B,OAAO;EACP;EACD,CAAC;;AAGJ,MAAa,gCAAgC,gBAAgBA,MAAE,QAAQ,EAAEA,MAAE,QAAQ,CAAC;AAGpF,SAAgB,2BAA2B,QAAgB;AACzD,QAAO,gBACLC,4CAAsB,UAAUC,+CAAoB,OAAO,CAAC,EAC5DD,4CAAsB,UAAUC,+CAAoB,OAAO,CAAC,CAC7D"}
+{"version":3,"file":"block_components.cjs","names":["z","ContentRelativeBinary","mapRemoteToAbsolute"],"sources":["../../src/block_meta/block_components.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ContentRelativeBinary } from \"./content_types\";\nimport { mapRemoteToAbsolute } from \"./content_conversion\";\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal(\"workflow-v1\"),\n    main: contentType.describe(\"Main workflow\"),\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: \"workflow-v1\" as const,\n        main: value,\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion(\"type\", [WorkflowV1(contentType)]),\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny,\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui,\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n"],"mappings":";;;;;AAIA,SAAgB,WAA+C,aAAsB;AACnF,QAAOA,IAAAA,EAAE,OAAO;EACd,MAAMA,IAAAA,EAAE,QAAQ,cAAc;EAC9B,MAAM,YAAY,SAAS,gBAAgB;EAC5C,CAAC;;AAGJ,SAAgB,SAA6C,aAAsB;AACjF,QAAOA,IAAAA,EAAE,MAAM,CAEb,YACG,WAAW,WAAwC;EAClD,MAAM;EACN,MAAM;EACP,EAAE,CACF,KAAK,WAAW,YAAY,CAAC,EAEhCA,IAAAA,EAAE,mBAAmB,QAAQ,CAAC,WAAW,YAAY,CAAC,CAAC,CACxD,CAAC;;AAGJ,SAAgB,gBAGd,YAAwB,IAAQ;AAChC,QAAOA,IAAAA,EAAE,OAAO;EACd,UAAU,SAAS,WAAW;EAC9B,OAAO;EACP;EACD,CAAC;;AAGJ,MAAa,gCAAgC,gBAAgBA,IAAAA,EAAE,QAAQ,EAAEA,IAAAA,EAAE,QAAQ,CAAC;AAGpF,SAAgB,2BAA2B,QAAgB;AACzD,QAAO,gBACLC,sBAAAA,sBAAsB,UAAUC,2BAAAA,oBAAoB,OAAO,CAAC,EAC5DD,sBAAAA,sBAAsB,UAAUC,2BAAAA,oBAAoB,OAAO,CAAC,CAC7D"}

package/dist/block_meta/block_components.d.ts

@@ -4,53 +4,35 @@ import { z } from "zod";
 declare function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content): z.ZodObject<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}>, any> extends infer T ? { [k in keyof T]: T[k] } : never, z.baseObjectInputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>]: z.baseObjectInputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>[k_1] }>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1] } : never>;
 declare function Workflow<const Content extends z.ZodTypeAny>(contentType: Content): z.ZodUnion<[z.ZodPipeline<z.ZodEffects<Content, {
   type: "workflow-v1";
   main: z.TypeOf<Content>;
 }, z.input<Content>>, z.ZodObject<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>]: z.baseObjectInputType<{
-  type: z.ZodLiteral<"workflow-v1">;
-  main: Content;
-}>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}>, any> extends infer T ? { [k in keyof T]: T[k] } : never, z.baseObjectInputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1] } : never>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>]: z.baseObjectInputType<{
+}>, any> extends infer T_2 ? { [k in keyof T_2]: T_2[k] } : never, z.baseObjectInputType<{
   type: z.ZodLiteral<"workflow-v1">;
   main: Content;
-}>[k_1] }>]>]>;
+}> extends infer T_3 ? { [k_1 in keyof T_3]: T_3[k_1] } : never>]>]>;
 declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, const UI extends z.ZodTypeAny>(wfAndModel: WfAndModel, ui: UI): z.ZodObject<{
   workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
     type: "workflow-v1";
@@ -58,185 +40,75 @@ declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, const UI
   }, z.input<WfAndModel>>, z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>]>]>;
-  model: WfAndModel;
-  ui: UI;
-}, "strip", z.ZodTypeAny, { [k_2 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-  workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
-    type: "workflow-v1";
-    main: z.TypeOf<WfAndModel>;
-  }, z.input<WfAndModel>>, z.ZodObject<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>]>]>;
-  model: WfAndModel;
-  ui: UI;
-}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-  workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
-    type: "workflow-v1";
-    main: z.TypeOf<WfAndModel>;
-  }, z.input<WfAndModel>>, z.ZodObject<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
+  }>, any> extends infer T ? { [k in keyof T]: T[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>]: z.baseObjectInputType<{
+  }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1] } : never>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }>, any> extends infer T_2 ? { [k in keyof T_2]: T_2[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>]>]>;
+  }> extends infer T_3 ? { [k_1 in keyof T_3]: T_3[k_1] } : never>]>]>;
   model: WfAndModel;
   ui: UI;
-}>, any>[k_2] }, { [k_1_1 in keyof z.baseObjectInputType<{
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
   workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
     type: "workflow-v1";
     main: z.TypeOf<WfAndModel>;
   }, z.input<WfAndModel>>, z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }>, any> extends infer T_5 ? { [k in keyof T_5]: T_5[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }> extends infer T_6 ? { [k_1 in keyof T_6]: T_6[k_1] } : never>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>]: z.baseObjectInputType<{
+  }>, any> extends infer T_7 ? { [k in keyof T_7]: T_7[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>[k_1] }>]>]>;
+  }> extends infer T_8 ? { [k_1 in keyof T_8]: T_8[k_1] } : never>]>]>;
   model: WfAndModel;
   ui: UI;
-}>]: z.baseObjectInputType<{
+}>, any> extends infer T_4 ? { [k_2 in keyof T_4]: T_4[k_2] } : never, z.baseObjectInputType<{
   workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
     type: "workflow-v1";
     main: z.TypeOf<WfAndModel>;
   }, z.input<WfAndModel>>, z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>]: z.baseObjectInputType<{
-    type: z.ZodLiteral<"workflow-v1">;
-    main: WfAndModel;
-  }>[k_1] }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }>, any> extends infer T_10 ? { [k in keyof T_10]: T_10[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+  }> extends infer T_11 ? { [k_1 in keyof T_11]: T_11[k_1] } : never>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
+  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>]: z.baseObjectInputType<{
+  }>, any> extends infer T_12 ? { [k in keyof T_12]: T_12[k] } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"workflow-v1">;
     main: WfAndModel;
-  }>[k_1] }>]>]>;
+  }> extends infer T_13 ? { [k_1 in keyof T_13]: T_13[k_1] } : never>]>]>;
   model: WfAndModel;
   ui: UI;
-}>[k_1_1] }>;
+}> extends infer T_9 ? { [k_3 in keyof T_9]: T_9[k_3] } : never>;
 declare const BlockComponentsDescriptionRaw: z.ZodObject<{
   workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodString, {
     type: "workflow-v1";

package/dist/block_meta/block_components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_components.d.ts","names":[],"sources":["../../src/block_meta/block_components.ts"],"mappings":";;;iBAIgB,UAAA,uBAAiC,CAAA,CAAE,UAAA,CAAA,CAAY,WAAA,EAAa,OAAA,GAAO,CAAA,CAAA,SAAA;;;;;;;;;;iBAOnE,QAAA,uBAA+B,CAAA,CAAE,UAAA,CAAA,CAAY,WAAA,EAAa,OAAA,GAAO,CAAA,CAAA,QAAA,EAAA,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,UAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;iBAcjE,eAAA,0BACW,CAAA,CAAE,UAAA,mBACV,CAAA,CAAE,UAAA,CAAA,CACnB,UAAA,EAAY,UAAA,EAAY,EAAA,EAAI,EAAA,GAAE,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAQnB,6BAAA,EAA6B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC9B,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,6BAAA;AAAA,iBAE3C,0BAAA,CAA2B,MAAA,WAAc,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAM7C,uBAAA,GAA0B,CAAA,CAAE,KAAA,CAAM,UAAA,QAAkB,0BAAA"}

package/dist/block_meta/block_components.js

@@ -1,7 +1,6 @@
 import { ContentRelativeBinary } from "./content_types.js";
 import { mapRemoteToAbsolute } from "./content_conversion.js";
 import { z } from "zod";
-
 //#region src/block_meta/block_components.ts
 function WorkflowV1(contentType) {
 	return z.object({
@@ -26,7 +25,7 @@ const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());
 function BlockComponentsAbsoluteUrl(prefix) {
 	return BlockComponents(ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)), ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)));
 }
-
 //#endregion
 export { BlockComponents, BlockComponentsAbsoluteUrl, BlockComponentsDescriptionRaw, Workflow, WorkflowV1 };
+
 //# sourceMappingURL=block_components.js.map

package/dist/block_meta/block_components.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_components.js","names":[],"sources":["../../src/block_meta/block_components.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ContentRelativeBinary } from \"./content_types\";\nimport { mapRemoteToAbsolute } from \"./content_conversion\";\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal(\"workflow-v1\"),\n    main: contentType.describe(\"Main workflow\"),\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: \"workflow-v1\" as const,\n        main: value,\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion(\"type\", [WorkflowV1(contentType)]),\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny,\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui,\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n"],"mappings":";;;;;AAIA,SAAgB,WAA+C,aAAsB;AACnF,QAAO,EAAE,OAAO;EACd,MAAM,EAAE,QAAQ,cAAc;EAC9B,MAAM,YAAY,SAAS,gBAAgB;EAC5C,CAAC;;AAGJ,SAAgB,SAA6C,aAAsB;AACjF,QAAO,EAAE,MAAM,CAEb,YACG,WAAW,WAAwC;EAClD,MAAM;EACN,MAAM;EACP,EAAE,CACF,KAAK,WAAW,YAAY,CAAC,EAEhC,EAAE,mBAAmB,QAAQ,CAAC,WAAW,YAAY,CAAC,CAAC,CACxD,CAAC;;AAGJ,SAAgB,gBAGd,YAAwB,IAAQ;AAChC,QAAO,EAAE,OAAO;EACd,UAAU,SAAS,WAAW;EAC9B,OAAO;EACP;EACD,CAAC;;AAGJ,MAAa,gCAAgC,gBAAgB,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC;AAGpF,SAAgB,2BAA2B,QAAgB;AACzD,QAAO,gBACL,sBAAsB,UAAU,oBAAoB,OAAO,CAAC,EAC5D,sBAAsB,UAAU,oBAAoB,OAAO,CAAC,CAC7D"}
+{"version":3,"file":"block_components.js","names":[],"sources":["../../src/block_meta/block_components.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ContentRelativeBinary } from \"./content_types\";\nimport { mapRemoteToAbsolute } from \"./content_conversion\";\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal(\"workflow-v1\"),\n    main: contentType.describe(\"Main workflow\"),\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: \"workflow-v1\" as const,\n        main: value,\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion(\"type\", [WorkflowV1(contentType)]),\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny,\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui,\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n"],"mappings":";;;;AAIA,SAAgB,WAA+C,aAAsB;AACnF,QAAO,EAAE,OAAO;EACd,MAAM,EAAE,QAAQ,cAAc;EAC9B,MAAM,YAAY,SAAS,gBAAgB;EAC5C,CAAC;;AAGJ,SAAgB,SAA6C,aAAsB;AACjF,QAAO,EAAE,MAAM,CAEb,YACG,WAAW,WAAwC;EAClD,MAAM;EACN,MAAM;EACP,EAAE,CACF,KAAK,WAAW,YAAY,CAAC,EAEhC,EAAE,mBAAmB,QAAQ,CAAC,WAAW,YAAY,CAAC,CAAC,CACxD,CAAC;;AAGJ,SAAgB,gBAGd,YAAwB,IAAQ;AAChC,QAAO,EAAE,OAAO;EACd,UAAU,SAAS,WAAW;EAC9B,OAAO;EACP;EACD,CAAC;;AAGJ,MAAa,gCAAgC,gBAAgB,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC;AAGpF,SAAgB,2BAA2B,QAAgB;AACzD,QAAO,gBACL,sBAAsB,UAAU,oBAAoB,OAAO,CAAC,EAC5D,sBAAsB,UAAU,oBAAoB,OAAO,CAAC,CAC7D"}

package/dist/block_meta/block_description.cjs

@@ -1,10 +1,9 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_block_id = require('./block_id.cjs');
-const require_block_components = require('./block_components.cjs');
-const require_block_meta = require('./block_meta.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
+const require_block_id = require("./block_id.cjs");
+const require_block_components = require("./block_components.cjs");
+const require_block_meta = require("./block_meta.cjs");
 let zod = require("zod");
 let es_toolkit = require("es-toolkit");
-
 //#region src/block_meta/block_description.ts
 /** Description, as appears in root block package.json file,
 * `file:` references are parsed into relative content of corresponding type, depending on the context,
@@ -26,11 +25,11 @@ const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(require_block_c
 function overrideDescriptionVersion(manifest, newVersion) {
 	return (0, es_toolkit.toMerged)(manifest, { id: { version: newVersion } });
 }
-
 //#endregion
 exports.BlockPackDescriptionFromPackageJsonRaw = BlockPackDescriptionFromPackageJsonRaw;
 exports.BlockPackDescriptionRaw = BlockPackDescriptionRaw;
 exports.CreateBlockPackDescriptionSchema = CreateBlockPackDescriptionSchema;
 exports.FeatureFlags = FeatureFlags;
 exports.overrideDescriptionVersion = overrideDescriptionVersion;
+
 //# sourceMappingURL=block_description.cjs.map

package/dist/block_meta/block_description.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_description.cjs","names":["z","BlockComponentsDescriptionRaw","BlockPackMetaDescriptionRaw","BlockPackId"],"sources":["../../src/block_meta/block_description.ts"],"sourcesContent":["import type { ZodTypeAny } from \"zod\";\nimport { z } from \"zod\";\nimport { BlockComponentsDescriptionRaw } from \"./block_components\";\nimport { BlockPackMetaDescriptionRaw } from \"./block_meta\";\nimport { BlockPackId } from \"./block_id\";\nimport { toMerged } from \"es-toolkit\";\nimport type { BlockCodeKnownFeatureFlags } from \"@milaboratories/pl-model-common\";\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw,\n});\n\nexport const FeatureFlags = z\n  .record(z.string(), z.union([z.boolean(), z.number()]))\n  .transform((flags) => flags as BlockCodeKnownFeatureFlags);\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny,\n>(components: Components, meta: Meta) {\n  return z\n    .object({\n      id: BlockPackId,\n      components,\n      meta,\n      featureFlags: FeatureFlags.optional(),\n    })\n    .passthrough();\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw,\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string,\n): T {\n  return toMerged(manifest, { id: { version: newVersion } }) as T;\n}\n"],"mappings":";;;;;;;;;;;AAWA,MAAa,yCAAyCA,MAAE,OAAO;CAC7D,YAAYC;CACZ,MAAMC;CACP,CAAC;AAEF,MAAa,eAAeF,MACzB,OAAOA,MAAE,QAAQ,EAAEA,MAAE,MAAM,CAACA,MAAE,SAAS,EAAEA,MAAE,QAAQ,CAAC,CAAC,CAAC,CACtD,WAAW,UAAU,MAAoC;AAE5D,SAAgB,iCAGd,YAAwB,MAAY;AACpC,QAAOA,MACJ,OAAO;EACN,IAAIG;EACJ;EACA;EACA,cAAc,aAAa,UAAU;EACtC,CAAC,CACD,aAAa;;AAGlB,MAAa,0BAA0B,iCACrCF,wDACAC,+CACD;AAGD,SAAgB,2BACd,UACA,YACG;AACH,iCAAgB,UAAU,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC"}
+{"version":3,"file":"block_description.cjs","names":["z","BlockComponentsDescriptionRaw","BlockPackMetaDescriptionRaw","BlockPackId"],"sources":["../../src/block_meta/block_description.ts"],"sourcesContent":["import type { ZodTypeAny } from \"zod\";\nimport { z } from \"zod\";\nimport { BlockComponentsDescriptionRaw } from \"./block_components\";\nimport { BlockPackMetaDescriptionRaw } from \"./block_meta\";\nimport { BlockPackId } from \"./block_id\";\nimport { toMerged } from \"es-toolkit\";\nimport type { BlockCodeKnownFeatureFlags } from \"@milaboratories/pl-model-common\";\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw,\n});\n\nexport const FeatureFlags = z\n  .record(z.string(), z.union([z.boolean(), z.number()]))\n  .transform((flags) => flags as BlockCodeKnownFeatureFlags);\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny,\n>(components: Components, meta: Meta) {\n  return z\n    .object({\n      id: BlockPackId,\n      components,\n      meta,\n      featureFlags: FeatureFlags.optional(),\n    })\n    .passthrough();\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw,\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string,\n): T {\n  return toMerged(manifest, { id: { version: newVersion } }) as T;\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAa,yCAAyCA,IAAAA,EAAE,OAAO;CAC7D,YAAYC,yBAAAA;CACZ,MAAMC,mBAAAA;CACP,CAAC;AAEF,MAAa,eAAeF,IAAAA,EACzB,OAAOA,IAAAA,EAAE,QAAQ,EAAEA,IAAAA,EAAE,MAAM,CAACA,IAAAA,EAAE,SAAS,EAAEA,IAAAA,EAAE,QAAQ,CAAC,CAAC,CAAC,CACtD,WAAW,UAAU,MAAoC;AAE5D,SAAgB,iCAGd,YAAwB,MAAY;AACpC,QAAOA,IAAAA,EACJ,OAAO;EACN,IAAIG,iBAAAA;EACJ;EACA;EACA,cAAc,aAAa,UAAU;EACtC,CAAC,CACD,aAAa;;AAGlB,MAAa,0BAA0B,iCACrCF,yBAAAA,+BACAC,mBAAAA,4BACD;AAGD,SAAgB,2BACd,UACA,YACG;AACH,SAAA,GAAA,WAAA,UAAgB,UAAU,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC"}

package/dist/block_meta/block_description.d.ts

@@ -308,6 +308,7 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: {
       type: "explicit-string";
       content: string;
@@ -339,7 +340,6 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -367,6 +367,7 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: string | {
       type: "explicit-string";
       content: string;
@@ -398,7 +399,6 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -428,6 +428,7 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: {
       type: "explicit-string";
       content: string;
@@ -459,7 +460,6 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -497,6 +497,7 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: string | {
       type: "explicit-string";
       content: string;
@@ -528,7 +529,6 @@ declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -914,6 +914,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: {
       type: "explicit-string";
       content: string;
@@ -945,7 +946,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -973,6 +973,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: string | {
       type: "explicit-string";
       content: string;
@@ -1004,7 +1005,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -1329,6 +1329,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: {
       type: "explicit-string";
       content: string;
@@ -1360,7 +1361,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -1388,6 +1388,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: string | {
       type: "explicit-string";
       content: string;
@@ -1419,7 +1420,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -1744,6 +1744,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: {
       type: "explicit-string";
       content: string;
@@ -1775,7 +1776,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;
@@ -1803,6 +1803,7 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
     };
     title: string;
     description: string;
+    url?: string | undefined;
     longDescription?: string | {
       type: "explicit-string";
       content: string;
@@ -1834,7 +1835,6 @@ declare const BlockPackDescriptionRaw: z.ZodObject<{
       type: "absolute-file";
       file: string;
     } | undefined;
-    url?: string | undefined;
     docs?: string | undefined;
     support?: string | undefined;
     tags?: string[] | undefined;

package/dist/block_meta/block_description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_description.d.ts","names":[],"sources":["../../src/block_meta/block_description.ts"],"mappings":"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"}

package/dist/block_meta/block_description.js

@@ -3,7 +3,6 @@ import { BlockComponentsDescriptionRaw } from "./block_components.js";
 import { BlockPackMetaDescriptionRaw } from "./block_meta.js";
 import { z } from "zod";
 import { toMerged } from "es-toolkit";
-
 //#region src/block_meta/block_description.ts
 /** Description, as appears in root block package.json file,
 * `file:` references are parsed into relative content of corresponding type, depending on the context,
@@ -25,7 +24,7 @@ const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(BlockComponents
 function overrideDescriptionVersion(manifest, newVersion) {
 	return toMerged(manifest, { id: { version: newVersion } });
 }
-
 //#endregion
 export { BlockPackDescriptionFromPackageJsonRaw, BlockPackDescriptionRaw, CreateBlockPackDescriptionSchema, FeatureFlags, overrideDescriptionVersion };
+
 //# sourceMappingURL=block_description.js.map