@platforma-sdk/block-tools 2.8.4 → 2.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.8.4",
+  "version": "2.9.1",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "license": "UNLICENSED",
   "bin": {
@@ -32,14 +32,14 @@
     "undici": "~7.16.0",
     "yaml": "^2.8.0",
     "zod": "~3.25.76",
-    "@milaboratories/pl-http": "1.2.4",
+    "@milaboratories/pl-model-backend": "1.3.4",
     "@milaboratories/pl-model-common": "1.42.0",
-    "@milaboratories/pl-model-middle-layer": "1.21.0",
-    "@milaboratories/pl-model-backend": "1.3.3",
-    "@milaboratories/ts-helpers-oclif": "1.1.41",
+    "@milaboratories/pl-http": "1.2.4",
     "@milaboratories/resolve-helper": "1.1.3",
+    "@milaboratories/pl-model-middle-layer": "1.22.0",
     "@milaboratories/ts-helpers": "1.8.2",
-    "@platforma-sdk/blocks-deps-updater": "2.2.0"
+    "@platforma-sdk/blocks-deps-updater": "2.2.0",
+    "@milaboratories/ts-helpers-oclif": "1.1.41"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
@@ -56,8 +56,8 @@
     "vitest": "^4.1.3",
     "@milaboratories/build-configs": "2.0.0",
     "@milaboratories/oclif-index": "1.1.1",
-    "@milaboratories/ts-configs": "1.2.3",
-    "@milaboratories/ts-builder": "1.5.0"
+    "@milaboratories/ts-builder": "1.5.0",
+    "@milaboratories/ts-configs": "1.2.3"
   },
   "oclif": {
     "bin": "block-tools",

package/src/cmd/build-meta.ts

@@ -2,7 +2,7 @@ import { Command, Flags } from "@oclif/core";
 import path from "node:path";
 import fs from "node:fs";
 import { loadPackDescriptionRaw } from "../v2";
-import { BlockPackMetaDescription, BlockPackMetaEmbedAbsoluteBase64 } from "../v2/model/block_meta";
+import { embedBlockPackMetaAbsoluteBase64, resolveBlockPackMeta } from "../v2/model/block_meta";
 
 export default class BuildMeta extends Command {
   static override description =
@@ -29,8 +29,8 @@ 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 BlockPackMetaEmbedAbsoluteBase64.parseAsync(
-      BlockPackMetaDescription(modulePath).parse(descriptionRaw.meta),
+    const metaEmbedded = await embedBlockPackMetaAbsoluteBase64(
+      await resolveBlockPackMeta(descriptionRaw.meta, modulePath),
     );
 
     await fs.promises.writeFile(path.resolve(flags.destination), JSON.stringify(metaEmbedded));

package/src/v2/build_dist.ts

@@ -5,7 +5,7 @@ import type {
 import { BlockPackManifest, BlockPackManifestFile } from "@milaboratories/pl-model-middle-layer";
 import type { CompiledTemplateV3 } from "@milaboratories/pl-model-backend";
 import type { BlockPackDescriptionAbsolute } from "./model";
-import { BlockPackDescriptionConsolidateToFolder } from "./model";
+import { consolidateBlockPackDescription } from "./model";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { gunzipSync } from "node:zlib";
@@ -23,8 +23,8 @@ async function workflowRequiredCapabilities(
   descriptionRelative: BlockPackDescriptionManifest,
   dst: string,
 ): Promise<string[] | undefined> {
-  // After BlockPackDescriptionConsolidateToFolder runs, components.workflow.main
-  // is always a {type: "relative", path: ...} reference into dst.
+  // After consolidateBlockPackDescription runs, components.workflow.main is
+  // always a `{type: "relative", path: ...}` reference into `dst`.
   const main = descriptionRelative.components.workflow.main;
   const bytes = await fsp.readFile(path.resolve(dst, main.path));
 
@@ -47,8 +47,11 @@ export async function buildBlockPackDist(
 ): Promise<BlockPackManifest> {
   await fsp.mkdir(dst, { recursive: true });
   const files: string[] = [];
-  const descriptionRelative: BlockPackDescriptionManifest =
-    await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(description);
+  const descriptionRelative: BlockPackDescriptionManifest = await consolidateBlockPackDescription(
+    description,
+    dst,
+    files,
+  );
 
   // Per-block capability detection: mirror the workflow's
   // compile-time-computed `requiredCapabilities` onto the published

package/src/v2/model/block_components.ts

@@ -1,38 +1,87 @@
-import type { z } from "zod";
-import {
-  ResolvedModuleFile,
-  ResolvedModuleFolder,
-  packFolderToRelativeTgz,
-  cpAbsoluteToRelative,
-} from "./content_conversion";
-import {
+import type {
   BlockComponents,
+  BlockComponentsDescriptionRaw,
   BlockComponentsManifest,
-  ContentAbsoluteBinaryLocal,
+  ContentAbsoluteFile,
   ContentAbsoluteFolder,
-  ContentRelative,
-  mapRemoteToAbsolute,
+  ContentAbsoluteUrl,
 } from "@milaboratories/pl-model-middle-layer";
+import { mapRemoteToAbsolute } from "@milaboratories/pl-model-middle-layer";
+import {
+  cpAbsoluteToRelative,
+  packFolderToRelativeTgz,
+  resolveModuleFile,
+  resolveModuleFolder,
+} from "./content_conversion";
+
+/**
+ * Resolved BlockComponents — workflow main and model resolved to absolute
+ * file references, UI request resolved to its absolute folder.
+ */
+export type BlockComponentsDescription = BlockComponents<
+  ContentAbsoluteFile,
+  ContentAbsoluteFolder
+>;
+
+/** BlockComponents pointing at registry-served URLs. */
+export type BlockComponentsAbsoluteUrl = BlockComponents<ContentAbsoluteUrl, ContentAbsoluteUrl>;
 
-export function BlockComponentsDescription(moduleRoot: string) {
-  return BlockComponents(
-    ResolvedModuleFile(moduleRoot),
-    ResolvedModuleFolder(moduleRoot, "index.html"),
-  );
+/**
+ * Resolves block-components paths from `package.json` raw form against the
+ * module root. Workflow and model strings are resolved via node module
+ * resolution; the UI request resolves to a folder containing `index.html`.
+ */
+export function resolveBlockComponents(
+  raw: BlockComponentsDescriptionRaw,
+  moduleRoot: string,
+): BlockComponentsDescription {
+  return {
+    workflow: {
+      type: "workflow-v1",
+      main: resolveModuleFile(moduleRoot, raw.workflow.main),
+    },
+    model: resolveModuleFile(moduleRoot, raw.model),
+    ui: resolveModuleFolder(moduleRoot, raw.ui, ["index.html"]),
+  };
 }
-export type BlockComponentsDescription = z.infer<ReturnType<typeof BlockComponentsDescription>>;
 
-export function BlockComponentsConsolidate(dstFolder: string, fileAccumulator?: string[]) {
-  return BlockComponents(
-    ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
-    ContentAbsoluteFolder.transform(packFolderToRelativeTgz(dstFolder, "ui.tgz", fileAccumulator)),
-  ).pipe(BlockComponentsManifest);
+/**
+ * Copies file references for workflow and model into `dstFolder`, packs the
+ * UI folder into `ui.tgz`, returning the manifest form with relative paths.
+ */
+export async function consolidateBlockComponents(
+  description: BlockComponentsDescription,
+  dstFolder: string,
+  fileAccumulator?: string[],
+): Promise<BlockComponentsManifest> {
+  const cpToRel = cpAbsoluteToRelative(dstFolder, fileAccumulator);
+  const packToTgz = packFolderToRelativeTgz(dstFolder, "ui.tgz", fileAccumulator);
+  return {
+    workflow: {
+      type: "workflow-v1",
+      main: await cpToRel(description.workflow.main),
+    },
+    model: await cpToRel(description.model),
+    ui: await packToTgz(description.ui),
+  };
 }
 
-export function BlockComponentsAbsoluteUrl(prefix: string) {
-  return BlockComponents(
-    ContentRelative.transform(mapRemoteToAbsolute(prefix)),
-    ContentRelative.transform(mapRemoteToAbsolute(prefix)),
-  );
+/**
+ * Maps a manifest with relative paths to one with absolute URLs against the
+ * given prefix. Used by the registry reader to point components at registry
+ * storage.
+ */
+export function blockComponentsManifestToAbsoluteUrl(
+  manifest: BlockComponentsManifest,
+  prefix: string,
+): BlockComponentsAbsoluteUrl {
+  const toAbs = mapRemoteToAbsolute(prefix);
+  return {
+    workflow: {
+      type: "workflow-v1",
+      main: toAbs(manifest.workflow.main),
+    },
+    model: toAbs(manifest.model),
+    ui: toAbs(manifest.ui),
+  };
 }
-export type BlockComponentsAbsoluteUrl = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;

package/src/v2/model/block_description.ts

@@ -1,63 +1,122 @@
-import {
-  addPrefixToRelative,
-  BlockComponents,
+import type {
+  BlockPackDescription,
   BlockPackDescriptionManifest,
-  BlockPackMeta,
-  ContentRelative,
-  ContentRelativeBinary,
-  ContentRelativeText,
-  CreateBlockPackDescriptionSchema,
+  BlockPackDescriptionRaw,
 } from "@milaboratories/pl-model-middle-layer";
-import { BlockComponentsConsolidate, BlockComponentsDescription } from "./block_components";
-import { BlockPackMetaConsolidate, BlockPackMetaDescription } from "./block_meta";
-import type { z } from "zod";
-import fsp from "node:fs/promises";
+import { addPrefixToRelative } from "@milaboratories/pl-model-middle-layer";
 import type { BlockConfigContainer } from "@milaboratories/pl-model-common";
 import { extractConfigGeneric } from "@milaboratories/pl-model-common";
+import fsp from "node:fs/promises";
+import type { BlockComponentsDescription } from "./block_components";
+import { consolidateBlockComponents, resolveBlockComponents } from "./block_components";
+import type { BlockPackMetaDescription } from "./block_meta";
+import { consolidateBlockPackMeta, resolveBlockPackMeta } from "./block_meta";
 
-export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsDescription(root),
-    BlockPackMetaDescription(root),
-  ).transform(async (description, _ctx) => {
-    const cfg = extractConfigGeneric(
-      JSON.parse(
-        await fsp.readFile(description.components.model.file, "utf-8"),
-      ) as BlockConfigContainer,
-    );
-    const featureFlags = cfg.featureFlags;
-    return {
-      ...description,
-      featureFlags,
-    };
-  });
-}
-export type BlockPackDescriptionAbsolute = z.infer<
-  ReturnType<typeof ResolvedBlockPackDescriptionFromPackageJson>
+/** Resolved block-pack description — components + meta point at absolute file paths. */
+export type BlockPackDescriptionAbsolute = BlockPackDescription<
+  BlockComponentsDescription,
+  BlockPackMetaDescription
 >;
 
-export function BlockPackDescriptionConsolidateToFolder(
+/**
+ * Resolves a raw `package.json`-form block-pack description against the
+ * module root: workflow/model/ui paths via node module resolution, text and
+ * binary fields in `meta` via `mapLocalToAbsolute`. Reads the resolved model
+ * file to extract feature flags from its `BlockConfigContainer`.
+ */
+export async function resolveBlockPackDescription(
+  raw: BlockPackDescriptionRaw,
+  root: string,
+): Promise<BlockPackDescriptionAbsolute> {
+  const components = resolveBlockComponents(raw.components, root);
+  const meta = await resolveBlockPackMeta(raw.meta, root);
+  const cfg = extractConfigGeneric(
+    JSON.parse(await fsp.readFile(components.model.file, "utf-8")) as BlockConfigContainer,
+  );
+  return {
+    ...raw,
+    components,
+    meta,
+    featureFlags: cfg.featureFlags,
+  };
+}
+
+/**
+ * Consolidates absolute references in components and meta into `dstFolder`
+ * (copying files and packing the UI as `ui.tgz`), returning the manifest
+ * form with relative paths.
+ */
+export async function consolidateBlockPackDescription(
+  description: BlockPackDescriptionAbsolute,
   dstFolder: string,
   fileAccumulator?: string[],
-) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsConsolidate(dstFolder, fileAccumulator),
-    BlockPackMetaConsolidate(dstFolder, fileAccumulator),
-  ).pipe(BlockPackDescriptionManifest);
+): Promise<BlockPackDescriptionManifest> {
+  const components = await consolidateBlockComponents(
+    description.components,
+    dstFolder,
+    fileAccumulator,
+  );
+  const meta = await consolidateBlockPackMeta(description.meta, dstFolder, fileAccumulator);
+  return {
+    ...description,
+    components,
+    meta,
+  };
+}
+
+/**
+ * Maps `components` and `meta` of a `BlockPackDescription` independently,
+ * preserving every other top-level field (including the `BlockPackId` and
+ * any passthrough siblings). Sync counterpart to the schema-driven async
+ * pipelines in `block_meta.ts`/`block_components.ts`; used by callers that
+ * need a synchronous transform (e.g. relative-path rewriting).
+ */
+function transformBlockPackDescription<Cin, Min, Cout, Mout>(
+  description: BlockPackDescription<Cin, Min>,
+  mapComponents: (components: Cin) => Cout,
+  mapMeta: (meta: Min) => Mout,
+): BlockPackDescription<Cout, Mout> {
+  return {
+    ...description,
+    components: mapComponents(description.components),
+    meta: mapMeta(description.meta),
+  };
 }
 
-export function BlockPackDescriptionManifestAddRelativePathPrefix(prefix: string) {
+/**
+ * Prefixes every relative-path field in a manifest description with the
+ * given path prefix (components workflow/model/ui plus meta text/binary
+ * fields).
+ */
+export function addRelativePathPrefix(
+  manifest: BlockPackDescriptionManifest,
+  prefix: string,
+): BlockPackDescriptionManifest {
   const transformer = addPrefixToRelative(prefix);
-  return BlockPackDescriptionManifest.pipe(
-    CreateBlockPackDescriptionSchema(
-      BlockComponents(
-        ContentRelative.transform(transformer),
-        ContentRelative.transform(transformer),
-      ),
-      BlockPackMeta(
-        ContentRelativeText.transform(transformer),
-        ContentRelativeBinary.transform(transformer),
-      ),
-    ),
-  ).pipe(BlockPackDescriptionManifest);
+  return transformBlockPackDescription(
+    manifest,
+    (components) => ({
+      workflow: {
+        type: "workflow-v1",
+        main: transformer(components.workflow.main),
+      },
+      model: transformer(components.model),
+      ui: transformer(components.ui),
+    }),
+    (meta) => {
+      const { logo: orgLogo, ...orgRest } = meta.organization;
+      return {
+        ...meta,
+        organization: {
+          ...orgRest,
+          ...(orgLogo !== undefined ? { logo: transformer(orgLogo) } : {}),
+        },
+        ...(meta.longDescription !== undefined
+          ? { longDescription: transformer(meta.longDescription) }
+          : {}),
+        ...(meta.changelog !== undefined ? { changelog: transformer(meta.changelog) } : {}),
+        ...(meta.logo !== undefined ? { logo: transformer(meta.logo) } : {}),
+      };
+    },
+  );
 }

package/src/v2/model/block_meta.ts

@@ -1,13 +1,11 @@
-import {
+import type {
   BlockPackMeta,
+  BlockPackMetaDescriptionRaw,
   BlockPackMetaEmbeddedBase64,
   BlockPackMetaEmbeddedBytes,
+  BlockPackMetaManifest,
   ContentAbsoluteBinaryLocal,
   ContentAbsoluteTextLocal,
-  ContentRelativeBinary,
-  ContentRelativeText,
-  DescriptionContentBinary,
-  DescriptionContentText,
 } from "@milaboratories/pl-model-middle-layer";
 import type { RelativeContentReader } from "./content_conversion";
 import {
@@ -19,36 +17,118 @@ import {
   relativeToContentString,
   relativeToExplicitBytes,
 } from "./content_conversion";
-import type { z } from "zod";
 
-export function BlockPackMetaDescription(root: string) {
-  return BlockPackMeta(
-    DescriptionContentText.transform(mapLocalToAbsolute(root)),
-    DescriptionContentBinary.transform(mapLocalToAbsolute(root)),
-  );
+/** Resolved BlockPackMeta — text/binary references mapped to absolute file refs. */
+export type BlockPackMetaDescription = BlockPackMeta<
+  ContentAbsoluteTextLocal,
+  ContentAbsoluteBinaryLocal
+>;
+
+/**
+ * Applies independent transforms to BlockPackMeta's text-content and
+ * binary-content fields (`longDescription`, `changelog`, `logo`,
+ * `organization.logo`). All other fields, including unknown passthrough keys,
+ * pass through unchanged.
+ *
+ * Spread order matters: `...meta` first preserves every key (including
+ * passthrough); the conditional spreads at the end override the four
+ * transformed fields. Reading bottom-up: the per-field spreads win over
+ * the bulk spread.
+ */
+async function transformBlockPackMeta<LongStringIn, BinaryIn, LongStringOut, BinaryOut>(
+  meta: BlockPackMeta<LongStringIn, BinaryIn>,
+  mapText: (value: LongStringIn) => Promise<LongStringOut>,
+  mapBinary: (value: BinaryIn) => Promise<BinaryOut>,
+): Promise<BlockPackMeta<LongStringOut, BinaryOut>> {
+  const { organization } = meta;
+  const { logo: orgLogo, ...orgRest } = organization;
+  const out = {
+    ...meta,
+    organization: {
+      ...orgRest,
+      ...(orgLogo !== undefined ? { logo: await mapBinary(orgLogo) } : {}),
+    },
+    ...(meta.longDescription !== undefined
+      ? { longDescription: await mapText(meta.longDescription) }
+      : {}),
+    ...(meta.changelog !== undefined ? { changelog: await mapText(meta.changelog) } : {}),
+    ...(meta.logo !== undefined ? { logo: await mapBinary(meta.logo) } : {}),
+  };
+  return out as BlockPackMeta<LongStringOut, BinaryOut>;
 }
-export type BlockPackMetaDescription = z.infer<ReturnType<typeof BlockPackMetaDescription>>;
 
-export function BlockPackMetaConsolidate(dstFolder: string, fileAccumulator?: string[]) {
-  return BlockPackMeta(
-    ContentAbsoluteTextLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
-    ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
+/**
+ * Resolves text/binary references in raw BlockPackMeta (post-`package.json`
+ * normalization) to absolute file paths against the module root.
+ */
+export async function resolveBlockPackMeta(
+  raw: BlockPackMetaDescriptionRaw,
+  root: string,
+): Promise<BlockPackMetaDescription> {
+  const toAbs = mapLocalToAbsolute(root);
+  return transformBlockPackMeta(
+    raw,
+    async (v) => toAbs(v),
+    async (v) => toAbs(v),
   );
 }
 
-export const BlockPackMetaEmbedAbsoluteBase64 = BlockPackMeta(
-  ContentAbsoluteTextLocal.transform(absoluteToString()),
-  ContentAbsoluteBinaryLocal.transform(absoluteToBase64()),
-).pipe(BlockPackMetaEmbeddedBase64);
+/**
+ * Copies absolute text/binary file references into `dstFolder` and returns
+ * the manifest form with relative paths.
+ */
+export async function consolidateBlockPackMeta(
+  meta: BlockPackMetaDescription,
+  dstFolder: string,
+  fileAccumulator?: string[],
+): Promise<BlockPackMetaManifest> {
+  const cpToRel = cpAbsoluteToRelative(dstFolder, fileAccumulator);
+  return transformBlockPackMeta(
+    meta,
+    async (v) => cpToRel(v),
+    async (v) => cpToRel(v),
+  ) as Promise<BlockPackMetaManifest>;
+}
+
+/**
+ * Reads absolute file references and embeds the content as in-line strings
+ * and base64-encoded binary blobs.
+ */
+export async function embedBlockPackMetaAbsoluteBase64(
+  meta: BlockPackMetaDescription,
+): Promise<BlockPackMetaEmbeddedBase64> {
+  return transformBlockPackMeta(
+    meta,
+    absoluteToString(),
+    absoluteToBase64(),
+  ) as Promise<BlockPackMetaEmbeddedBase64>;
+}
 
-export const BlockPackMetaEmbedAbsoluteBytes = BlockPackMeta(
-  ContentAbsoluteTextLocal.transform(absoluteToString()),
-  ContentAbsoluteBinaryLocal.transform(absoluteToBytes()),
-).pipe(BlockPackMetaEmbeddedBytes);
+/**
+ * Reads absolute file references and embeds the content as in-line strings
+ * and raw byte arrays.
+ */
+export async function embedBlockPackMetaAbsoluteBytes(
+  meta: BlockPackMetaDescription,
+): Promise<BlockPackMetaEmbeddedBytes> {
+  return transformBlockPackMeta(
+    meta,
+    absoluteToString(),
+    absoluteToBytes(),
+  ) as Promise<BlockPackMetaEmbeddedBytes>;
+}
 
-export function BlockPackMetaEmbedBytes(reader: RelativeContentReader) {
-  return BlockPackMeta(
-    ContentRelativeText.transform(relativeToContentString(reader)),
-    ContentRelativeBinary.transform(relativeToExplicitBytes(reader)),
-  ).pipe(BlockPackMetaEmbeddedBytes);
+/**
+ * Reads relative-path references through the given content reader and embeds
+ * the content as in-line strings and raw byte arrays.
+ */
+export async function embedBlockPackMetaBytes(
+  manifest: BlockPackMetaManifest,
+  reader: RelativeContentReader,
+): Promise<BlockPackMetaEmbeddedBytes> {
+  return transformBlockPackMeta(
+    manifest,
+    relativeToContentString(reader),
+    relativeToExplicitBytes(reader),
+  ) as Promise<BlockPackMetaEmbeddedBytes>;
 }

package/src/v2/model/content_conversion.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import path from "node:path";
 import fsp from "node:fs/promises";
 import * as mime from "mime-types";
@@ -33,60 +32,36 @@ type ContentCtxUrl = {
 /** Describes a place relative to which any content references should be interpreted */
 export type ContentCtx = ContentCtxFs | ContentCtxUrl;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- utility function for future use
-function mustResolve(root: string, request: string): string {
-  const res = tryResolve(root, request);
-  if (res === undefined) throw new Error(`Can't resolve ${request} against ${root}`);
-  return res;
-}
-
-/** Zod type that resolves node module request into absolute content */
-export function ResolvedModuleFile(moduleRoot: string) {
-  return z.string().transform<ContentAbsoluteFile>((request, ctx) => {
-    const result = tryResolve(moduleRoot, request);
-    if (result === undefined) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Can't resolve ${request} against ${moduleRoot}`,
-      });
-      return z.NEVER;
-    }
-    return {
-      type: "absolute-file",
-      file: result,
-    };
-  });
+/** Resolves a node module request to an absolute file reference. */
+export function resolveModuleFile(moduleRoot: string, request: string): ContentAbsoluteFile {
+  const result = tryResolve(moduleRoot, request);
+  if (result === undefined) throw new Error(`Can't resolve ${request} against ${moduleRoot}`);
+  return { type: "absolute-file", file: result };
 }
 
 /**
- * Zod type that resolves node module request for folder into absolute folder,
- * given a list of expected index files in that folder
- * */
-export function ResolvedModuleFolder(
+ * Resolves a node module request for a folder to an absolute folder reference,
+ * given a list of expected index file names in that folder.
+ */
+export function resolveModuleFolder(
   moduleRoot: string,
-  ...indexFilesToLookFor: [string, ...string[]]
-) {
-  return z.string().transform<ContentAbsoluteFolder>((request, ctx) => {
-    const requestWithSlash = request.endsWith("/") ? request : `${request}/`;
-
-    for (const idxFile of indexFilesToLookFor) {
-      const result = tryResolve(moduleRoot, requestWithSlash + idxFile);
-      if (result !== undefined) {
-        if (!result.endsWith(idxFile))
-          throw new Error(`Unexpected resolve result ${result} with index file ${idxFile}`);
-        return {
-          type: "absolute-folder",
-          folder: result.slice(0, result.length - idxFile.length),
-        };
-      }
-    }
-
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(", ")})`,
-    });
-    return z.NEVER;
-  });
+  request: string,
+  indexFilesToLookFor: [string, ...string[]],
+): ContentAbsoluteFolder {
+  const requestWithSlash = request.endsWith("/") ? request : `${request}/`;
+  for (const idxFile of indexFilesToLookFor) {
+    const result = tryResolve(moduleRoot, requestWithSlash + idxFile);
+    if (result === undefined) continue;
+    if (!result.endsWith(idxFile))
+      throw new Error(`Unexpected resolve result ${result} with index file ${idxFile}`);
+    return {
+      type: "absolute-folder",
+      folder: result.slice(0, result.length - idxFile.length),
+    };
+  }
+  throw new Error(
+    `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(", ")})`,
+  );
 }
 
 export function mapLocalToAbsolute(