@milaboratories/pl-model-middle-layer 1.4.1 → 1.4.2

package/dist/block_meta/block_description.d.ts

@@ -80,6 +80,40 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         }>]>]>>;
+        changelog: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        }, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"explicit-string">;
+            content: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "explicit-string";
+            content: string;
+        }, {
+            type: "explicit-string";
+            content: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"relative">;
+            path: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "relative";
+            path: string;
+        }, {
+            type: "relative";
+            path: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"absolute-file">;
+            file: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "absolute-file";
+            file: string;
+        }, {
+            type: "absolute-file";
+            file: string;
+        }>]>]>>;
         logo: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
             type: "explicit-base64";
             content: string;
@@ -221,6 +255,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -264,6 +308,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: string | {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: string | {
             type: "explicit-base64";
             content: string;
@@ -317,6 +371,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -370,6 +434,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: string | {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: string | {
             type: "explicit-base64";
             content: string;
@@ -558,6 +632,40 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         }>]>]>>;
+        changelog: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        }, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"explicit-string">;
+            content: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "explicit-string";
+            content: string;
+        }, {
+            type: "explicit-string";
+            content: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"relative">;
+            path: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "relative";
+            path: string;
+        }, {
+            type: "relative";
+            path: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"absolute-file">;
+            file: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "absolute-file";
+            file: string;
+        }, {
+            type: "absolute-file";
+            file: string;
+        }>]>]>>;
         logo: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
             type: "explicit-base64";
             content: string;
@@ -699,6 +807,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -742,6 +860,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: string | {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: string | {
             type: "explicit-base64";
             content: string;
@@ -795,6 +923,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -853,6 +991,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             type: "absolute-file";
             file: string;
         } | undefined;
+        changelog?: string | {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | {
+            type: "absolute-file";
+            file: string;
+        } | undefined;
         logo?: string | {
             type: "explicit-base64";
             content: string;

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

@@ -1 +1 @@
-{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAKpC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD,CAAC;AAEH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,UAAU,EAC7B,IAAI,SAAS,UAAU,EACvB,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAMnC;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAKpC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD,CAAC;AAEH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,UAAU,EAC7B,IAAI,SAAS,UAAU,EACvB,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAMnC;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/block_meta/block_manifest.d.ts

@@ -146,6 +146,25 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
         type: "relative";
         path: string;
     }>]>>;
+    changelog: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-string">;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-string";
+        content: string;
+    }, {
+        type: "explicit-string";
+        content: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>]>>;
     logo: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"explicit-base64">;
         mimeType: z.ZodString;
@@ -243,6 +262,13 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
         type: "relative";
         path: string;
     } | undefined;
+    changelog?: {
+        type: "explicit-string";
+        content: string;
+    } | {
+        type: "relative";
+        path: string;
+    } | undefined;
     logo?: {
         type: "explicit-base64";
         content: string;
@@ -277,6 +303,13 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
         type: "relative";
         path: string;
     } | undefined;
+    changelog?: {
+        type: "explicit-string";
+        content: string;
+    } | {
+        type: "relative";
+        path: string;
+    } | undefined;
     logo?: {
         type: "explicit-base64";
         content: string;
@@ -451,6 +484,25 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             type: "relative";
             path: string;
         }>]>>;
+        changelog: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"explicit-string">;
+            content: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "explicit-string";
+            content: string;
+        }, {
+            type: "explicit-string";
+            content: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"relative">;
+            path: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            type: "relative";
+            path: string;
+        }, {
+            type: "relative";
+            path: string;
+        }>]>>;
         logo: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             type: z.ZodLiteral<"explicit-base64">;
             mimeType: z.ZodString;
@@ -548,6 +600,13 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             type: "relative";
             path: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -582,6 +641,13 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             type: "relative";
             path: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -635,6 +701,13 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             type: "relative";
             path: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -696,6 +769,13 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             type: "relative";
             path: string;
         } | undefined;
