@helios-lang/contract-utils 0.2.81 → 0.3.0

package/src/context/DagCompiler.js

@@ -1,21 +1,19 @@
 import { bytesToHex } from "@helios-lang/codec-utils"
 import {
-    MintingPolicyHash,
-    ScriptHash,
-    StakingValidatorHash,
-    ValidatorHash
+    makeMintingPolicyHash,
+    makeStakingValidatorHash,
+    makeValidatorHash
 } from "@helios-lang/ledger"
-import { None, expectSome, isSome } from "@helios-lang/type-utils"
+import {
+    expectDefined as expectSome,
+    isDefined as isSome
+} from "@helios-lang/type-utils"
 import { restoreUplcProgram } from "@helios-lang/uplc"
 import { configureCast } from "../cast/index.js"
 
 /**
- * @typedef {import("@helios-lang/uplc").UplcData} UplcData
- * @typedef {import("@helios-lang/uplc").UplcProgram} UplcProgram
- * @typedef {import("../cast/index.js").CastConfig} CastConfig
- * @typedef {import("../codegen/LoadedValidator.js").LoadedValidator} LoadedValidator
- * @typedef {import("../compiler/index.js").CompilerLib} CompilerLib
- * @typedef {import("./ContractContext.js").AnyContractValidatorContext} AnyContractValidatorContext
+ * @import { UplcData, UplcProgram, UplcProgramV2 } from "@helios-lang/uplc"
+ * @import { AnyContractValidatorContext, CastConfig, CompilerLib, LoadedValidator} from "../index.js"
  */
 
 /**
@@ -79,10 +77,10 @@ export class DagCompiler {
      * @param {LoadedValidator[]} validators
      * @param {Record<string, UplcData>} parameters
      * @param {boolean} isTestnet
-     * @param {Option<{[name: string]: string}>} expectedHashes
+     * @param {{[name: string]: string} | undefined} expectedHashes
      * @returns {DagCompilerOutput}
      */
