@platforma-sdk/block-tools 2.2.0 → 2.3.1

package/dist/v2/registry/schema_public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_public.d.ts","sourceRoot":"","sources":["../../../src/v2/registry/schema_public.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema_public.d.ts","sourceRoot":"","sources":["../../../src/v2/registry/schema_public.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,WAAW,EACX,oBAAoB,EAOrB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAqD,MAAM,UAAU,CAAC;AAEpG,eAAO,MAAM,UAAU,QAAQ,CAAC;AAEhC,eAAO,MAAM,sBAAsB,kBAAkB,CAAC;AACtD,eAAO,MAAM,uBAAuB,kBAAkB,CAAC;AACvD,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAEpE;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED,eAAO,MAAM,cAAc,QAAyB,CAAC;AAMrD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiFwzT,CAAC;;;;;;;;;;;oBAA6S,CAAC;;;;;;;;;;;;;oBAAoW,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;oBAA4H,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;oBAAogB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAgpB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA5sE,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAgpB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;EA9Ez3d,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEtF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2Eo0T,CAAC;;;;;;;;;;;wBAA6S,CAAC;;;;;;;;;;;;;wBAAoW,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;wBAA4H,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;wBAAogB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA5sE,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA5sE,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;EAxEz3d,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,oBAAoB,GAAG,MAAM,CAEpE;AAED,eAAO,MAAM,kBAAkB,qBAA2C,CAAC;AAE3E,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,WAAW,SAAS,CAAC,CAAC,UAAU,EACxE,eAAe,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAQ7B;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqD6zT,CAAC;;;;;;;;;;;oBAA6S,CAAC;;;;;;;;;;;;;oBAAoW,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;oBAA4H,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;oBAAogB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAgpB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA5sE,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAgpB,CAAC;;;;;;;;;;;eAAuS,CAAC;2BAA6C,CAAC;;;;;;;gBAA+K,CAAC;;;;;;;;gBAA6M,CAAC;mBAAqC,CAAC;gBAAkC,CAAC;;;;;;;;;EArDpyd,CAAC;AACxF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,wBAAgB,cAAc,CAAC,KAAK,CAAC,WAAW,SAAS,CAAC,CAAC,UAAU,EACnE,eAAe,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM7B;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCk0T,CAAC;;;;;;;;;;;wBAA6S,CAAC;;;;;;;;;;;;;wBAAoW,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;wBAA4H,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;wBAAogB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA5sE,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA5sE,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAgpB,CAAC;;;;;;;;;;;mBAAuS,CAAC;+BAA6C,CAAC;;;;;;;oBAA+K,CAAC;;;;;;;;oBAA6M,CAAC;uBAAqC,CAAC;oBAAkC,CAAC;;;;;;;;;;EAzC9yd,CAAC;AAC9E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,wBAAgB,qCAAqC,CAAC,MAAM,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQlF;AACD,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUhF;AACD,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,UAAU,CAAC,OAAO,mCAAmC,CAAC,CACvD,CAAC;AAEF,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUjF;AACD,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,UAAU,CAAC,OAAO,oCAAoC,CAAC,CACxD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "types": "./dist/lib.d.ts",
   "main": "./dist/index.js",
@@ -25,14 +25,16 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.658.1",
     "@oclif/core": "^4.0.23",
+    "canonicalize": "^2.0.0",
+    "undici": "^6.19.8",
     "mime-types": "^2.1.35",
     "tar": "^7.4.3",
     "yaml": "^2.5.1",
     "zod": "^3.23.8",
     "@milaboratories/resolve-helper": "^1.0.1",