+        changelog?: {
+            type: "explicit-string";
+            content: string;
+        } | {
+            type: "relative";
+            path: string;
+        } | undefined;
         logo?: {
             type: "explicit-base64";
             content: string;
@@ -892,6 +972,25 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             }>]>>;
+            changelog: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"explicit-string">;
+                content: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                type: "explicit-string";
+                content: string;
+            }, {
+                type: "explicit-string";
+                content: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"relative">;
+                path: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                type: "relative";
+                path: string;
+            }, {
+                type: "relative";
+                path: string;
+            }>]>>;
             logo: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                 type: z.ZodLiteral<"explicit-base64">;
                 mimeType: z.ZodString;
@@ -989,6 +1088,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;
@@ -1023,6 +1129,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;
@@ -1076,6 +1189,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;
@@ -1137,6 +1257,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;
@@ -1210,6 +1337,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;
@@ -1279,6 +1413,13 @@ export declare const BlockPackManifest: z.ZodObject<{
                 type: "relative";
                 path: string;
             } | undefined;
+            changelog?: {
+                type: "explicit-string";
+                content: string;
+            } | {
+                type: "relative";
+                path: string;
+            } | undefined;
             logo?: {
                 type: "explicit-base64";
                 content: string;

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

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AACzF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4D,CAAC;AAC/F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,qDAAqD;AACrD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAExF,eAAO,MAAM,YAAY,aAIZ,CAAC;AAEd,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,qBAAqB,kBAAkB,CAAC"}
+{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"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"}

package/dist/block_meta/block_meta.d.ts

@@ -3,6 +3,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<LongStringType>;
+    changelog: z.ZodOptional<LongStringType>;
     logo: z.ZodOptional<BinaryType>;
     url: z.ZodOptional<z.ZodString>;
     docs: z.ZodOptional<z.ZodString>;
@@ -33,6 +34,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<LongStringType>;
+    changelog: z.ZodOptional<LongStringType>;
     logo: z.ZodOptional<BinaryType>;
     url: z.ZodOptional<z.ZodString>;
     docs: z.ZodOptional<z.ZodString>;
@@ -63,6 +65,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<LongStringType>;
+    changelog: z.ZodOptional<LongStringType>;
     logo: z.ZodOptional<BinaryType>;
     url: z.ZodOptional<z.ZodString>;
     docs: z.ZodOptional<z.ZodString>;
@@ -93,6 +96,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<LongStringType>;
+    changelog: z.ZodOptional<LongStringType>;
     logo: z.ZodOptional<BinaryType>;
     url: z.ZodOptional<z.ZodString>;
     docs: z.ZodOptional<z.ZodString>;
@@ -123,6 +127,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<LongStringType>;
+    changelog: z.ZodOptional<LongStringType>;
     logo: z.ZodOptional<BinaryType>;
     url: z.ZodOptional<z.ZodString>;
     docs: z.ZodOptional<z.ZodString>;
@@ -187,6 +192,40 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
         type: "absolute-file";
         file: string;
     }>]>]>>;
+    changelog: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        type: "explicit-string";
+        content: string;
+    } | {
+        type: "relative";
+        path: string;
+    }, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-string">;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-string";
+        content: string;
+    }, {
+        type: "explicit-string";
+        content: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"absolute-file">;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "absolute-file";
+        file: string;
+    }, {
+        type: "absolute-file";
+        file: string;
+    }>]>]>>;
     logo: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
         type: "explicit-base64";
         content: string;
@@ -328,6 +367,16 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
         type: "absolute-file";
         file: string;
     } | undefined;
+    changelog?: {
+        type: "explicit-string";
+        content: string;
+    } | {
+        type: "relative";
+        path: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    } | undefined;
     logo?: {
         type: "explicit-base64";
         content: string;
@@ -371,6 +420,16 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
         type: "absolute-file";
         file: string;
     } | undefined;