-    build(validators, parameters, isTestnet, expectedHashes = None) {
+    build(validators, parameters, isTestnet, expectedHashes = undefined) {
         const hashTypes = this.getHashTypes(validators)
         const validatorIndices = this.getValidatorIndices(validators)
 
@@ -169,7 +167,12 @@ export class DagCompiler {
                 this.cachedValidators[validator.$name]
             )
             const optimizedHashHex = optimizedHash.toHex()
-            const optimizedProgram = optimizedHash.context.program
+
+            /**
+             * @type {UplcProgramV2}
+             */
+            const optimizedProgram = /** @type {any} */ (optimizedHash.context)
+                .program
 
             // unoptimized compilation (so traces are untouched)
             const {
@@ -281,21 +284,22 @@ export class DagCompiler {
 
         switch (validator.$purpose) {
             case "spending":
-                this.cachedValidators[name] = new ValidatorHash(hash, {
+                this.cachedValidators[name] = makeValidatorHash(hash, {
                     program,
                     redeemer,
                     datum: configureCast(validator.$Datum, this.config)
                 })
                 break
             case "mixed":
-                this.cachedValidators[name] = new ScriptHash(hash, {
+                throw new Error("not yet implemented")
+                /*this.cachedValidators[name] = new ScriptHash(hash, {
                     program,
                     redeemer,
                     datum: configureCast(validator.$Datum, this.config)
-                })
+                })*/
                 break
             case "minting":
-                this.cachedValidators[name] = new MintingPolicyHash(hash, {
+                this.cachedValidators[name] = makeMintingPolicyHash(hash, {
                     program,
                     redeemer
                 })
@@ -303,7 +307,7 @@ export class DagCompiler {
             case "certifying":
             case "rewarding":
             case "staking":
-                this.cachedValidators[name] = new StakingValidatorHash(hash, {
+                this.cachedValidators[name] = makeStakingValidatorHash(hash, {
                     program,
                     redeemer
                 })
@@ -397,7 +401,7 @@ export class DagCompiler {
             if (isSome(v.$currentScriptIndex)) {
                 res[v.$name] = v.$currentScriptIndex
             } else {
-                return None
+                return undefined
             }
         }
 

package/src/context/index.js

@@ -1,8 +1,2 @@
-export { ContractContextBuilder } from "./ContractContextBuilder.js"
+export { makeContractContextBuilder } from "./ContractContextBuilder.js"
 export { contractContextCache } from "./ContractContextCache.js"
-
-/**
- * @template {{[name: string]: import("../codegen/index.js").LoadedValidator}} Vs
- * @template {{[name: string]: import("../codegen/index.js").LoadedModule}} Ms
- * @typedef {import("./ContractContext.js").ContractContext<Vs, Ms>} ContractContext
- */

package/src/hl2ts.js

@@ -9,15 +9,12 @@ import {
 } from "node:fs"
 import { dirname, join, resolve } from "node:path"
 import { Cli, EnumOpt, StringOpt } from "@helios-lang/cli-utils"
-import { None } from "@helios-lang/type-utils"
-import { LoadedScriptsWriter } from "./codegen/index.js"
+import { makeLoadedScriptsWriter } from "./codegen/index.js"
 import { loadCompilerLib } from "./compiler/index.js"
 import { typeCheckFiles } from "./compiler/ops.js"
 
 /**
- * @typedef {import("./compiler/CompilerLib.js").CompilerLib} CompilerLib
- * @typedef {import("./compiler/CompilerLib.js").TypeCheckedModule} ModuleDetails
- * @typedef {import("./compiler/CompilerLib.js").TypeCheckedValidator} ValidatorDetails
+ * @import { CompilerLib, TypeCheckedModule, TypeCheckedValidator } from "./index.js"
  */
 
 /**
@@ -90,7 +87,7 @@ async function mainInternal(_args, { outDir, format }) {
         resolve(join(dirname(current), rel))
     )
 
-    const [js, dts, ts] = LoadedScriptsWriter.new()
+    const [js, dts, ts] = makeLoadedScriptsWriter()
         .writeModules(modules)
         .writeValidators(validators)
         .finalize()

package/src/index.js

@@ -1,24 +1,370 @@
-export * from "./cast/index.js"
+export { makeCast, makeUserFunc } from "./cast/index.js"
 export {
-    ContractContextBuilder,
+    makeContractContextBuilder,
     contractContextCache
 } from "./context/index.js"
 export { typeCheckFiles, typeCheckScripts } from "./compiler/ops.js"
-export { LoadedScriptsWriter } from "./codegen/LoadedScriptsWriter.js"
+export { makeLoadedScriptsWriter } from "./codegen/index.js"
 export { loadCompilerLib } from "./compiler/ops.js"
 
 /**
- * @typedef {import("./codegen/index.js").LoadedValidator} LoadedValidator
- * @typedef {import("./codegen/index.js").LoadedModule} LoadedModule
+ * @import { MintingContext, MintingPolicyHash, ScriptHash, SpendingContext, StakingContext, StakingValidatorHash, ValidatorHash } from "@helios-lang/ledger"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { CekResult, PlutusVersion, UplcData, UplcLogger, UplcProgram, UplcSourceMapJsonSafe } from "@helios-lang/uplc"
  */
 
 /**
- * @template {{[name: string]: import("./codegen/index.js").LoadedValidator}} Vs
- * @template {{[name: string]: import("./codegen/index.js").LoadedModule}} Ms
- * @typedef {import("./context/index.js").ContractContext<Vs, Ms>} ContractContext
+ * `returns` is optional to accomodate main functions that return undefined
+ * @typedef {{
+ *   name: string
+ *   requiresScriptContext: boolean
+ *   requiresCurrentScript: boolean
+ *   arguments: {
+ *     name: string
+ *     type: TypeSchema
+ *     isOptional: boolean
+ *   }[]
+ *   returns?: TypeSchema
+ * }} TypeCheckedUserFunc
+ */
+
+/**
+ * @typedef {{
+ *   name: string
+ *   purpose: string
+ *   sourceCode: string
+ *   moduleDepedencies: string[]
+ *   types: Record<string, TypeSchema>
+ *   functions?: Record<string, TypeCheckedUserFunc>
+ * }} TypeCheckedModule
+ */
+
+/**
+ * @typedef {TypeCheckedModule & {
+ *   hashDependencies: string[]
+ *   currentScriptIndex?: number
+ *   Redeemer: TypeSchema
+ *   Datum?: TypeSchema
+ * }} 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
+ */
+
+/**
+ * @typedef {{
+ *   isMainnet: boolean
+ * }} CastConfig
+ */
+
+/**
+ * @template TStrict
+ * @template TPermissive
+ * @typedef {object} Cast
+ * @prop {"Cast"} kind
+ * @prop {TypeSchema} schema
+ * @prop {CastConfig} config
+ * @prop {(data: UplcData, dataPath?: string) => TStrict} fromUplcData
+ *
+ * @prop {(x: TPermissive, dataPath?: string) => UplcData} toUplcData
+ * converts javascript object to UPLC data, according to the schema.
+ * The optional `dataPath` parameter can provide a contextual cue for the
+ * data-conversion process, and will be displayed as part of any error messages
+ * thrown during the data transformation
+ */
+
+/**
+ * @template TStrict
+ * @template TPermissive
+ * @typedef {(config: CastConfig) => Cast<TStrict, TPermissive>} ConfigurableCast
+ */
+
+/**
+ * StrictType and PermissiveType work for both Cast and ConfigurableCast
+ * @template TStrict
+ * @template TPermissive
+ * @typedef {Cast<TStrict, TPermissive> | ConfigurableCast<TStrict, TPermissive>} CastLike
+ */
+
+/**
+ * @typedef {Object} SchemaToUplcContext
+ * @prop {Record<string, TypeSchema>} defs - symbol table permitting recursive schema references
+ * @prop {string} dataPath - provides developer-facing cues for any parsing errors, showing the deep field path of any error
+ */
+
+/**
+ * @typedef {Object} UplcToSchemaContext
+ * @prop {Record<string, TypeSchema>} defs - symbol table permitting recursive schema references
+ * @prop {string} dataPath - provides developer-facing cues for any parsing errors, showing the deep field path of any error
+ * @prop {CastConfig} config - has isMainnet indicator
+ */
+
+/**
+ * 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
+ * @typedef {object} UserFunc
+ * @prop {UplcProgram} uplc
+ * @prop {string} name
+ * @prop {(namedArgs: ArgsT, logOptions?: UplcLogger | undefined) => RetT} eval
+ * @prop {(namedArgs: UnsafeArgsT<ArgsT>, logOptions?: UplcLogger | undefined) => RetT extends void ? void : UplcData} evalUnsafe
+ * @prop {(namedArgs: UnsafeArgsT<ArgsT>, logOptions?: UplcLogger | undefined) => CekResult} profile
+ */
+
+/**
+ * @typedef {{
+ *   $name: string
+ *   $purpose: "module"
+ *   $sourceCode: string
+ *   $dependencies: ReadonlyArray<LoadedModule>
+ *   $types: {[name: string]: CastLike<any, any>}
+ *   $functions: {[name: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}
+ * }} LoadedModule
+ */
+
+/**
+ * * Note: `$hashDependencies` doesn't contain the indirect dependencies! It must be kept to a minimum in order to inform in which order the validators must be compiled
+ * @typedef {{
+ *   $name: string
+ *   $sourceCode: string
+ *   $dependencies: ReadonlyArray<LoadedModule>
+ *   $hashDependencies: ReadonlyArray<LoadedValidator>
+ *   $currentScriptIndex?: number
+ *   $dependsOnOwnHash: boolean
+ *   $types: {[name: string]: CastLike<any, any>}
+ *   $functions: {[name: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}
+ *   $Redeemer: CastLike<any, any>
+ * } & (
+ *   {
+ *     $purpose: "spending" | "mixed"
+ *     $Datum: CastLike<any, any>
+ *   } | {
+ *     $purpose: "minting" | "certifying" | "rewarding" | "staking"
+ *   }
+ * )} LoadedValidator
+ */
+
+/**
+ * @template {{$name: string}} N
+ * @typedef {{
+ *   [name in N["$name"]]: Extract<N, {"$name": name}>
+ * }} NamedDependencyToObject
+ */
+
+/**
+ * @template {ReadonlyArray<{$name: string}>} N
+ * @typedef {NamedDependencyToObject<N extends ReadonlyArray<infer M> ? M : never>} NamedDependenciesToObject
+ */
+
+/**
+ * @template {LoadedValidator} V
+ * @typedef {NamedDependenciesToObject<V["$dependencies"]>} ExtractDependencies
+ */
+
+/**
+ * @template {CastLike<any, any>} C
+ * @typedef {C extends CastLike<any, infer TPermissive> ? TPermissive : never} PermissiveType
+ */
+
+/**
+ * @template {CastLike<any, any>} C
+ * @typedef {C extends CastLike<infer TStrict, any> ? TStrict : never} StrictType
+ */
+
+/**
+ * @typedef {(
+ *   ValidatorHash<SpendingContext<any, any, any, any>> |
+ *   MintingPolicyHash<MintingContext<any, any>> |
+ *   StakingValidatorHash<StakingContext<any, any>> |
+ *   ScriptHash
+ * )} AnyContractValidatorContext
  */
 
 /**
  * @template {LoadedValidator} V
- * @typedef {import("./codegen/index.js").ExtractDependencies<V>} ExtractDependencies
+ * @typedef {V extends {"$purpose": "spending", "$Datum": CastLike<any, any>, "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: ValidatorHash<
+ *         SpendingContext<
+ *           StrictType<V["$Datum"]>,
+ *           PermissiveType<V["$Datum"]>,
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
+ *       >
+ *     } & ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]> :
+ *     V extends {"$purpose": "minting", "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: MintingPolicyHash<
+ *         MintingContext<
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
+ *       >
+ *     } & ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]> :
+ *     V extends {"$purpose": ("certifying" | "rewarding" | "staking"), "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: StakingValidatorHash<
+ *         StakingContext<
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
+ *       >
+ *     } & ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]> :
+ *     V extends {"$purpose": "mixed", "$Datum": CastLike<any, any>, "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: ScriptHash<
+ *         SpendingContext<
+ *            StrictType<V["$Datum"]>,
+ *            PermissiveType<V["$Datum"]>,
+ *            StrictType<V["$Redeemer"]>,
+ *            PermissiveType<V["$Redeemer"]>
+ *          >
+ *       >
+ *     } & ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]> :
+ *     never
+ * } ContractValidatorContexts
+ */
+
+/**
+ * @template {LoadedModule} V
+ * @typedef {ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]>} ContractModuleContexts
+ */
+
+/**
+ * @template {{[typeName: string]: CastLike<any, any>}} T
+ * @typedef {{
+ *   [K in keyof T]: Cast<StrictType<T[K]>, PermissiveType<T[K]>>
+ * }} ContractTypesContext
+ */
+
+/**
+ * @template {{[funcName: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}} T
+ * @typedef {{
+ *   [K in keyof T]: ReturnType<T[K]>
+ * }} ContractUserFuncsContext
+ */
+
+/**
+ * @template {{[name: string]: LoadedValidator}} Vs
+ * @template {{[name: string]: LoadedModule}} Ms
+ * @typedef {{
+ *   [K in keyof Vs]: ContractValidatorContexts<Vs[K]>
+ * } & {
+ *   [K in keyof Ms]: ContractModuleContexts<Ms[K]>
+ * }} ContractContext
+ */
+
+/**
+ * if `debug` is true, the ir is included where possible
+ * @typedef {{
+ *   isMainnet: boolean
+ *   expectedHashes?: {[name: string]: string}
+ *   parameters?: Record<string, UplcData>
+ *   dumpHashes?: boolean
+ *   debug?: boolean
+ * }} ContractContextBuilderProps
+ */
+
+/**
+ * @typedef {object} LoadedScriptsWriter
+ * @prop {(modules: Record<string, TypeCheckedModule>) => LoadedScriptsWriter} writeModules
+ * @prop {(validators: Record<string, TypeCheckedValidator>) => LoadedScriptsWriter} writeValidators
+ * @prop {() => [string, string, string]} finalize
+ */
+
+/**
+ * @template {{[name: string]: LoadedValidator}} Vs
+ * @template {{[name: string]: LoadedModule}} Ms
+ * @typedef {object} ContractContextBuilder
+ * @prop {<V extends LoadedValidator>(validator: V) => ContractContextBuilder<Vs & {[K in V["$name"]]: V}, Ms & ExtractDependencies<V>>} with
+ * @prop {<M extends LoadedModule>(m: M) => ContractContextBuilder<Vs, Ms & {[K in M["$name"]]: M}>} withModule
+ * @prop {(props: ContractContextBuilderProps) => ContractContext<Vs, Ms>} build
  */

package/types/cast/Cast.d.ts

@@ -1,113 +1,27 @@
 /**
- * @template TStrict
- * @template TPermissive
- * @param {CastLike<TStrict, TPermissive>} cast
- * @param {CastConfig} config
- * @returns {Cast<TStrict, TPermissive>}
- */
-export function configureCast<TStrict, TPermissive>(cast: CastLike<TStrict, TPermissive>, config: CastConfig): Cast<TStrict, TPermissive>;
-/**
- * @typedef {import("@helios-lang/uplc").UplcData} UplcData
- * @typedef {import("../codegen/index.js").TypeSchema} TypeSchema
- */
-/**
- * @typedef {{
- *   isMainnet: boolean
- * }} CastConfig
+ * @import { TxInput, TxOutput } from "@helios-lang/ledger"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { UplcData } from "@helios-lang/uplc"
+ * @import { Cast, CastConfig, CastLike, SchemaToUplcContext, UplcToSchemaContext } from "../index.js"
  */
 /**
  * @template TStrict
- * @template TPermissive
- * @typedef {(config: CastConfig) => Cast<TStrict, TPermissive>} ConfigurableCast
+ * @template TPermissive=TStrict
+ * @param {TypeSchema} schema
+ * @param {CastConfig} config
+ * @returns {Cast<TStrict, TPermissive>}
  */
+export function makeCast<TStrict, TPermissive>(schema: TypeSchema, config: CastConfig): Cast<TStrict, TPermissive>;
 /**
- * StrictType and PermissiveType work for both Cast and ConfigurableCast
  * @template TStrict
  * @template TPermissive
- * @typedef {Cast<TStrict, TPermissive> | ConfigurableCast<TStrict, TPermissive>} CastLike
- */
-/**
- * @typedef {Object} SchemaToUplcContext
- * @property {Record<string, TypeSchema>} defs - symbol table permitting recursive schema references
- * @property {string} dataPath - provides developer-facing cues for any parsing errors, showing the deep field path of any error
- */
-/**
- * @typedef {Object} UplcToSchemaContext
- * @property {Record<string, TypeSchema>} defs - symbol table permitting recursive schema references
- * @property {string} dataPath - provides developer-facing cues for any parsing errors, showing the deep field path of any error
- * @property {CastConfig} config - has isMainnet indicator
- */
-/**
- * @template TStrict
- * @template TPermissive=TStrict
- */
-export class Cast<TStrict, TPermissive> {
-    /**
-     * @param {TypeSchema} schema
-     * @param {CastConfig} config
-     */
-    constructor(schema: TypeSchema, config: CastConfig);
-    /**
-     * @readonly
-     * @type {TypeSchema}
-     */
-    readonly schema: TypeSchema;
-    /**
-     * @readonly
-     * @type {CastConfig}
-     */
-    readonly config: CastConfig;
-    /**
-     * @param {UplcData} data
-     * @param {string} [dataPath] - can be used to indicate the kind or context of data-decoding
-     * @returns {TStrict}
-     */
-    fromUplcData(data: UplcData, dataPath?: string | undefined): TStrict;
-    /**
-     * converts javascript object to UPLC data, according to the schema.
-     * @remarks
-     * The optional `dataPath` parameter can provide a contextual cue for the
-     * data-conversion process, and will be displayed as part of any error messages
-     * thrown during the data transformation
-     *
-     * @param {TPermissive} x
-     * @param {string} dataPath
-     * @returns {UplcData}
-     */
-    toUplcData(x: TPermissive, dataPath?: string): UplcData;
-}
-export type UplcData = import("@helios-lang/uplc").UplcData;
-export type TypeSchema = import("../codegen/index.js").TypeSchema;
-export type CastConfig = {
-    isMainnet: boolean;
-};
-export type ConfigurableCast<TStrict, TPermissive> = (config: CastConfig) => Cast<TStrict, TPermissive>;
-/**
- * StrictType and PermissiveType work for both Cast and ConfigurableCast
+ * @param {CastLike<TStrict, TPermissive>} cast
+ * @param {CastConfig} config
+ * @returns {Cast<TStrict, TPermissive>}
  */
-export type CastLike<TStrict, TPermissive> = Cast<TStrict, TPermissive> | ConfigurableCast<TStrict, TPermissive>;
-export type SchemaToUplcContext = {
-    /**
-     * - symbol table permitting recursive schema references
-     */
-    defs: Record<string, TypeSchema>;
-    /**
-     * - provides developer-facing cues for any parsing errors, showing the deep field path of any error
-     */
-    dataPath: string;
-};
-export type UplcToSchemaContext = {
-    /**
-     * - symbol table permitting recursive schema references
-     */
-    defs: Record<string, TypeSchema>;
-    /**
-     * - provides developer-facing cues for any parsing errors, showing the deep field path of any error
-     */
-    dataPath: string;
-    /**
-     * - has isMainnet indicator
-     */
-    config: CastConfig;
-};
+export function configureCast<TStrict, TPermissive>(cast: CastLike<TStrict, TPermissive>, config: CastConfig): Cast<TStrict, TPermissive>;
+import type { TypeSchema } from "@helios-lang/type-utils";
+import type { CastConfig } from "../index.js";
+import type { Cast } from "../index.js";
+import type { CastLike } from "../index.js";
 //# sourceMappingURL=Cast.d.ts.map

package/types/cast/Cast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/cast/Cast.js"],"names":[],"mappings":"AA0uBA;;;;;;GAMG;AACH,8BANa,OAAO,EACP,WAAW,QACb,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,UAC9B,UAAU,GACR,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAQtC;AAltBD;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;GAGG;AACH,kBAHa,OAAO,EACP,WAAW;IAepB;;;OAGG;IACH,oBAHW,UAAU,UACV,UAAU,EAKpB;IAnBD;;;OAGG;IACH,iBAFU,UAAU,CAEd;IAEN;;;OAGG;IACH,iBAFU,UAAU,CAEd;IAWN;;;;OAIG;IACH,mBAJW,QAAQ,kCAEN,OAAO,CAQnB;IAED;;;;;;;;;;OAUG;IACH,cAJW,WAAW,aACX,MAAM,GACJ,QAAQ,CASpB;CACJ;uBA9FY,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,qBAAqB,EAAE,UAAU;yBAIxC;IACR,SAAS,EAAE,OAAO,CAAA;CACnB;6BAIS,OAAO,EACP,WAAW,IACX,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC;;;;qBAKlD,OAAO,EACP,WAAW,IACX,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC;;;;;UAKlE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;;;;cAC1B,MAAM;;;;;;UAKN,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;;;;cAC1B,MAAM;;;;YACN,UAAU"}
+{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/cast/Cast.js"],"names":[],"mappings":"AAsDA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,yBANa,OAAO,EACP,WAAW,UACb,UAAU,UACV,UAAU,GACR,KAAK,OAAO,EAAE,WAAW,CAAC,CAItC;AA6qBD;;;;;;GAMG;AACH,8BANa,OAAO,EACP,WAAW,QACb,SAAS,OAAO,EAAE,WAAW,CAAC,UAC9B,UAAU,GACR,KAAK,OAAO,EAAE,WAAW,CAAC,CAQtC;gCAxsB8B,yBAAyB;gCAEiC,aAAa;0BAAb,aAAa;8BAAb,aAAa"}