@helios-lang/contract-utils 0.2.82 → 0.3.1

package/src/cast/UserFunc.js

@@ -1,46 +1,35 @@
 import { bytesToHex } from "@helios-lang/codec-utils"
-import { expectSome, isLeft, isString, None } from "@helios-lang/type-utils"
-import { ConstrData, UplcDataValue, UplcRuntimeError } from "@helios-lang/uplc"
-import { Cast } from "./Cast.js"
+import { expectDefined, isLeft, isString } from "@helios-lang/type-utils"
+import {
+    makeConstrData,
+    makeUplcDataValue,
+    UplcRuntimeError
+} from "@helios-lang/uplc"
+import { makeCast } from "./Cast.js"
 
 /**
- * @typedef {import("@helios-lang/type-utils").TypeSchema} TypeSchema
- * @typedef {import("@helios-lang/uplc").CekResult} CekResult
- * @typedef {import("@helios-lang/uplc").UplcData} UplcData
- * @typedef {import("@helios-lang/uplc").UplcLoggingI} UplcLoggingI
- * @typedef {import("@helios-lang/uplc").UplcProgram} UplcProgram
- * @typedef {import("@helios-lang/uplc").UplcValue} UplcValue
- * @typedef {import("./Cast.js").CastConfig} CastConfig
+ * @import { Either, TypeSchema } from "@helios-lang/type-utils"
+ * @import { CekResult, UplcData, UplcLogger, UplcProgram, UplcValue } from "@helios-lang/uplc"
+ * @import { Cast, CastConfig, UnsafeArgsT, UserFunc, UserFuncProps } from "../index.js"
  */
 
 /**
- * TODO: add logOptions here as well (which can be overridden by logOptions passed directly to eval(), evalUnsafe() and profile())?
- * `returns` is optional to accomodate main functions that return void
- * @typedef {{
- *   name: string
- *   requiresScriptContext: boolean
- *   requiresCurrentScript: boolean
- *   arguments: {
- *     name: string
- *     type: TypeSchema
- *     isOptional: boolean
- *   }[]
- *   returns?: TypeSchema
- *   validatorIndices?: Record<string, number>
- *   castConfig: CastConfig
- * }} UserFuncProps
- */
-
-/**
- * @template ArgsT
- * @typedef {{[K in keyof ArgsT]: K extends "$currentScript" ? string : UplcData}} UnsafeArgsT
+ * @template {{[argName: string]: any}} ArgsT
+ * @template RetT
+ * @param {UplcProgram} uplc
+ * @param {UserFuncProps} props
+ * @returns {UserFunc<ArgsT, RetT>}
  */
+export function makeUserFunc(uplc, props) {
+    return new UserFuncImpl(uplc, props)
+}
 
 /**
  * @template {{[argName: string]: any}} ArgsT
  * @template RetT
+ * @implements {UserFunc<ArgsT, RetT>}
  */