-    "@milaboratories/pl-model-middle-layer": "^1.3.0",
-    "@milaboratories/ts-helpers": "^1.0.26",
-    "@milaboratories/ts-helpers-oclif": "^1.1.4"
+    "@milaboratories/pl-model-middle-layer": "^1.4.1",
+    "@milaboratories/ts-helpers": "^1.0.27",
+    "@milaboratories/ts-helpers-oclif": "^1.1.5"
   },
   "devDependencies": {
     "typescript": "~5.5.4",
@@ -46,6 +48,7 @@
     "@types/node": "~20.16.5",
     "@types/semver": "^7.5.8",
     "jest": "^29.7.0",
+    "@jest/globals": "^29.7.0",
     "oclif": "^4.14.35",
     "ts-jest": "^29.2.5",
     "@milaboratories/platforma-build-configs": "1.0.1"

package/src/cmd/build-meta.ts

@@ -2,7 +2,7 @@ import { Command, Flags } from '@oclif/core';
 import path from 'path';
 import fs from 'fs';
 import { loadPackDescriptionRaw } from '../v2';
-import { BlockPackMetaDescription, BlockPackMetaEmbed } from '../v2/model/block_meta';
+import { BlockPackMetaDescription, BlockPackMetaEmbedAbsoluteBase64 } from '../v2/model/block_meta';
 
 export default class BuildMeta extends Command {
   static override description =
@@ -29,7 +29,7 @@ export default class BuildMeta extends Command {
     const { flags } = await this.parse(BuildMeta);
     const modulePath = path.resolve(flags.modulePath);
     const descriptionRaw = await loadPackDescriptionRaw(modulePath);
-    const metaEmbedded = await BlockPackMetaEmbed.parseAsync(
+    const metaEmbedded = await BlockPackMetaEmbedAbsoluteBase64.parseAsync(
       BlockPackMetaDescription(modulePath).parse(descriptionRaw.meta)
     );
 

package/src/cmd/publish.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { OclifLoggerAdapter } from '@milaboratories/ts-helpers-oclif';
 import { ManifestFileName } from '../v2/registry/schema_public';
 import { BlockPackManifest } from '@milaboratories/pl-model-middle-layer';
-import { storageByUrl } from '../lib/storage';
+import { storageByUrl } from '../io/storage';
 import { BlockRegistryV2 } from '../v2/registry/registry';
 import path from 'node:path';
 

package/src/io/folder_reader.test.ts

@@ -0,0 +1,21 @@
+import { expect, test } from '@jest/globals';
+import { folderReaderByUrl } from './folder_reader';
+
+test('test fs reader', async () => {
+  const reader = folderReaderByUrl('file:.');
+  const content = await reader.getContentReader()('package.json');
+  expect(content).toBeDefined();
+  expect(content.length).toBeGreaterThan(10);
+});
+
+test('test url reader with slash', async () => {
+  const reader = folderReaderByUrl('https://cdn.milaboratory.com/');
+  const content = await reader.getContentReader()('ping');
+  expect(content?.toString('utf8')).toStrictEqual('pong');
+});
+
+test('test url reader without slash', async () => {
+  const reader = folderReaderByUrl('https://cdn.milaboratory.com');
+  const content = await reader.getContentReader()('ping');
+  expect(content?.toString('utf8')).toStrictEqual('pong');
+});

package/src/io/folder_reader.ts

@@ -0,0 +1,85 @@
+import { Agent, Dispatcher, request } from 'undici';
+import { RelativeContentReader } from '../v2';
+import path from 'node:path';
+import pathPosix from 'node:path/posix';
+import fsp from 'node:fs/promises';
+
+export interface FolderReader {
+  readonly rootUrl: URL;
+  relativeReader(relativePath: string): FolderReader;
+  readFile(file: string): Promise<Buffer>;
+  getContentReader(relativePath?: string): RelativeContentReader;
+}
+
+class HttpFolderReader implements FolderReader {
+  constructor(
+    public readonly rootUrl: URL,
+    private readonly httpDispatcher: Dispatcher
+  ) {}
+
+  public async readFile(file: string): Promise<Buffer> {
+    const targetUrl = new URL(file, this.rootUrl);
+    const response = await request(targetUrl, {
+      dispatcher: this.httpDispatcher
+    });
+    return Buffer.from(await response.body.arrayBuffer());
+  }
+
+  public relativeReader(relativePath: string): HttpFolderReader {
+    return new HttpFolderReader(new URL(relativePath, this.rootUrl), this.httpDispatcher);
+  }
+
+  public getContentReader(relativePath?: string): RelativeContentReader {
+    let reader: HttpFolderReader = this;
+    if (relativePath !== undefined) reader = reader.relativeReader(relativePath);
+    return (path) => reader.readFile(path);
+  }
+}
+
+class FSFolderReader implements FolderReader {
+  constructor(
+    public readonly rootUrl: URL,
+    private readonly root: string
+  ) {}
+
+  public async readFile(file: string): Promise<Buffer> {
+    const targetPath = path.join(this.root, ...file.split(pathPosix.sep));
+    return await fsp.readFile(targetPath);
+  }
+
+  public relativeReader(relativePath: string): FSFolderReader {
+    return new FSFolderReader(
+      new URL(relativePath, this.rootUrl),
+      path.join(this.root, ...relativePath.split(pathPosix.sep))
+    );
+  }
+
+  public getContentReader(relativePath?: string): RelativeContentReader {
+    let reader: FSFolderReader = this;
+    if (relativePath !== undefined) reader = reader.relativeReader(relativePath);
+    return (path) => reader.readFile(path);
+  }
+}
+
+function posixToLocalPath(p: string): string {
+  return p.split(pathPosix.sep).join(path.sep);
+}
+
+function localToPosix(p: string): string {
+  return p.split(path.sep).join(pathPosix.sep);
+}
+
+export function folderReaderByUrl(address: string, httpDispatcher?: Dispatcher): FolderReader {
+  if (!address.endsWith('/')) address = address + '/';
+  const url = new URL(address, `file:${localToPosix(path.resolve('.'))}/`);
+  switch (url.protocol) {
+    case 'file:':
+      const rootPath = posixToLocalPath(url.pathname);
+      return new FSFolderReader(url, rootPath);
+    case 'https:':
+    case 'http:':
+      return new HttpFolderReader(url, httpDispatcher ?? new Agent());
+    default:
+      throw new Error(`Unknown protocol: ${url.protocol}`);
+  }
+}

package/src/io/index.ts

@@ -0,0 +1,2 @@
+export * from './folder_reader';
+export * from './storage';

package/src/lib.ts

@@ -1,2 +1,3 @@
 export * as RegistryV1 from './registry_v1';
+export * from './io';
 export * from './v2';

package/src/registry_v1/config.ts

@@ -8,7 +8,7 @@ import {
 } from './config_schema';
 import * as os from 'node:os';
 import { BlockRegistry } from './registry';
-import { storageByUrl } from '../lib/storage';
+import { storageByUrl } from '../io/storage';
 import { FullBlockPackageName } from './v1_repo_schema';
 import { MiLogger } from '@milaboratories/ts-helpers';
 

package/src/registry_v1/registry.test.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
-import { RegistryStorage, S3Storage, storageByUrl } from '../lib/storage';
+import { RegistryStorage, storageByUrl } from '../io';
 import fs from 'node:fs';
 import { BlockRegistry } from './registry';
 import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';

package/src/registry_v1/registry.ts

@@ -1,4 +1,4 @@
-import { RegistryStorage } from '../lib/storage';
+import { RegistryStorage } from '../io/storage';
 import { randomUUID } from 'node:crypto';
 import semver from 'semver';
 import {

package/src/registry_v1/v1_repo_schema.ts

@@ -36,7 +36,7 @@ export interface GlobalOverviewEntry {
   package: string;
   allVersions: string[];
   latestVersion: string;
-  latestMeta: object;
+  latestMeta: any;
 }
 
 export type GlobalOverview = GlobalOverviewEntry[];

package/src/util.ts

@@ -23,3 +23,9 @@ export async function tryStat(path: string): Promise<BigIntStats | undefined> {
     throw error;
   }
 }
+
+export async function calculateSha256(bytes: ArrayBuffer) {
+  return Buffer.from(await crypto.subtle.digest('sha-256', bytes))
+    .toString('hex')
+    .toUpperCase();
+}

package/src/v2/build_dist.ts

@@ -7,6 +7,7 @@ import {
 import { BlockPackDescriptionAbsolute, BlockPackDescriptionConsolidateToFolder } from './model';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
+import { calculateSha256 } from '../util';
 
 export async function buildBlockPackDist(
   description: BlockPackDescriptionAbsolute,
@@ -19,7 +20,7 @@ export async function buildBlockPackDist(
   const filesForManifest = await Promise.all(
     files.map(async (f): Promise<ManifestFileInfo> => {
       const bytes = await fsp.readFile(path.resolve(dst, f));
-      const sha256 = Buffer.from(await crypto.subtle.digest('sha-256', bytes)).toString('hex');
+      const sha256 = await calculateSha256(bytes);
       return { name: f, size: bytes.length, sha256 };
     })
   );

package/src/v2/index.ts

@@ -1,3 +1,4 @@
 export * from './model';
 export * from './build_dist';
 export * from './source_package';
+export * from './registry';

package/src/v2/model/block_components.ts

@@ -9,7 +9,9 @@ import {
   BlockComponents,
   BlockComponentsManifest,
   ContentAbsoluteBinaryLocal,
-  ContentAbsoluteFolder
+  ContentAbsoluteFolder,
+  ContentRelative,
+  mapRemoteToAbsolute
 } from '@milaboratories/pl-model-middle-layer';
 
 export function BlockComponentsDescription(moduleRoot: string) {
@@ -27,10 +29,10 @@ export function BlockComponentsConsolidate(dstFolder: string, fileAccumulator?:
   ).pipe(BlockComponentsManifest);
 }
 
-// export function BlockComponentsAbsoluteUrl(prefix: string) {
-//   return BlockComponents(
-//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
-//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
-//   );
-// }
-// export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;
+export function BlockComponentsAbsoluteUrl(prefix: string) {
+  return BlockComponents(
+    ContentRelative.transform(mapRemoteToAbsolute(prefix)),
+    ContentRelative.transform(mapRemoteToAbsolute(prefix))
+  );
+}
+export type BlockComponentsAbsoluteUrl = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;

package/src/v2/model/block_meta.ts

@@ -1,16 +1,23 @@
 import {
   BlockPackMeta,
-  BlockPackMetaEmbeddedContent,
+  BlockPackMetaEmbeddedBase64,
+  BlockPackMetaEmbeddedBytes,
   ContentAbsoluteBinaryLocal,
   ContentAbsoluteTextLocal,
+  ContentRelativeBinary,
+  ContentRelativeText,
   DescriptionContentBinary,
   DescriptionContentText
 } from '@milaboratories/pl-model-middle-layer';
 import {
   absoluteToBase64,
+  absoluteToBytes,
   absoluteToString,
   cpAbsoluteToRelative,
-  mapLocalToAbsolute
+  mapLocalToAbsolute,
+  RelativeContentReader,
+  relativeToContentString,
+  relativeToExplicitBytes
 } from './content_conversion';
 import { z } from 'zod';
 
@@ -29,8 +36,19 @@ export function BlockPackMetaConsolidate(dstFolder: string, fileAccumulator?: st
   );
 }
 
-export const BlockPackMetaEmbed = BlockPackMeta(
+export const BlockPackMetaEmbedAbsoluteBase64 = BlockPackMeta(
   ContentAbsoluteTextLocal.transform(absoluteToString()),
   ContentAbsoluteBinaryLocal.transform(absoluteToBase64())
-).pipe(BlockPackMetaEmbeddedContent);
-export type BlockPackMetaEmbed = z.infer<typeof BlockPackMetaEmbed>;
+).pipe(BlockPackMetaEmbeddedBase64);
+
+export const BlockPackMetaEmbedAbsoluteBytes = BlockPackMeta(
+  ContentAbsoluteTextLocal.transform(absoluteToString()),
+  ContentAbsoluteBinaryLocal.transform(absoluteToBytes())
+).pipe(BlockPackMetaEmbeddedBytes);
+
+export function BlockPackMetaEmbedBytes(reader: RelativeContentReader) {
+  return BlockPackMeta(
+    ContentRelativeText.transform(relativeToContentString(reader)),
+    ContentRelativeBinary.transform(relativeToExplicitBytes(reader))
+  ).pipe(BlockPackMetaEmbeddedBytes);
+}

package/src/v2/model/content_conversion.ts

@@ -122,6 +122,28 @@ export function absoluteToBase64(): (
   };
 }
 
+export function absoluteToBytes(): (
+  value: ContentAbsoluteBinaryLocal
+) => Promise<ContentExplicitBytes> {
+  return async (value) => {
+    if (value.type === 'absolute-file') {
+      const mimeType = mime.lookup(value.file);
+      if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.file}.`);
+      return {
+        type: 'explicit-bytes',
+        mimeType,
+        content: Buffer.from(await fsp.readFile(value.file))
+      };
+    } else if (value.type === 'explicit-base64') {
+      return {
+        type: 'explicit-bytes',
+        mimeType: value.mimeType,
+        content: Buffer.from(value.content, 'base64')
+      };
+    } else return value;
+  };
+}
+
 export function cpAbsoluteToRelative(
   dstFolder: string,
   fileAccumulator?: string[]
@@ -162,7 +184,7 @@ export function packFolderToRelativeTgz(
 
 export type RelativeContentReader = (relativePath: string) => Promise<Buffer>;
 
-export function relativeToExplicitText(
+export function relativeToExplicitString(
   reader: RelativeContentReader
 ): (value: ContentRelativeText) => Promise<ContentExplicitString> {
   return async (value) =>
@@ -171,6 +193,13 @@ export function relativeToExplicitText(
       : { type: 'explicit-string', content: (await reader(value.path)).toString('utf8') };
 }
 
+export function relativeToContentString(
+  reader: RelativeContentReader
+): (value: ContentRelativeText) => Promise<string> {
+  return async (value) =>
+    value.type === 'explicit-string' ? value.content : (await reader(value.path)).toString('utf8');
+}
+
 export function relativeToExplicitBinary64(
   reader: RelativeContentReader
 ): (value: ContentRelativeBinary) => Promise<ContentExplicitBase64> {

package/src/v2/registry/index.ts

@@ -0,0 +1,3 @@
+export * from './registry'
+export * from './registry_reader'
+export * from './schema_public'

package/src/v2/registry/registry.ts

@@ -1,6 +1,6 @@
 import { MiLogger } from '@milaboratories/ts-helpers';
 import { compare as compareSemver, satisfies } from 'semver';
-import { RegistryStorage } from '../../lib/storage';
+import { RegistryStorage } from '../../io/storage';
 import { BlockPackIdNoVersion, BlockPackManifest } from '@milaboratories/pl-model-middle-layer';
 import {
   GlobalUpdateSeedInFile,
@@ -20,6 +20,7 @@ import {
 } from './schema_public';
 import { BlockPackDescriptionManifestAddRelativePathPrefix, RelativeContentReader } from '../model';
 import { randomUUID } from 'node:crypto';
+import { calculateSha256 } from '../../util';
 
 type PackageUpdateInfo = {
   package: BlockPackIdNoVersion;
@@ -75,7 +76,7 @@ export class BlockRegistryV2 {
       // reading existing overview
       const overviewFile = packageOverviewPath(packageInfo.package);
       const pOverviewContent = await this.storage.getFile(overviewFile);
-      let packageOverview: PackageOverview =
+      const packageOverview: PackageOverview =
         pOverviewContent === undefined
           ? { schema: 'v2', versions: [] }
           : PackageOverview.parse(JSON.parse(pOverviewContent.toString()));
@@ -85,7 +86,7 @@ export class BlockRegistryV2 {
 
       // removing versions that we will update
       const newVersions = packageOverview.versions.filter(
-        (e) => !packageInfo.versions.has(e.id.version)
+        (e) => !packageInfo.versions.has(e.description.id.version)
       );
 
       // reading new entries
@@ -98,15 +99,19 @@ export class BlockRegistryV2 {
           }) + ManifestSuffix
         );
         if (!manifestContent) continue; // absent package
-        newVersions.push(
-          BlockPackDescriptionManifestAddRelativePathPrefix(version).parse(
+        const sha256 = await calculateSha256(manifestContent);
+        newVersions.push({
+          description: BlockPackDescriptionManifestAddRelativePathPrefix(version).parse(
             BlockPackManifest.parse(JSON.parse(manifestContent.toString('utf8'))).description
-          )
-        );
+          ),
+          manifestSha256: sha256
+        });
       }
 
       // sorting entries according to version
-      newVersions.sort((e1, e2) => compareSemver(e2.id.version, e1.id.version));
+      newVersions.sort((e1, e2) =>
+        compareSemver(e2.description.id.version, e1.description.id.version)
+      );
 
       // write package overview back
       await this.storage.putFile(
@@ -128,10 +133,11 @@ export class BlockRegistryV2 {
           organization: packageInfo.package.organization,
           name: packageInfo.package.name
         },
-        allVersions: newVersions.map((e) => e.id.version).reverse(),
-        latest: BlockPackDescriptionManifestAddRelativePathPrefix(packageInfo.package.name).parse(
-          newVersions[0]
-        )
+        allVersions: newVersions.map((e) => e.description.id.version).reverse(),
+        latest: BlockPackDescriptionManifestAddRelativePathPrefix(
+          `${packageInfo.package.organization}/${packageInfo.package.name}`
+        ).parse(newVersions[0].description),
+        latestManifestSha256: newVersions[0].manifestSha256
       });
     }
 
@@ -204,9 +210,7 @@ export class BlockRegistryV2 {
         throw new Error(
           `Actual file size don't match file size from the manifest file for ${f.name} (actual = ${bytes.length}; manifest = ${f.size})`
         );
-      const sha256 = Buffer.from(await crypto.subtle.digest('sha-256', bytes))
-        .toString('hex')
-        .toUpperCase();
+      const sha256 = await calculateSha256(bytes);
       if (sha256 !== f.sha256.toUpperCase())
         throw new Error(
           `Actual file SHA-256 don't match the checksum from the manifest file for ${f.name} (actual = ${sha256}; manifest = ${f.sha256.toUpperCase()})`

package/src/v2/registry/registry_reader.ts

@@ -0,0 +1,81 @@
+import {
+  BlockPackId,
+  BlockPackManifest,
+  BlockPackMetaEmbeddedBytes,
+  BlockPackOverview
+} from '@milaboratories/pl-model-middle-layer';
+import { FolderReader } from '../../io';
+import canonicalize from 'canonicalize';
+import {
+  GlobalOverviewEntryReg,
+  GlobalOverviewFileName,
+  GlobalOverviewReg,
+  MainPrefix,
+  ManifestFileName,
+  packageContentPrefix,
+  packageContentPrefixInsideV2
+} from './schema_public';
+import { BlockComponentsAbsoluteUrl, BlockPackMetaEmbedBytes } from '../model';
+
+export type BlockPackOverviewNoRegLabel = Omit<BlockPackOverview, 'registryId'>;
+
+export class RegistryV2Reader {
+  private readonly metaCache = new Map<
+    string,
+    { sha256: string; meta: BlockPackMetaEmbeddedBytes }
+  >();
+
+  private readonly v2RootFolderReader: FolderReader;
+
+  constructor(private readonly registryReader: FolderReader) {
+    this.v2RootFolderReader = registryReader.relativeReader(MainPrefix);
+  }
+
+  private async embedMetaContent(
+    entry: GlobalOverviewEntryReg
+  ): Promise<BlockPackMetaEmbeddedBytes> {
+    const id = canonicalize(entry.id)!;
+    const fromCache = this.metaCache.get(id);
+    if (fromCache && fromCache.sha256 === entry.latestManifestSha256) return fromCache.meta;
+    const rootContentReader = this.v2RootFolderReader.getContentReader();
+    const meta = await BlockPackMetaEmbedBytes(rootContentReader).parseAsync(entry.latest.meta);
+    this.metaCache.set(id, { sha256: entry.latestManifestSha256, meta });
+    return meta;
+  }
+
+  public async listBlockPacks(): Promise<BlockPackOverviewNoRegLabel[]> {
+    const rootContentReader = this.v2RootFolderReader.getContentReader();
+    const globalOverview = GlobalOverviewReg.parse(
+      JSON.parse(
+        Buffer.from(await this.v2RootFolderReader.readFile(GlobalOverviewFileName)).toString()
+      )
+    );
+    return await Promise.all(
+      globalOverview.packages.map(
+        async (p) =>
+          ({
+            id: p.latest.id,
+            meta: await this.embedMetaContent(p),
+            spec: {
+              type: 'from-registry-v2',
+              id: p.latest.id,
+              registryUrl: this.registryReader.rootUrl.toString()
+            },
+            otherVersions: p.allVersions
+          }) satisfies BlockPackOverviewNoRegLabel
+      )
+    );
+  }
+
+  public async getComponents(id: BlockPackId): Promise<BlockComponentsAbsoluteUrl> {
+    const packageFolderReader = this.v2RootFolderReader.relativeReader(
+      packageContentPrefixInsideV2(id)
+    );
+    const manifest = BlockPackManifest.parse(
+      JSON.parse(Buffer.from(await packageFolderReader.readFile(ManifestFileName)).toString())
+    );
+    return BlockComponentsAbsoluteUrl(packageFolderReader.rootUrl.toString()).parse(
+      manifest.description.components
+    );
+  }
+}