@platforma-sdk/package-builder-lib 1.4.0 → 1.4.2

package/dist/core/push-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"push-guard.d.ts","names":[],"sources":["../../src/core/push-guard.ts"],"mappings":";YAeY;;EAEV;;EAEA;;EAEA;;EAEA;;;wBAIc,uBAAuB,QAAQ"}
+{"version":3,"file":"push-guard.d.ts","names":[],"sources":["../../src/core/push-guard.ts"],"mappings":"A,YAeY;;EAEV;;EAEA;;EAEA;;EAEA;;;wBAIc,uBAAuB,QAAQ"}

package/dist/core/push-guard.js

@@ -1,6 +1,6 @@
 import { PL_DOCKER_NO_AUTOPUSH, isCI } from "./envs.js";
 import { CLIError } from "./util.js";
-//#region src/core/push-guard.ts
+// src/core/push-guard.ts
 /** Throws when a CI run is about to reference docker images it never pushed. */
 function assertDockerPushIntent(intent) {
 	if (!isCI()) return;
@@ -11,7 +11,6 @@ function assertDockerPushIntent(intent) {
   The usual cause is "private": true in package.json: auto-push is gated on !isPrivate, and software packages must never be private.
   If this package really must build images without publishing them, say so with --docker-no-autopush (or ${PL_DOCKER_NO_AUTOPUSH}=1).`);
 }
-//#endregion
 export { assertDockerPushIntent };
 
 //# sourceMappingURL=push-guard.js.map

package/dist/core/resolver.cjs

@@ -5,7 +5,7 @@ let node_fs = require("node:fs");
 node_fs = require_runtime.__toESM(node_fs, 1);
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path, 1);
-//#region src/core/resolver.ts
+// src/core/resolver.ts
 const compiledSoftwareSuffix = ".sw.json";
 const compiledAssetSuffix = ".as.json";
 function descriptorFilePath(packageRoot, entrypointType, entrypointName) {
@@ -92,7 +92,6 @@ function resolveRunEnvironment(logger, packageRoot, packageName, envName, requir
 			throw new Error("renderer logic error: resolveRunEnvironment does not cover all run environment types");
 	}
 }
-//#endregion
 exports.compiledAssetSuffix = compiledAssetSuffix;
 exports.compiledSoftwareSuffix = compiledSoftwareSuffix;
 exports.descriptorFilePath = descriptorFilePath;

package/dist/core/resolver.js

@@ -2,7 +2,7 @@ import { CLIError, assertNever, findInstalledModule, formatZodIssues, rSplit } f
 import { swJsonSchema } from "./schemas/sw-json.js";
 import fs from "node:fs";
 import path from "node:path";
-//#region src/core/resolver.ts
+// src/core/resolver.ts
 const compiledSoftwareSuffix = ".sw.json";
 const compiledAssetSuffix = ".as.json";
 function descriptorFilePath(packageRoot, entrypointType, entrypointName) {
@@ -89,7 +89,6 @@ function resolveRunEnvironment(logger, packageRoot, packageName, envName, requir
 			throw new Error("renderer logic error: resolveRunEnvironment does not cover all run environment types");
 	}
 }
-//#endregion
 export { compiledAssetSuffix, compiledSoftwareSuffix, descriptorFilePath, readDescriptorFile, readSwJsonFile, resolveDependency, resolveRunEnvironment };
 
 //# sourceMappingURL=resolver.js.map

package/dist/core/schemas/artifacts.cjs

@@ -1,7 +1,7 @@
 const require_defaults = require("../../defaults.cjs");
 const require_util = require("../util.cjs");
 let zod_v4 = require("zod/v4");
-//#region src/core/schemas/artifacts.ts
+// src/core/schemas/artifacts.ts
 const artifactTypes = [
 	"asset",
 	"environment",
@@ -116,7 +116,6 @@ const anyArtifactSchema = zod_v4.z.discriminatedUnion("type", [
 	dockerSchema
 ]);
 const artifactIndexSchema = zod_v4.z.record(zod_v4.z.string(), anyArtifactSchema);
-//#endregion
 exports.anyArtifactSchema = anyArtifactSchema;
 exports.archiveArtifactTypes = archiveArtifactTypes;
 exports.artifactIDSchema = artifactIDSchema;

package/dist/core/schemas/artifacts.d.ts

@@ -1,52 +1,13 @@
-import { ArchType, util_d_exports } from "../util.js";
+import "../util.js";
 import { z } from "zod/v4";
-declare namespace artifacts_d_exports {
-  export { anyArtifactSchema, anyArtifactType, archiveArtifactTypes, archiveRules, artifactIDSchema, artifactIDString, artifactIndexSchema, artifactIndexType, artifactType, artifactTypes, assetSchema, assetType, binarySchema, binaryType, condaSchema, condaType, crossplatformTypes, dockerArchitectures, dockerAutogenTypes, dockerSchema, dockerType, environmentSchema, environmentType, isBuildable, isCrossPlatform, javaSchema, javaType, pythonSchema, pythonToolsetName, pythonToolsetSchema, pythonToolsets, pythonType, rSchema, rType, registry, registryOrRef, registrySchema, runEnvironmentType, runEnvironmentTypes, withId, withType };
-}
 export declare const artifactTypes: readonly ["asset", "environment", "binary", "java", "python", "R", "docker", "conda"];
 export type artifactType = (typeof artifactTypes)[number];
-export declare const archiveArtifactTypes: artifactType[];
-export declare const crossplatformTypes: artifactType[];
-export declare const dockerAutogenTypes: artifactType[];
-export declare const dockerArchitectures: ArchType[];
-export declare function isBuildable(aType: artifactType): boolean;
-export declare function isCrossPlatform(aType: artifactType): boolean;
-export declare const runEnvironmentTypes: readonly ["java", "python", "R"];
-export type runEnvironmentType = (typeof runEnvironmentTypes)[number];
-export declare const pythonToolsets: readonly ["pip"];
-export type pythonToolsetName = (typeof pythonToolsets)[number];
 export declare const registrySchema: z.ZodObject<{
   name: z.ZodString;
   downloadURL: z.ZodOptional<z.ZodString>;
   storageURL: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type registry = z.infer<typeof registrySchema>;
-export declare const registryOrRef: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-  name: z.ZodString;
-  downloadURL: z.ZodOptional<z.ZodString>;
-  storageURL: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>]>;
-declare const archiveRulesSchema: z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  root: z.ZodString;
-  roots: z.ZodRecord<z.ZodEnum<{
-    "linux-aarch64": "linux-aarch64";
-    "linux-x64": "linux-x64";
-    "macosx-aarch64": "macosx-aarch64";
-    "macosx-x64": "macosx-x64";
-    "windows-aarch64": "windows-aarch64";
-    "windows-x64": "windows-x64";
-  }> & z.core.$partial, z.ZodString>;
-}, z.core.$strip>;
-export type archiveRules = z.infer<typeof archiveRulesSchema>;
-export declare const artifactIDSchema: z.ZodString;
-export type artifactIDString = z.infer<typeof artifactIDSchema>;
 export declare const assetSchema: z.ZodObject<{
   registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     name: z.ZodString;
@@ -120,10 +81,6 @@ export declare const javaSchema: z.ZodObject<{
   environment: z.ZodString;
 }, z.core.$strip>;
 export type javaType = z.infer<typeof javaSchema>;
-export declare const pythonToolsetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  toolset: z.ZodLiteral<"pip">;
-  requirements: z.ZodString;
-}, z.core.$strict>]>;
 export declare const pythonSchema: z.ZodObject<{
   registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     name: z.ZodString;
@@ -311,135 +268,10 @@ export declare const anyArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   pkg: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>]>;
 export type anyArtifactType = z.infer<typeof anyArtifactSchema>;
-export declare const artifactIndexSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  root: z.ZodString;
-  type: z.ZodLiteral<"asset">;
-}, z.core.$strict>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  roots: z.ZodRecord<z.ZodEnum<{
-    "linux-aarch64": "linux-aarch64";
-    "linux-x64": "linux-x64";
-    "macosx-aarch64": "macosx-aarch64";
-    "macosx-x64": "macosx-x64";
-    "windows-aarch64": "windows-aarch64";
-    "windows-x64": "windows-x64";
-  }> & z.core.$partial, z.ZodString>;
-  type: z.ZodLiteral<"environment">;
-  runtime: z.ZodEnum<{
-    R: "R";
-    java: "java";
-    python: "python";
-  }>;
-  "r-version": z.ZodOptional<z.ZodString>;
-  "python-version": z.ZodOptional<z.ZodString>;
-  "java-version": z.ZodOptional<z.ZodString>;
-  envVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  binDir: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  roots: z.ZodRecord<z.ZodEnum<{
-    "linux-aarch64": "linux-aarch64";
-    "linux-x64": "linux-x64";
-    "macosx-aarch64": "macosx-aarch64";
-    "macosx-x64": "macosx-x64";
-    "windows-aarch64": "windows-aarch64";
-    "windows-x64": "windows-x64";
-  }> & z.core.$partial, z.ZodString>;
-  type: z.ZodLiteral<"binary">;
-}, z.core.$strip>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  root: z.ZodString;
-  type: z.ZodLiteral<"java">;
-  environment: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  root: z.ZodString;
-  "docker-registry": z.ZodDefault<z.ZodString>;
-  pkg: z.ZodDefault<z.ZodString>;
-  type: z.ZodLiteral<"python">;
-  environment: z.ZodString;
-  dependencies: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-    toolset: z.ZodLiteral<"pip">;
-    requirements: z.ZodString;
-  }, z.core.$strict>]>>;
-}, z.core.$strip>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  root: z.ZodString;
-  type: z.ZodLiteral<"R">;
-  environment: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    downloadURL: z.ZodOptional<z.ZodString>;
-    storageURL: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>;
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  roots: z.ZodRecord<z.ZodEnum<{
-    "linux-aarch64": "linux-aarch64";
-    "linux-x64": "linux-x64";
-    "macosx-aarch64": "macosx-aarch64";
-    "macosx-x64": "macosx-x64";
-    "windows-aarch64": "windows-aarch64";
-    "windows-x64": "windows-x64";
-  }> & z.core.$partial, z.ZodString>;
-  "docker-registry": z.ZodDefault<z.ZodString>;
-  pkg: z.ZodDefault<z.ZodString>;
-  type: z.ZodLiteral<"conda">;
-  "micromamba-version": z.ZodDefault<z.ZodString>;
-  "conda-root-dir": z.ZodDefault<z.ZodString>;
-  spec: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-  type: z.ZodLiteral<"docker">;
-  registry: z.ZodDefault<z.ZodString>;
-  context: z.ZodString;
-  dockerfile: z.ZodDefault<z.ZodString>;
-  pkg: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>]>>;
-export type artifactIndexType = z.infer<typeof artifactIndexSchema>;
 export type withType<Typ, Orig> = Orig & {
   type: Typ;
 };
 export type withId<T> = T & {
   id: string;
 };
-//#endregion
-export { artifacts_d_exports };
 //# sourceMappingURL=artifacts.d.ts.map

package/dist/core/schemas/artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifacts.d.ts","names":[],"sources":["../../../src/core/schemas/artifacts.ts"],"mappings":";;;;;qBAKa;YAUD,uBAAuB;qBAGtB,sBAAsB;qBAStB,oBAAoB;qBACpB,oBAAoB;qBACpB,qBAAqB;wBAElB,YAAY,OAAO;wBAKnB,gBAAgB,OAAO;qBAI1B;YACD,6BAA6B;qBAE5B;YACD,4BAA4B;qBAE3B,gBAAc,EAAA;;;;;YAKf,WAAW,EAAE,aAAa;qBAEzB,eAAa,EAAA,mBAAA,EAAA,WAAA,EAAA;;;;;cAIpB,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;YA0CZ,eAAe,EAAE,aAAa;qBAmB7B,kBAAgB,EAAA;YAQjB,mBAAmB,EAAE,aAAa;qBAEjC,aAAW,EAAA;;;;;;;;;;;YAIZ,YAAY,EAAE,aAAa;qBAE1B,mBAAiB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6BlB,kBAAkB,EAAE,aAAa;qBAEhC,cAAY,EAAA;;;;;;;;;;;;;;;;;;YAGb,aAAa,EAAE,aAAa;qBAE3B,YAAU,EAAA;;;;;;;;;;;;YAIX,WAAW,EAAE,aAAa;qBAOzB,qBAAmB,EAAA,uBAAA,EAAA;;;;qBAEnB,cAAY,EAAA;;;;;;;;;;;;;;;;;;YASb,aAAa,EAAE,aAAa;qBAE3B,SAAO,EAAA;;;;;;;;;;;;YAIR,QAAQ,EAAE,aAAa;qBAEtB,aAAW,EAAA;;;;;;;;;;;;;;;;;;;;;;;YAoBZ,YAAY,EAAE,aAAa;qBAE1B,cAAY,EAAA;;;;;;;YAqCb,aAAa,EAAE,aAAa;qBAE3B,mBAAiB,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAWlB,kBAAkB,EAAE,aAAa;qBAEhC,qBAAmB,EAAA,UAAA,EAAA,WAAA,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YACpB,oBAAoB,EAAE,aAAa;YAEnC,SAAS,KAAK,QAAQ;EAAS,MAAM;;YACrC,OAAO,KAAK;EAAM"}
+{"version":3,"file":"artifacts.d.ts","names":[],"sources":["../../../src/core/schemas/artifacts.ts"],"mappings":";;qBAKa;YAUD,uBAAuB;qBA+BtB,gBAAc,EAAA;;;;GAIzB,EAAA,KAAA;YACU,WAAW,EAAE,aAAa;qBA6EzB,aAAW,EAAA;;;;;;;;;;GAGb,EAAA,KAAA;YACC,YAAY,EAAE,aAAa;qBAE1B,mBAAiB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2B5B,EAAA,KAAA;YAEU,kBAAkB,EAAE,aAAa;qBAEhC,cAAY,EAAA;;;;;;;;;;;;;;;;;GAEvB,EAAA,KAAA;YACU,aAAa,EAAE,aAAa;qBAE3B,YAAU,EAAA;;;;;;;;;;;GAGrB,EAAA,KAAA;YACU,WAAW,EAAE,aAAa;qBASzB,cAAY,EAAA;;;;;;;;;;;;;;;;;GAQrB,EAAA,KAAA;YACQ,aAAa,EAAE,aAAa;qBAE3B,SAAO,EAAA;;;;;;;;;;;GAGlB,EAAA,KAAA;YACU,QAAQ,EAAE,aAAa;qBAEtB,aAAW,EAAA;;;;;;;;;;;;;;;;;;;;;;GAmBpB,EAAA,KAAA;YACQ,YAAY,EAAE,aAAa;qBAE1B,cAAY,EAAA;;;;;;GAoCvB,EAAA,KAAA;YACU,aAAa,EAAE,aAAa;qBAE3B,mBAAiB,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAS5B,EAAA,KAAA;YAEU,kBAAkB,EAAE,aAAa;YAKjC,SAAS,KAAK,QAAQ;EAAS,MAAM;;YACrC,OAAO,KAAK;EAAM"}

package/dist/core/schemas/artifacts.js

@@ -1,7 +1,7 @@
 import { BIN_REGISTRY_DOWNLOAD_URL, BIN_REGISTRY_NAME, CONDA_DATA_LOCATION, CONDA_MICROMAMBA_VERSION, CONDA_SOURCE_ENV_SPEC_FILE, DOCKER_DOCKERFILE, DOCKER_PLACEHOLDER_PKG, DOCKER_REGISTRY } from "../../defaults.js";
 import { AllPlatforms } from "../util.js";
 import { z } from "zod/v4";
-//#region src/core/schemas/artifacts.ts
+// src/core/schemas/artifacts.ts
 const artifactTypes = [
 	"asset",
 	"environment",
@@ -116,7 +116,6 @@ const anyArtifactSchema = z.discriminatedUnion("type", [
 	dockerSchema
 ]);
 const artifactIndexSchema = z.record(z.string(), anyArtifactSchema);
-//#endregion
 export { anyArtifactSchema, archiveArtifactTypes, artifactIDSchema, artifactIndexSchema, artifactTypes, assetSchema, binarySchema, condaSchema, crossplatformTypes, dockerAutogenTypes, dockerSchema, environmentSchema, isBuildable, isCrossPlatform, javaSchema, pythonSchema, pythonToolsetSchema, rSchema, registryOrRef, registrySchema, runEnvironmentTypes };
 
 //# sourceMappingURL=artifacts.js.map

package/dist/core/schemas/entrypoints.cjs

@@ -1,7 +1,7 @@
 const require_util = require("../util.cjs");
 const require_artifacts = require("./artifacts.cjs");
 let zod_v4 = require("zod/v4");
-//#region src/core/schemas/entrypoints.ts
+// src/core/schemas/entrypoints.ts
 const envVarsSchema = zod_v4.z.array(zod_v4.z.string().regex(/=/, "full environment variable specification is required: <var-name>=<var-value>, e.g.: IS_CI=yes"));
 const EnyrypointReferencePattern = /^(?<fullName>(?:(?<scope>@[a-z0-9-.]+)\/)?(?<name>[a-z0-9-.]+))\/(?<path>.*)$/;
 const referenceSchema = zod_v4.z.string().regex(EnyrypointReferencePattern, "entrypoint reference must contain full package name and path to the file inside");
@@ -35,7 +35,6 @@ const entrypointSchema = zod_v4.z.strictObject({
 	path: ["reference | asset | binary | environment | docker"]
 });
 const entrypointListSchema = zod_v4.z.record(zod_v4.z.string().regex(/[-_a-z0-9.]/).describe("name of entrypoint descriptor, client should import to use this entrypoint (assets.importSoftware)"), entrypointSchema);
-//#endregion
 exports.EnyrypointReferencePattern = EnyrypointReferencePattern;
 exports.entrypointListSchema = entrypointListSchema;
 exports.entrypointSchema = entrypointSchema;