-export class UserFunc {
+class UserFuncImpl {
     /**
      * @readonly
      * @type {UplcProgram}
@@ -72,10 +61,10 @@ export class UserFunc {
 
     /**
      * @param {ArgsT} namedArgs
-     * @param {Option<UplcLoggingI>} logOptions
+     * @param {UplcLogger | undefined} logOptions
      * @returns {RetT}
      */
-    eval(namedArgs, logOptions = None) {
+    eval(namedArgs, logOptions = undefined) {
         /**
          * @type {{[argName: string]: any}}
          */
@@ -89,7 +78,7 @@ export class UserFunc {
             if (argDetails) {
                 const typeSchema = argDetails.type
 
-                unsafeNamedArgs[argName] = new Cast(
+                unsafeNamedArgs[argName] = makeCast(
                     typeSchema,
                     this.props.castConfig
                 ).toUplcData(argValue)
@@ -108,10 +97,10 @@ export class UserFunc {
         )
 
         if (this.props.returns) {
-            return new Cast(
+            return makeCast(
                 this.props.returns,
                 this.props.castConfig
-            ).fromUplcData(expectSome(/** @type {any} */ (result)))
+            ).fromUplcData(expectDefined(/** @type {any} */ (result)))
         } else {
             return /** @type {any} */ (undefined)
         }
@@ -119,10 +108,10 @@ export class UserFunc {
 
     /**
      * @param {UnsafeArgsT<ArgsT>} namedArgs
-     * @param {Option<UplcLoggingI>} logOptions
+     * @param {UplcLogger | undefined} logOptions
      * @returns {RetT extends void ? void : UplcData}
      */
-    evalUnsafe(namedArgs, logOptions = None) {
+    evalUnsafe(namedArgs, logOptions = undefined) {
         const result = this.profile(namedArgs, logOptions).result
 
         if (isLeft(result)) {
@@ -138,10 +127,10 @@ export class UserFunc {
 
     /**
      * @param {UnsafeArgsT<ArgsT>} namedArgs
-     * @param {Option<UplcLoggingI>} logOptions - optional, passed to UplcProgram.eval if provided
+     * @param {UplcLogger | undefined} logOptions - optional, passed to UplcProgram.eval if provided
      * @returns {CekResult}
      */
-    profile(namedArgs, logOptions = None) {
+    profile(namedArgs, logOptions = undefined) {
         const isMain = this.name == "main"
 
         /**
@@ -157,38 +146,38 @@ export class UserFunc {
                         args.push(namedArgs[name])
                     }
                 } else {
-                    args.push(expectSome(namedArgs[name]))
+                    args.push(expectDefined(namedArgs[name]))
                 }
             } else {
                 if (isOptional) {
                     if (name in namedArgs && namedArgs[name]) {
-                        args.push(new ConstrData(0, [namedArgs[name]]))
+                        args.push(makeConstrData(0, [namedArgs[name]]))
                     } else {
-                        args.push(new ConstrData(1, []))
+                        args.push(makeConstrData(1, []))
                     }
                 } else {
-                    args.push(expectSome(namedArgs[name]))
+                    args.push(expectDefined(namedArgs[name]))
                 }
             }
         })
 
         if (this.props.requiresScriptContext) {
-            args.push(expectSome(namedArgs["$scriptContext"]))
+            args.push(expectDefined(namedArgs["$scriptContext"]))
         }
 
         if (this.props.requiresCurrentScript) {
-            const currentScriptName = expectSome(
+            const currentScriptName = expectDefined(
                 /** @type {any} */ (namedArgs)["$currentScript"]
             )
 
-            const index = expectSome(
-                expectSome(this.props.validatorIndices)[currentScriptName]
+            const index = expectDefined(
+                expectDefined(this.props.validatorIndices)[currentScriptName]
             )
 
-            args.push(new ConstrData(index, []))
+            args.push(makeConstrData(index, []))
         }
 
-        const argValues = args.map((a) => new UplcDataValue(a))
+        const argValues = args.map((a) => makeUplcDataValue(a))
 
         const cekResult = this.uplc.eval(argValues, {
             logOptions: logOptions ?? undefined

package/src/cast/index.js

@@ -1,30 +1,3 @@
-import { Cast } from "./Cast.js"
-export { Cast }
+export { makeCast } from "./Cast.js"
 export { configureCast } from "./Cast.js"
-export { UserFunc } from "./UserFunc.js"
-
-/**
- * @typedef {import("./Cast.js").CastConfig} CastConfig
- */
-
-/**
- * @template TStrict
- * @template TPermissive
- * @typedef {import("./Cast.js").ConfigurableCast<TStrict, TPermissive>} ConfigurableCast
- */
-
-/**
- * @template TStrict
- * @template TPermissive
- * @typedef {import("./Cast.js").CastLike<TStrict, TPermissive>} CastLike
- */
-
-/**
- * @template {CastLike<any, any>} C
- * @typedef {import("./PermissiveType.js").PermissiveType<C>} PermissiveType
- */
-
-/**
- * @template {CastLike<any, any>} C
- * @typedef {import("./StrictType.js").StrictType<C>} StrictType
- */
+export { makeUserFunc } from "./UserFunc.js"

package/src/codegen/LoadedScriptsWriter.js

@@ -1,34 +1,30 @@
-import { StringWriter } from "@helios-lang/codec-utils"
-import { isSome } from "@helios-lang/type-utils"
+import { makeStringWriter } from "@helios-lang/codec-utils"
+import { isDefined as isSome } from "@helios-lang/type-utils"
 import { genTypes } from "./TypeSchema.js"
 
 /**
- * @typedef {import("./TypeCheckedModule.js").TypeCheckedModule} TypeCheckedModule
- * @typedef {import("./TypeCheckedModule.js").TypeCheckedUserFunc} TypeCheckedUserFunc
- * @typedef {import("./TypeCheckedValidator.js").TypeCheckedValidator} TypeCheckedValidator
- * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { LoadedScriptsWriter, TypeCheckedModule, TypeCheckedUserFunc, TypeCheckedValidator } from "../index.js"
  */
 
-export class LoadedScriptsWriter {
-    /**
-     * @private
-     */
-    constructor() {
-        this.definition = new StringWriter()
-        this.declaration = new StringWriter()
-        this.combined = new StringWriter()
-    }
-
-    /**
-     * Constructs a LoadedScriptsWriter instance and initializes it be writing the header
-     * @returns {LoadedScriptsWriter}
-     */
-    static new() {
-        const w = new LoadedScriptsWriter()
+/**
+ * Constructs a LoadedScriptsWriter instance and initializes it be writing the header
+ * @returns {LoadedScriptsWriter}
+ */
+export function makeLoadedScriptsWriter() {
+    return new LoadedScriptsWriterImpl()
+}
 
-        w.writeHeaders()
+/**
+ * @implements {LoadedScriptsWriter}
+ */
+class LoadedScriptsWriterImpl {
+    constructor() {
+        this.definition = makeStringWriter()
+        this.declaration = makeStringWriter()
+        this.combined = makeStringWriter()
 
-        return w
+        this.writeHeaders()
     }
 
     /**
@@ -132,31 +128,28 @@ export class LoadedScriptsWriter {
     }
 
     /**
+     * @private
      * @param {string} path
-     * @param {string} typeName
-     * @param {string[]} typeParams
+     * @param {string[]} typeNames
      * @returns {LoadedScriptsWriter}
      */
-    writeImportType(path, typeName, typeParams = []) {
+    writeImportType(path, ...typeNames) {
         this.definition.writeLine("/**")
 
-        for (let tp of typeParams) {
-            this.definition.writeLine(` * @template ${tp}`)
-        }
-
         this.definition
-            .writeLine(
-                ` * @typedef {import("${path}").${typeName}${typeParams.length > 0 ? `<${typeParams.join(", ")}>` : ""}} ${typeName}`
-            )
+            .writeLine(` * @import { ${typeNames.join(", ")} } from "${path}";`)
             .writeLine(" */")
         ;[this.declaration, this.combined].forEach((w) => {
-            w.writeLine(`import type { ${typeName} } from "${path}";`)
+            w.writeLine(
+                `import type { ${typeNames.join(", ")} } from "${path}";`
+            )
         })
 
         return this
     }
 
     /**
+     * @private
      * @param {string} path
      * @param {string[]} objectNames
      * @returns {LoadedScriptsWriter}
@@ -173,8 +166,21 @@ export class LoadedScriptsWriter {
      * @private
      */
     writeHeaders() {
-        this.writeImport("@helios-lang/contract-utils", "Cast", "UserFunc")
         this.writeImport(
+            "@helios-lang/contract-utils",
+            "makeCast",
+            "makeUserFunc"
+        )
+
+        this.writeImportType("@helios-lang/codec-utils", "IntLike")
+        this.writeImportType(
+            "@helios-lang/contract-utils",
+            "Cast",
+            "CastConfig",
+            "ConfigurableCast",
+            "UserFunc"
+        )
+        this.writeImportType(
             "@helios-lang/ledger",
             "Address",
             "AssetClass",
@@ -186,8 +192,8 @@ export class LoadedScriptsWriter {
             "ScriptHash",
             "SpendingCredential",
             "StakingCredential",
-            "StakingHash",
             "StakingValidatorHash",
+            "TimeLike",
             "TimeRange",
             "TxId",
             "TxInput",
@@ -197,19 +203,11 @@ export class LoadedScriptsWriter {
             "ValidatorHash",
             "Value"
         )
-        this.writeImportType("@helios-lang/codec-utils", "IntLike")
-        this.writeImportType("@helios-lang/contract-utils", "CastConfig")
-        this.writeImportType(
-            "@helios-lang/contract-utils",
-            "ConfigurableCast",
-            ["TStrict", "TPermissive"]
-        )
-        this.writeImportType("@helios-lang/ledger", "TimeLike")
-        this.writeImportType("@helios-lang/uplc", "UplcData")
-        this.writeImportType("@helios-lang/uplc", "UplcProgram")
+        this.writeImportType("@helios-lang/uplc", "UplcData", "UplcProgram")
     }
 
     /**
+     * @private
      * @param {Record<string, TypeSchema>} types
      */
     writeTypes(types) {
@@ -222,13 +220,13 @@ export class LoadedScriptsWriter {
             const tsTypes = genTypes(t)
 
             this.definition.write(
-                `        ${key}: (config) => /** @type {Cast<${tsTypes[0]}, ${tsTypes[1]}>} */ (new Cast(${JSON.stringify(t)}, config)),\n`
+                `        ${key}: (config) => /** @type {Cast<${tsTypes[0]}, ${tsTypes[1]}>} */ (makeCast(${JSON.stringify(t)}, config)),\n`
             )
             this.declaration.write(
                 `        ${key}: ConfigurableCast<${tsTypes[0]}, ${tsTypes[1]}>,\n`
             )
             this.combined.write(
-                `        ${key}: (config: CastConfig) => new Cast<${tsTypes[0]}, ${tsTypes[1]}>(${JSON.stringify(t)}, config),\n`
+                `        ${key}: (config: CastConfig) => makeCast<${tsTypes[0]}, ${tsTypes[1]}>(${JSON.stringify(t)}, config),\n`
             )
         }
 
@@ -238,6 +236,7 @@ export class LoadedScriptsWriter {
     }
 
     /**
+     * @private
      * @param {Record<string, TypeCheckedUserFunc>} functions
      */
     writeFunctions(functions) {
@@ -252,13 +251,13 @@ export class LoadedScriptsWriter {
             const propsStr = `{...(${JSON.stringify(fn)}), castConfig: config, validatorIndices: __validatorIndices}`
 
             this.definition.write(
-                `        "${key}": (uplc, config) => /** @type {UserFunc<${argsType}, ${retType}>} */ (new UserFunc(uplc, ${propsStr})),\n`
+                `        "${key}": (uplc, config) => /** @type {UserFunc<${argsType}, ${retType}>} */ (makeUserFunc(uplc, ${propsStr})),\n`
             )
             this.declaration.write(
                 `        "${key}": (uplc: UplcProgram, config: CastConfig) => UserFunc<${argsType}, ${retType}>,\n`
             )
             this.combined.write(
-                `        "${key}": (uplc: UplcProgram, config: CastConfig) => new UserFunc<${argsType}, ${retType}>(uplc, ${propsStr}),\n`
+                `        "${key}": (uplc: UplcProgram, config: CastConfig) => makeUserFunc<${argsType}, ${retType}>(uplc, ${propsStr}),\n`
             )
         }
 
@@ -320,8 +319,8 @@ ${isSome(currentScriptIndex) ? `    $currentScriptIndex: /** @type {const} */ ($
     $dependencies: /** @type {const} */ ([${v.moduleDepedencies.join(", ")}]),
     $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
     $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)},
-    $Redeemer: (config) => /** @type {Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>} */ (new Cast(${JSON.stringify(v.Redeemer)}, config)),
-${datumTypes ? `    $Datum: (config) => /** @type {Cast<${datumTypes[0]}, ${datumTypes[1]}>} */ (new Cast(${JSON.stringify(v.Datum)}, config)),\n` : ""}`
+    $Redeemer: (config) => /** @type {Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>} */ (makeCast(${JSON.stringify(v.Redeemer)}, config)),
+${datumTypes ? `    $Datum: (config) => /** @type {Cast<${datumTypes[0]}, ${datumTypes[1]}>} */ (makeCast(${JSON.stringify(v.Datum)}, config)),\n` : ""}`
         )
 
         this.declaration.write(
@@ -349,8 +348,8 @@ ${isSome(currentScriptIndex) ? `    $currentScriptIndex: ${currentScriptIndex} a
     $dependencies: [${v.moduleDepedencies.join(", ")}] as const,
     $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
     $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)} as boolean,
-    $Redeemer: (config: CastConfig) => new Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>(${JSON.stringify(v.Redeemer)}, config),
-${datumTypes ? `    $Datum: (config: CastConfig) => new Cast<${datumTypes[0]}, ${datumTypes[1]}>(${JSON.stringify(v.Datum)}, config),\n` : ""}`
+    $Redeemer: (config: CastConfig) => makeCast<${redeemerTypes[0]}, ${redeemerTypes[1]}>(${JSON.stringify(v.Redeemer)}, config),
+${datumTypes ? `    $Datum: (config: CastConfig) => makeCast<${datumTypes[0]}, ${datumTypes[1]}>(${JSON.stringify(v.Datum)}, config),\n` : ""}`
         )
 
         this.writeTypes(v.types)
@@ -362,6 +361,7 @@ ${datumTypes ? `    $Datum: (config: CastConfig) => new Cast<${datumTypes[0]}, $
     }
 
     /**
+     * @private
      * @param {Record<string, TypeCheckedValidator>} validators
      */
     writeValidatorIndices(validators) {

package/src/codegen/TypeSchema.js

@@ -1,8 +1,8 @@
 /**
- * @typedef {import("@helios-lang/type-utils").TypeSchema} TypeSchema
+ * @import { TypeSchema } from "@helios-lang/type-utils"
  */
 
-const NONE = "null"
+const NONE = "undefined"
 
 /**
  * TODO: handle recursive data structures
@@ -50,20 +50,12 @@ export function genTypes(schema) {
                 case "Real":
                     return ["number", "number"]
                 case "SpendingCredential":
-                    return [
-                        "SpendingCredential",
-                        "SpendingCredential | PubKeyHash | ValidatorHash"
-                    ]
+                    return ["SpendingCredential", "SpendingCredential"]
                 case "StakingCredential":
-                    return [
-                        "StakingCredential",
-                        "StakingCredential | StakingHash | PubKeyHash | StakingValidatorHash"
-                    ]
+                    return ["StakingCredential", "StakingCredential"]
                 case "StakingHash":
-                    return [
-                        "StakingHash",
-                        "StakingHash | PubKeyHash | StakingValidatorHash"
-                    ]
+                    // TODO: implement this
+                    return ["never", "never"]
                 case "StakingValidatorHash":
                     return [
                         "StakingValidatorHash",

package/src/codegen/index.js

@@ -1,14 +1 @@
-export { LoadedScriptsWriter } from "./LoadedScriptsWriter.js"
-
-/**
- * @typedef {import("./LoadedModule.js").LoadedModule} LoadedModule
- * @typedef {import("./LoadedValidator.js").LoadedValidator} LoadedValidator
- * @typedef {import("./TypeCheckedModule.js").TypeCheckedModule} TypeCheckedModule
- * @typedef {import("./TypeCheckedValidator.js").TypeCheckedValidator} TypeCheckedValidator
- * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
- */
-
-/**
- * @template {LoadedValidator} V
- * @typedef {import("./LoadedValidator.js").ExtractDependencies<V>} ExtractDependencies
- */
+export { makeLoadedScriptsWriter } from "./LoadedScriptsWriter.js"

package/src/compiler/CompilerLib.js

@@ -1,86 +1,7 @@
 import { readHeader } from "@helios-lang/compiler-utils"
 
-export {}
-
-/**
- * @typedef {import("@helios-lang/uplc").PlutusVersion} PlutusVersion
- * @typedef {import("@helios-lang/uplc").UplcData} UplcData
- * @typedef {import("@helios-lang/uplc").UplcSourceMapJsonSafe} UplcSourceMapJsonSafe
- * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
- * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
- * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
- */
-
-/**
- * @typedef {any} ScriptHashType
- */
-
-/**
- * if `debug` is true, the ir is included in the user functions where possible
- * @typedef {{
- *   allValidatorHashTypes: Record<string, ScriptHashType>
- *   allValidatorIndices?: Record<string, number>
- *   hashDependencies: Record<string, string>
- *   dependsOnOwnHash?: boolean
- *   ownHash?: string
- *   parameters?: Record<string, UplcData>
- *   isTestnet: boolean
- *   optimize: boolean
- *   debug?: boolean
- *   excludeUserFuncs?: Set<string>
- *   onCompileUserFunc?: (props: {
- *     name: string
- *     cborHex: string
- *     plutusVersion: PlutusVersion
- *     ir?: string
- *     sourceMap?: UplcSourceMapJsonSafe
- *     alt?: {
- *       cborHex: string
- *       ir?: string
- *       sourceMap?: UplcSourceMapJsonSafe
- *     }
- *   }) => void
- * }} CompileOptions
- */
-
-/**
- * @typedef {{
- *   cborHex: string
- *   plutusVersion: PlutusVersion
- *   ir?: string
- *   sourceMap?: import("@helios-lang/uplc").UplcSourceMapJsonSafe
- * }} CompileOutput
- */
-
-/**
- * @typedef {{
- *   modules: {[name: string]: TypeCheckedModule}
- *   validators: {[name: string]: TypeCheckedValidator}
- * }} TypeCheckOutput
- */
-
-/**
- * @typedef {{
- *   name: string
- *   purpose: string
- *   sourceCode: string
- * }} SourceDetails
- */
-
-/**
- * @typedef {{
- *   version: string
- *   getScriptHashType: (purpose: string) => ScriptHashType
- *   typeCheck: (validators: string[], modules: string[]) => ({
- *     modules: {[name: string]: TypeCheckedModule},
- *     validators: {[name: string]: TypeCheckedValidator}
- *   })
- *   compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput
- * }} CompilerLib
- */
-
 /**
- * @typedef {Record<string, string[]>} DagDependencies
+ * @import { CompilerLib, ScriptHashType } from "../index.js"
  */
 
 /**

package/src/compiler/CompilerLib_v0_16.js

@@ -1,20 +1,12 @@
 import { bytesToHex } from "@helios-lang/codec-utils"
 import { readHeader } from "@helios-lang/compiler-utils"
-import { expectSome } from "@helios-lang/type-utils"
+import { expectDefined } from "@helios-lang/type-utils"
 import { getValidatorTypes } from "./CompilerLib.js"
 
 /**
- * @typedef {import("@helios-lang/uplc").UplcData} UplcData
- * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
- * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
- * @typedef {import("../codegen/index.js").TypeSchema} TypeSchema
- * @typedef {import("./CompilerLib.js").CompileOptions} CompileOptions
- * @typedef {import("./CompilerLib.js").CompileOutput} CompileOutput
- * @typedef {import("./CompilerLib.js").CompilerLib} CompilerLib
- * @typedef {import("./CompilerLib.js").DagDependencies} DagDependencies
- * @typedef {import("./CompilerLib.js").ScriptHashType} ScriptHashType
- * @typedef {import("./CompilerLib.js").SourceDetails} SourceDetails
- * @typedef {import("./CompilerLib.js").TypeCheckOutput} TypeCheckOutput
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { UplcData } from "@helios-lang/uplc"
+ * @import { CompileOptions, CompileOutput, CompilerLib, DagDependencies, ScriptHashType, SourceDetails, TypeCheckOutput, TypeCheckedModule, TypeCheckedValidator }  from "../index.js"
  */
 
 /**
@@ -130,10 +122,18 @@ import { getValidatorTypes } from "./CompilerLib.js"
  * }} UserTypes
  */
 
+/**
+ * @param {any} lib
+ * @returns {CompilerLib}
+ */
+export function makeCompilerLib_v0_16(lib) {
+    return new CompilerLib_v0_16(lib)
+}
+
 /**
  * @implements {CompilerLib}
  */
-export class CompilerLib_v0_16 {
+class CompilerLib_v0_16 {
     /**
      * @param {any} lib
      */
@@ -570,7 +570,7 @@ export class CompilerLib_v0_16 {
                 const module_ =
                     moduleName.value == program.name
                         ? program.mainModule
-                        : expectSome(
+                        : expectDefined(
                               program.mainImportedModules.find(
                                   (m) => m.name.value == moduleName.value
                               ),
@@ -602,7 +602,7 @@ export class CompilerLib_v0_16 {
     /**
      * @private
      * @param {any} program
-     * @param {Option<Record<string, UplcData>>} parameters
+     * @param {Record<string, UplcData> | undefined} parameters
      */
     setParameters(program, parameters) {
         if (!parameters) {