@platforma-sdk/block-tools 2.1.11 → 2.3.0

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

@@ -0,0 +1 @@
+{"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,oBAAoB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED,eAAO,MAAM,cAAc,QAAyB,CAAC;AAMrD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiF+kR,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;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAmkB,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;;;;;;;;;EA9E/sb,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEtF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2E2lR,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;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAmkB,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;;;;;;;;;;EAxE/sb,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqDolR,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;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAmkB,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;;;;;;;;;EArD1nb,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCylR,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;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAmkB,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;;;;;;;;;;EAzCpob,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.1.11",
+  "version": "2.3.0",
   "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.2.20",
-    "@milaboratories/ts-helpers": "^1.0.26",
-    "@milaboratories/ts-helpers-oclif": "^1.1.4"
+    "@milaboratories/resolve-helper": "^1.0.1",
+    "@milaboratories/pl-model-middle-layer": "^1.4.0",
+    "@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/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/index.ts

@@ -1,6 +1,7 @@
 import BuildMeta from './build-meta';
 import BuildModel from './build-model';
 import PackBlock from './pack-block';
+import Publish from './publish';
 import UploadPackageV1 from './upload-package-v1';
 
 // prettier-ignore
@@ -9,4 +10,5 @@ export const COMMANDS = {
   'pack': PackBlock,
   'build-model': BuildModel,
   'build-meta': BuildMeta,
+  'publish': Publish,
 };

package/src/cmd/publish.ts

@@ -0,0 +1,69 @@
+import { Command, Flags } from '@oclif/core';
+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 '../io/storage';
+import { BlockRegistryV2 } from '../v2/registry/registry';
+import path from 'node:path';
+
+export default class Publish extends Command {
+  static description =
+    'Publishes the block package and refreshes the registry (for v2 block-pack schema)';
+
+  static flags = {
+    registry: Flags.string({
+      char: 'r',
+      summary: 'full address of the registry',
+      helpValue: '<address>',
+      env: 'PL_REGISTRY',
+      required: true
+    }),
+
+    manifest: Flags.file({
+      char: 'm',
+      summary: 'manifest file path',
+      exists: true,
+      default: `./block-pack/${ManifestFileName}`
+    }),
+
+    refresh: Flags.boolean({
+      summary: 'refresh repository after adding the package',
+      default: true,
+      allowNo: true,
+      env: 'PL_REGISTRY_REFRESH'
+    })
+  };
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(Publish);
+
+    // if (flags.meta) {
+    //   if (flags.meta.endsWith('.json'))
+    //     configFromFlags.meta = JSON.parse(
+    //       await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
+    //     );
+    //   else if (flags.meta.endsWith('.yaml'))
+    //     configFromFlags.meta = YAML.parse(
+    //       await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
+    //     );
+    // }
+
+    const manifestPath = path.resolve(flags.manifest);
+    const manifest = BlockPackManifest.parse(
+      JSON.parse(await fs.promises.readFile(manifestPath, { encoding: 'utf-8' }))
+    );
+    const manifestRoot = path.dirname(manifestPath);
+
+    this.log(`Manifest root = ${manifestRoot}`);
+
+    const storage = storageByUrl(flags.registry);
+    const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
+
+    await registry.publishPackage(manifest, async (file) =>
+      Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file)))
+    );
+
+    if (flags.refresh) await registry.updateIfNeeded();
+  }
+}

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,77 @@
+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 {
+  relativeReader(relativePath: string): FolderReader;
+  readFile(file: string): Promise<Buffer>;
+  getContentReader(relativePath?: string): RelativeContentReader;
+}
+
+export class HttpFolderReader implements FolderReader {
+  constructor(
+    private readonly root: URL,
+    private readonly httpDispatcher: Dispatcher
+  ) {}
+
+  public async readFile(file: string): Promise<Buffer> {
+    const targetUrl = new URL(file, this.root);
+    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.root), this.httpDispatcher);
+  }
+
+  public getContentReader(relativePath?: string): RelativeContentReader {
+    let reader: HttpFolderReader = this;
+    if (relativePath !== undefined) reader = reader.relativeReader(relativePath);
+    return (path) => reader.readFile(path);
+  }
+}
+
+export class FSFolderReader implements FolderReader {
+  constructor(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(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 {
+  const url = new URL(address, `file:${localToPosix(path.resolve('.'))}/`);
+  switch (url.protocol) {
+    case 'file:':
+      const root = posixToLocalPath(url.pathname);
+      return new FSFolderReader(root);
+    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/v2/build_dist.ts

@@ -1,13 +1,11 @@
 import {
-  BlockPackDescriptionAbsolute,
-  BlockPackDescriptionConsolidateToFolder,
   BlockPackDescriptionManifest,
   BlockPackManifest,
-  BlockPackManifestFile
-} from './model';
+  BlockPackManifestFile,
+  ManifestFileInfo
+} from '@milaboratories/pl-model-middle-layer';
+import { BlockPackDescriptionAbsolute, BlockPackDescriptionConsolidateToFolder } from './model';
 import fsp from 'node:fs/promises';
-import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './model/meta';
-import { patch } from 'semver';
 import path from 'node:path';
 
 export async function buildBlockPackDist(
@@ -16,14 +14,20 @@ export async function buildBlockPackDist(
 ): Promise<BlockPackManifest> {
   await fsp.mkdir(dst, { recursive: true });
   const files: string[] = [];
-  const descriptionRelative = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(
-    description
+  const descriptionRelative: BlockPackDescriptionManifest =
+    await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(description);
+  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');
+      return { name: f, size: bytes.length, sha256 };
+    })
   );
   const manifest: BlockPackManifest = BlockPackManifest.parse({
-    schema: 'v1',
-    ...descriptionRelative,
-    files
-  });
+    schema: 'v2',
+    description: descriptionRelative,
+    files: filesForManifest
+  } satisfies BlockPackManifest);
   await fsp.writeFile(path.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
   return manifest;
 }

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

@@ -3,10 +3,14 @@ import {
   ResolvedModuleFile,
   ResolvedModuleFolder,
   packFolderToRelativeTgz,
-  cpAbsoluteToRelative,
-  mapRemoteToAbsolute,
+  cpAbsoluteToRelative
 } from './content_conversion';
-import { BlockComponents, BlockComponentsManifest, ContentAbsoluteBinaryLocal, ContentAbsoluteFolder, ContentRelativeBinary } from '@milaboratories/pl-model-middle-layer';
+import {
+  BlockComponents,
+  BlockComponentsManifest,
+  ContentAbsoluteBinaryLocal,
+  ContentAbsoluteFolder
+} from '@milaboratories/pl-model-middle-layer';
 
 export function BlockComponentsDescription(moduleRoot: string) {
   return BlockComponents(
@@ -23,10 +27,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(
+//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
+//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
+//   );
+// }
+// export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;

package/src/v2/model/block_description.ts

@@ -0,0 +1,49 @@
+import {
+  addPrefixToRelative,
+  BlockComponents,
+  BlockPackDescriptionManifest,
+  BlockPackMeta,
+  ContentRelative,
+  ContentRelativeBinary,
+  ContentRelativeText,
+  CreateBlockPackDescriptionSchema
+} from '@milaboratories/pl-model-middle-layer';
+import { BlockComponentsConsolidate, BlockComponentsDescription } from './block_components';
+import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './block_meta';
+import { z } from 'zod';
+
+export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
+  return CreateBlockPackDescriptionSchema(
+    BlockComponentsDescription(root),
+    BlockPackMetaDescription(root)
+  );
+}
+export type BlockPackDescriptionAbsolute = z.infer<
+  ReturnType<typeof ResolvedBlockPackDescriptionFromPackageJson>
+>;
+
+export function BlockPackDescriptionConsolidateToFolder(
+  dstFolder: string,
+  fileAccumulator?: string[]
+) {
+  return CreateBlockPackDescriptionSchema(
+    BlockComponentsConsolidate(dstFolder, fileAccumulator),
+    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
+  ).pipe(BlockPackDescriptionManifest);
+}
+
+export function BlockPackDescriptionManifestAddRelativePathPrefix(prefix: string) {
+  const transformer = addPrefixToRelative(prefix);
+  return BlockPackDescriptionManifest.pipe(
+    CreateBlockPackDescriptionSchema(
+      BlockComponents(
+        ContentRelative.transform(transformer),
+        ContentRelative.transform(transformer)
+      ),
+      BlockPackMeta(
+        ContentRelativeText.transform(transformer),
+        ContentRelativeBinary.transform(transformer)
+      )
+    )
+  ).pipe(BlockPackDescriptionManifest);
+}

package/src/v2/model/{meta.ts → block_meta.ts}

@@ -1,18 +1,25 @@
 import {
   BlockPackMeta,
+  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';
-import { BlockPackMetaEmbeddedContent } from '@milaboratories/pl-model-middle-layer';
 
 export function BlockPackMetaDescription(root: string) {
   return BlockPackMeta(
@@ -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

@@ -8,10 +8,13 @@ import {
   ContentAbsoluteFile,
   ContentAbsoluteFolder,
   ContentAbsoluteTextLocal,
-  ContentAbsoluteUrl,
   ContentAnyLocal,
   ContentExplicitBase64,
-  ContentRelative
+  ContentExplicitBytes,
+  ContentExplicitString,
+  ContentRelative,
+  ContentRelativeBinary,
+  ContentRelativeText
 } from '@milaboratories/pl-model-middle-layer';
 import { tryResolve } from '@milaboratories/resolve-helper';
 
@@ -119,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[]
@@ -157,12 +182,55 @@ export function packFolderToRelativeTgz(
   };
 }
 
-export function mapRemoteToAbsolute(
-  rootUrl: string
-): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {
-  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;
-  return <T extends ContentAnyLocal>(value: T) =>
-    value.type === 'relative'
-      ? { type: 'absolute-url', url: rootWithSlash + value.path }
-      : (value as Exclude<T, ContentRelative>);
+export type RelativeContentReader = (relativePath: string) => Promise<Buffer>;
+
+export function relativeToExplicitString(
+  reader: RelativeContentReader
+): (value: ContentRelativeText) => Promise<ContentExplicitString> {
+  return async (value) =>
+    value.type === 'explicit-string'
+      ? value
+      : { 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> {
+  return async (value) => {
+    if (value.type === 'explicit-base64') return value;
+    const mimeType = mime.lookup(value.path);
+    if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.path}.`);
+    return {
+      type: 'explicit-base64',
+      mimeType,
+      content: (await reader(value.path)).toString('base64')
+    };
+  };
+}
+
+export function relativeToExplicitBytes(
+  reader: RelativeContentReader
+): (value: ContentRelativeBinary) => Promise<ContentExplicitBytes> {
+  return async (value) => {
+    if (value.type === 'explicit-base64')
+      return {
+        type: 'explicit-bytes',
+        mimeType: value.mimeType,
+        content: Buffer.from(value.content, 'base64')
+      };
+    const mimeType = mime.lookup(value.path);
+    if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.path}.`);
+    return {
+      type: 'explicit-bytes',
+      mimeType,
+      content: await reader(value.path)
+    };
+  };
 }

package/src/v2/model/index.ts

@@ -1,46 +1,5 @@
-import { z } from 'zod';
-import { BlockComponentsConsolidate, BlockComponentsDescription } from './block_components';
-import {
-  BlockComponentsManifest,
-  BlockPackMetaManifest,
-  CreateBlockPackDescriptionSchema
-} from '@milaboratories/pl-model-middle-layer';
-import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './meta';
-
-export * from './block_components';
 export * from './content_conversion';
 
-export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsDescription(root),
-    BlockPackMetaDescription(root)
-  );
-}
-export type BlockPackDescriptionAbsolute = z.infer<
-  ReturnType<typeof ResolvedBlockPackDescriptionFromPackageJson>
->;
-
-export function BlockPackDescriptionConsolidateToFolder(
-  dstFolder: string,
-  fileAccumulator?: string[]
-) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsConsolidate(dstFolder, fileAccumulator),
-    //BlockPackMetaToExplicit
-    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
-  ).pipe(BlockPackDescriptionManifest);
-}
-
-export const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(
-  BlockComponentsManifest,
-  BlockPackMetaManifest
-);
-export type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;
-
-export const BlockPackManifest = BlockPackDescriptionManifest.extend({
-  schema: z.literal('v1'),
-  files: z.array(z.string())
-});
-export type BlockPackManifest = z.infer<typeof BlockPackManifest>;
-
-export const BlockPackManifestFile = 'manifest.json';
+export * from './block_meta';
+export * from './block_components';
+export * from './block_description';

package/src/v2/registry/index.ts

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