+    changelog?: string | {
+        type: "explicit-string";
+        content: string;
+    } | {
+        type: "relative";
+        path: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    } | undefined;
     logo?: string | {
         type: "explicit-base64";
         content: string;
@@ -391,6 +450,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<z.ZodString>;
+    changelog: z.ZodOptional<z.ZodString>;
     logo: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"explicit-base64">;
         mimeType: z.ZodString;
@@ -455,6 +515,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     description: string;
     url?: string | undefined;
     longDescription?: string | undefined;
+    changelog?: string | undefined;
     logo?: {
         type: "explicit-base64";
         content: string;
@@ -477,6 +538,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     description: string;
     url?: string | undefined;
     longDescription?: string | undefined;
+    changelog?: string | undefined;
     logo?: {
         type: "explicit-base64";
         content: string;
@@ -491,6 +553,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodString;
     longDescription: z.ZodOptional<z.ZodString>;
+    changelog: z.ZodOptional<z.ZodString>;
     logo: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"explicit-bytes">;
         mimeType: z.ZodString;
@@ -555,6 +618,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     description: string;
     url?: string | undefined;
     longDescription?: string | undefined;
+    changelog?: string | undefined;
     logo?: {
         type: "explicit-bytes";
         content: Uint8Array;
@@ -577,6 +641,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     description: string;
     url?: string | undefined;
     longDescription?: string | undefined;
+    changelog?: string | undefined;
     logo?: {
         type: "explicit-bytes";
         content: Uint8Array;

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

@@ -1 +1 @@
-{"version":3,"file":"block_meta.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,wBAAgB,aAAa,CAC3B,KAAK,CAAC,cAAc,SAAS,CAAC,CAAC,UAAU,EACzC,KAAK,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EACrC,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgB/C;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"block_meta.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,wBAAgB,aAAa,CAC3B,KAAK,CAAC,cAAc,SAAS,CAAC,CAAC,UAAU,EACzC,KAAK,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EACrC,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiB/C;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/block_registry/overview.d.ts

@@ -21,6 +21,7 @@ export declare const BlockPackOverview: z.ZodObject<{
         title: z.ZodString;
         description: z.ZodString;
         longDescription: z.ZodOptional<z.ZodString>;
+        changelog: z.ZodOptional<z.ZodString>;
         logo: z.ZodOptional<z.ZodObject<{
             type: z.ZodLiteral<"explicit-bytes">;
             mimeType: z.ZodString;
@@ -85,6 +86,7 @@ export declare const BlockPackOverview: z.ZodObject<{
         description: string;
         url?: string | undefined;
         longDescription?: string | undefined;
+        changelog?: string | undefined;
         logo?: {
             type: "explicit-bytes";
             content: Uint8Array;
@@ -107,6 +109,7 @@ export declare const BlockPackOverview: z.ZodObject<{
         description: string;
         url?: string | undefined;
         longDescription?: string | undefined;
+        changelog?: string | undefined;
         logo?: {
             type: "explicit-bytes";
             content: Uint8Array;
@@ -221,6 +224,7 @@ export declare const BlockPackOverview: z.ZodObject<{
         description: string;
         url?: string | undefined;
         longDescription?: string | undefined;
+        changelog?: string | undefined;
         logo?: {
             type: "explicit-bytes";
             content: Uint8Array;
@@ -277,6 +281,7 @@ export declare const BlockPackOverview: z.ZodObject<{
         description: string;
         url?: string | undefined;
         longDescription?: string | undefined;
+        changelog?: string | undefined;
         logo?: {
             type: "explicit-bytes";
             content: Uint8Array;
@@ -465,6 +470,7 @@ export declare const BlockPackListing: z.ZodObject<{
             title: z.ZodString;
             description: z.ZodString;
             longDescription: z.ZodOptional<z.ZodString>;
+            changelog: z.ZodOptional<z.ZodString>;
             logo: z.ZodOptional<z.ZodObject<{
                 type: z.ZodLiteral<"explicit-bytes">;
                 mimeType: z.ZodString;
@@ -529,6 +535,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;
@@ -551,6 +558,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;
@@ -665,6 +673,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;
@@ -721,6 +730,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;
@@ -794,6 +804,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;
@@ -867,6 +878,7 @@ export declare const BlockPackListing: z.ZodObject<{
             description: string;
             url?: string | undefined;
             longDescription?: string | undefined;
+            changelog?: string | undefined;
             logo?: {
                 type: "explicit-bytes";
                 content: Uint8Array;

package/dist/block_registry/overview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;KAEK;AACL,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;KAEK;AACL,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),r=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),o=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().startsWith("/").describe("Absolute address of the file in local file system")}).strict(),l=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),f=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),$=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().startsWith("/").describe("Absolute address of the folder in local file system")}).strict(),q=t.z.discriminatedUnion("type",[r,i,o,c,l]),J=t.z.discriminatedUnion("type",[r,i,o]),N=t.z.discriminatedUnion("type",[r,i,o,c]),G=t.z.discriminatedUnion("type",[r,i,o,l]),C=t.z.discriminatedUnion("type",[i,o,c]),P=t.z.discriminatedUnion("type",[r,o,c]),H=t.z.discriminatedUnion("type",[i,l]),K=t.z.discriminatedUnion("type",[i,c]),Q=t.z.discriminatedUnion("type",[r,l]),X=t.z.discriminatedUnion("type",[r,c]),p=t.z.discriminatedUnion("type",[i,o]),R=t.z.discriminatedUnion("type",[r,o]),v=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),C]),A=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),P]),m=t.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,"Wrong version format, please use valid semver");function y(e){const n=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"absolute-url",url:n+s.path}:s}function Y(e){const n=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"relative",path:n+s.path}:s}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:m}).strict(),tt=a.omit({version:!0});function k(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function h(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(k(e)),t.z.discriminatedUnion("type",[k(e)])])}function d(e,n){return t.z.object({workflow:h(e),model:e,ui:n})}const g=d(t.z.string(),t.z.string());function et(e){return d(p.transform(y(e)),p.transform(y(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()})})}const u=z(A,v),nt=z(t.z.string(),i),j=z(t.z.string(),f),ot=t.z.object({components:g,meta:u});function b(e,n){return t.z.object({id:a,components:e,meta:n})}const it=b(g,u),x=d(o,o),M=z(R,p),w=b(x,M),S=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),D=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:S}),rt=t.z.object({schema:t.z.literal("v2"),description:w,files:t.z.array(D)}),st="manifest.json",U=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),V=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),L=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a}),E=t.z.discriminatedUnion("type",[U,V,F,L]),T=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),W=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),I=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),O=t.z.discriminatedUnion("type",[W,I,T]),B=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:O}),ct=t.z.array(B),Z=t.z.object({registryId:t.z.string(),id:a,meta:j,spec:E,otherVersions:t.z.array(m)}),_=B.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),at=t.z.object({registries:t.z.array(_),blockPacks:t.z.array(Z)}),lt=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=d;exports.BlockComponentsAbsoluteUrl=et;exports.BlockComponentsDescriptionRaw=g;exports.BlockComponentsManifest=x;exports.BlockPackDescriptionFromPackageJsonRaw=ot;exports.BlockPackDescriptionManifest=w;exports.BlockPackDescriptionRaw=it;exports.BlockPackDevV1=U;exports.BlockPackDevV2=V;exports.BlockPackFromRegistryV1=F;exports.BlockPackFromRegistryV2=L;exports.BlockPackId=a;exports.BlockPackIdNoVersion=tt;exports.BlockPackListing=at;exports.BlockPackManifest=rt;exports.BlockPackManifestFile=st;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=u;exports.BlockPackMetaEmbeddedBase64=nt;exports.BlockPackMetaEmbeddedBytes=j;exports.BlockPackMetaManifest=M;exports.BlockPackOverview=Z;exports.BlockPackSpec=E;exports.ContentAbsoluteBinaryLocal=K;exports.ContentAbsoluteBinaryRemote=H;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=$;exports.ContentAbsoluteTextLocal=X;exports.ContentAbsoluteTextRemote=Q;exports.ContentAbsoluteUrl=l;exports.ContentAny=q;exports.ContentAnyBinaryLocal=C;exports.ContentAnyLocal=N;exports.ContentAnyRemote=G;exports.ContentAnyTextLocal=P;exports.ContentExplicitBase64=i;exports.ContentExplicitBytes=f;exports.ContentExplicitOrRelative=J;exports.ContentExplicitString=r;exports.ContentRelative=o;exports.ContentRelativeBinary=p;exports.ContentRelativeText=R;exports.CreateBlockPackDescriptionSchema=b;exports.DescriptionContentBinary=v;exports.DescriptionContentText=A;exports.LocalDevFolder=T;exports.ManifestFileInfo=D;exports.PFrameInternal=lt;exports.RegistryEntry=B;exports.RegistryList=ct;exports.RegistrySpec=O;exports.RegistryStatus=_;exports.RemoteRegistryV1Spec=W;exports.RemoteRegistryV2Spec=I;exports.SemVer=m;exports.Sha256Schema=S;exports.Workflow=h;exports.WorkflowV1=k;exports.addPrefixToRelative=Y;exports.mapRemoteToAbsolute=y;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),r=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),o=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().startsWith("/").describe("Absolute address of the file in local file system")}).strict(),l=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),f=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),$=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().startsWith("/").describe("Absolute address of the folder in local file system")}).strict(),q=t.z.discriminatedUnion("type",[r,i,o,c,l]),J=t.z.discriminatedUnion("type",[r,i,o]),N=t.z.discriminatedUnion("type",[r,i,o,c]),G=t.z.discriminatedUnion("type",[r,i,o,l]),C=t.z.discriminatedUnion("type",[i,o,c]),P=t.z.discriminatedUnion("type",[r,o,c]),H=t.z.discriminatedUnion("type",[i,l]),K=t.z.discriminatedUnion("type",[i,c]),Q=t.z.discriminatedUnion("type",[r,l]),X=t.z.discriminatedUnion("type",[r,c]),p=t.z.discriminatedUnion("type",[i,o]),R=t.z.discriminatedUnion("type",[r,o]),v=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),C]),A=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),P]),m=t.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,"Wrong version format, please use valid semver");function y(e){const n=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"absolute-url",url:n+s.path}:s}function Y(e){const n=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"relative",path:n+s.path}:s}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:m}).strict(),tt=a.omit({version:!0});function k(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function h(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(k(e)),t.z.discriminatedUnion("type",[k(e)])])}function d(e,n){return t.z.object({workflow:h(e),model:e,ui:n})}const g=d(t.z.string(),t.z.string());function et(e){return d(p.transform(y(e)),p.transform(y(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()})})}const u=z(A,v),nt=z(t.z.string(),i),j=z(t.z.string(),f),ot=t.z.object({components:g,meta:u});function b(e,n){return t.z.object({id:a,components:e,meta:n})}const it=b(g,u),x=d(o,o),M=z(R,p),w=b(x,M),S=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),D=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:S}),rt=t.z.object({schema:t.z.literal("v2"),description:w,files:t.z.array(D)}),st="manifest.json",U=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),V=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),L=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a}),E=t.z.discriminatedUnion("type",[U,V,F,L]),T=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),W=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),I=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),O=t.z.discriminatedUnion("type",[W,I,T]),B=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:O}),ct=t.z.array(B),Z=t.z.object({registryId:t.z.string(),id:a,meta:j,spec:E,otherVersions:t.z.array(m)}),_=B.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),at=t.z.object({registries:t.z.array(_),blockPacks:t.z.array(Z)}),lt=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=d;exports.BlockComponentsAbsoluteUrl=et;exports.BlockComponentsDescriptionRaw=g;exports.BlockComponentsManifest=x;exports.BlockPackDescriptionFromPackageJsonRaw=ot;exports.BlockPackDescriptionManifest=w;exports.BlockPackDescriptionRaw=it;exports.BlockPackDevV1=U;exports.BlockPackDevV2=V;exports.BlockPackFromRegistryV1=F;exports.BlockPackFromRegistryV2=L;exports.BlockPackId=a;exports.BlockPackIdNoVersion=tt;exports.BlockPackListing=at;exports.BlockPackManifest=rt;exports.BlockPackManifestFile=st;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=u;exports.BlockPackMetaEmbeddedBase64=nt;exports.BlockPackMetaEmbeddedBytes=j;exports.BlockPackMetaManifest=M;exports.BlockPackOverview=Z;exports.BlockPackSpec=E;exports.ContentAbsoluteBinaryLocal=K;exports.ContentAbsoluteBinaryRemote=H;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=$;exports.ContentAbsoluteTextLocal=X;exports.ContentAbsoluteTextRemote=Q;exports.ContentAbsoluteUrl=l;exports.ContentAny=q;exports.ContentAnyBinaryLocal=C;exports.ContentAnyLocal=N;exports.ContentAnyRemote=G;exports.ContentAnyTextLocal=P;exports.ContentExplicitBase64=i;exports.ContentExplicitBytes=f;exports.ContentExplicitOrRelative=J;exports.ContentExplicitString=r;exports.ContentRelative=o;exports.ContentRelativeBinary=p;exports.ContentRelativeText=R;exports.CreateBlockPackDescriptionSchema=b;exports.DescriptionContentBinary=v;exports.DescriptionContentText=A;exports.LocalDevFolder=T;exports.ManifestFileInfo=D;exports.PFrameInternal=lt;exports.RegistryEntry=B;exports.RegistryList=ct;exports.RegistrySpec=O;exports.RegistryStatus=_;exports.RemoteRegistryV1Spec=W;exports.RemoteRegistryV2Spec=I;exports.SemVer=m;exports.Sha256Schema=S;exports.Workflow=h;exports.WorkflowV1=k;exports.addPrefixToRelative=Y;exports.mapRemoteToAbsolute=y;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\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 function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\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 function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}

package/dist/index.mjs

@@ -17,7 +17,7 @@ const r = t.object({
 }).strict(), l = t.object({
   type: t.literal("absolute-url"),
   url: t.string().url().describe("Global URL to reach the requested file")
-}).strict(), h = t.object({
+}).strict(), B = t.object({
   type: t.literal("explicit-bytes"),
   mimeType: t.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),
   content: t.instanceof(Uint8Array).describe("Raw content")
@@ -129,6 +129,7 @@ function p(e, n) {
     title: t.string(),
     description: t.string(),
     longDescription: e.optional(),
+    changelog: e.optional(),
     logo: n.optional(),
     url: t.string().url().optional(),
     docs: t.string().url().optional(),
@@ -149,7 +150,7 @@ const f = p(
   o
 ), x = p(
   t.string(),
-  h
+  B
 ), ot = t.object({
   components: u,
   meta: f
@@ -209,17 +210,17 @@ const rt = k(
   T,
   I,
   L
-]), B = t.object({
+]), h = t.object({
   id: t.string(),
   title: t.string().optional(),
   spec: Z
-}), at = t.array(B), O = t.object({
+}), at = t.array(h), O = t.object({
   registryId: t.string(),
   id: a,
   meta: x,
   spec: E,
   otherVersions: t.array(b)
-}), _ = B.extend({
+}), _ = h.extend({
   status: t.union([t.literal("online"), t.literal("offline")])
 }), lt = t.object({
   registries: t.array(_),
@@ -264,7 +265,7 @@ export {
   H as ContentAnyRemote,
   j as ContentAnyTextLocal,
   o as ContentExplicitBase64,
-  h as ContentExplicitBytes,
+  B as ContentExplicitBytes,
   J as ContentExplicitOrRelative,
   r as ContentExplicitString,
   i as ContentRelative,
@@ -276,7 +277,7 @@ export {
   L as LocalDevFolder,
   D as ManifestFileInfo,
   pt as PFrameInternal,
-  B as RegistryEntry,
+  h as RegistryEntry,
   at as RegistryList,
   Z as RegistrySpec,
   _ as RegistryStatus,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\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 function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
+{"version":3,"file":"index.mjs","sources":["../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\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 function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-middle-layer",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Common model between middle layer and non-block UI code",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

package/src/block_meta/block_meta.ts

@@ -14,6 +14,7 @@ export function BlockPackMeta<
     title: z.string(),
     description: z.string(),
     longDescription: longString.optional(),
+    changelog: longString.optional(),
     logo: binary.optional(),
     url: z.string().url().optional(),
     docs: z.string().url().optional(),