@helios-lang/contract-utils 0.3.4 → 0.3.6

package/src/index.js

@@ -1,4 +1,13 @@
-export { makeCast, makeUserFunc } from "./cast/index.js"
+export { writeContractContextArtifacts } from "./artifacts/index.js"
+export {
+    convertFromUplcData,
+    convertToUplcData,
+    evalUserFunc,
+    evalUserFuncUnsafe,
+    makeCast,
+    makeUserFunc,
+    profileUserFunc
+} from "./cast/index.js"
 export {
     makeContractContextBuilder,
     contractContextCache
@@ -122,8 +131,10 @@ export { genTypes } from "./codegen/TypeSchema.js"
  */
 
 /**
+ * `unwrapSingleFieldEnumVariants` defaults to false. If true, the following enum variant data structure is used: `{VariantName: SingleFieldData}`, instead of the more verbose `{VariantName: {SingleFieldName: SingleFieldData}}`
  * @typedef {{
  *   isMainnet: boolean
+ *   unwrapSingleFieldEnumVariants?: boolean
  * }} CastConfig
  */
 
@@ -156,19 +167,6 @@ export { genTypes } from "./codegen/TypeSchema.js"
  * @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
@@ -198,6 +196,7 @@ export { genTypes } from "./codegen/TypeSchema.js"
  * @typedef {object} UserFunc
  * @prop {UplcProgram} uplc
  * @prop {string} name
+ * @prop {UserFuncProps} props
  * @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
@@ -273,7 +272,7 @@ export { genTypes } from "./codegen/TypeSchema.js"
  */
 
 /**
- * @template {LoadedValidator} V
+ * @template {LoadedValidator} [V=LoadedValidator]
  * @typedef {V extends {"$purpose": "spending", "$Datum": CastLike<any, any>, "$Redeemer": CastLike<any, any>} ? {
  *       $hash: ValidatorHash<
  *         SpendingContext<
@@ -310,32 +309,34 @@ export { genTypes } from "./codegen/TypeSchema.js"
  *          >
  *       >
  *     } & ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]> :
- *     never
+ *     {
+ *         $hash: ScriptHash<any>
+ *     } & ContractTypesContext & ContractUserFuncsContext
  * } ContractValidatorContexts
  */
 
 /**
- * @template {LoadedModule} V
+ * @template {LoadedModule} [V=LoadedModule]
  * @typedef {ContractTypesContext<V["$types"]> & ContractUserFuncsContext<V["$functions"]>} ContractModuleContexts
  */
 
 /**
- * @template {{[typeName: string]: CastLike<any, any>}} T
+ * @template {{[typeName: string]: CastLike<any, any>}} [T={[typeName: string]: CastLike<any, any>}]
  * @typedef {{
  *   [K in keyof T]: Cast<StrictType<T[K]>, PermissiveType<T[K]>>
  * }} ContractTypesContext
  */
 
 /**
- * @template {{[funcName: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}} T
+ * @template {{[funcName: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}} [T={[funcName: string]: (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>}]
  * @typedef {{
  *   [K in keyof T]: ReturnType<T[K]>
  * }} ContractUserFuncsContext
  */
 
 /**
- * @template {{[name: string]: LoadedValidator}} Vs
- * @template {{[name: string]: LoadedModule}} Ms
+ * @template {{[name: string]: LoadedValidator}} [Vs={[name: string]: LoadedValidator}]
+ * @template {{[name: string]: LoadedModule}} [Ms={[name: string]: LoadedModule}]
  * @typedef {{
  *   [K in keyof Vs]: ContractValidatorContexts<Vs[K]>
  * } & {
@@ -369,3 +370,19 @@ export { genTypes } from "./codegen/TypeSchema.js"
  * @prop {<M extends LoadedModule>(m: M) => ContractContextBuilder<Vs, Ms & {[K in M["$name"]]: M}>} withModule
  * @prop {(props: ContractContextBuilderProps) => ContractContext<Vs, Ms>} build
  */
+
+/**
+ * A subset of the Node FS interface, that can easily be implemented in other environments
+ * This type symbol shadows `FileSystem` from the FileSystem API
+ * @typedef {{
+ *   mkdirSync(path: string, options?: {recursive: boolean}): void
+ *   writeFileSync(path: string, content: string): void
+ * }} FileSystem
+ */
+
+/**
+ * @typedef {{
+ *   outDir: string
+ *   fs: FileSystem
+ * }} WriteContractContextArtifactsOptions
+ */

package/src/internal.js

@@ -0,0 +1,12 @@
+/**
+ * @import { AssertExtends } from "@helios-lang/type-utils"
+ * @import { FileSystem } from "./index.js"
+ */
+
+/**
+ * @typedef {typeof import("node:fs")} NodeFileSystem
+ */
+
+/**
+ * @typedef {AssertExtends<FileSystem, NodeFileSystem>} NodeFileSystemExtendsFileSystem
+ */

package/types/artifacts/Artifact.d.ts

@@ -0,0 +1,11 @@
+export type Artifact = {
+    dir: string;
+    fs: FileSystem;
+    isMainnet: boolean;
+    writeDeclLine: (line: string) => void;
+    writeDefLine: (line: string) => void;
+    writeAggregateExport: (name: string) => void;
+    save: () => void;
+};
+import type { FileSystem } from "../index.js";
+//# sourceMappingURL=Artifact.d.ts.map

package/types/artifacts/Artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Artifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/Artifact.js"],"names":[],"mappings":";SAMU,MAAM;QACN,UAAU;eACV,OAAO;mBACP,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;kBACtB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;0BACtB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;UACtB,MAAM,IAAI;;gCAXW,aAAa"}

package/types/artifacts/ArtifactWriter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @import { StringWriter } from "@helios-lang/codec-utils"
+ * @import { FileSystem } from "../index.js"
+ */
+export class ArtifactWriter {
+    /**
+     * @param {FileSystem} fs
+     * @param {string} dir
+     */
+    constructor(fs: FileSystem, dir: string);
+    /**
+     * @readonly
+     * @type {FileSystem}
+     */
+    readonly fs: FileSystem;
+    /**
+     * @readonly
+     * @type {string}
+     */
+    readonly dir: string;
+    /**
+     * @private
+     * @type {StringWriter}
+     */
+    private decl;
+    /**
+     * @private
+     * @type {StringWriter}
+     */
+    private def;
+    /**
+     * @private
+     * @type {[string, string, boolean][]}
+     */
+    private imports;
+    /**
+     * @param {string} name
+     * @param {string} from
+     * @param {boolean} [isType]
+     * @returns {ArtifactWriter}
+     */
+    addImport(name: string, from: string, isType?: boolean | undefined): ArtifactWriter;
+    /**
+     * @param {string} line
+     * @returns {ArtifactWriter}
+     */
+    writeDeclLine(line: string): ArtifactWriter;
+    /**
+     * @param {string} line
+     * @returns {ArtifactWriter}
+     */
+    writeDefLine(line: string): ArtifactWriter;
+    /**
+     * @param {string} name
+     * @returns {ArtifactWriter}
+     */
+    writeAggregateExport(name: string): ArtifactWriter;
+    /**
+     * Write the .d.ts and .js files to the FS
+     */
+    save(): void;
+}
+import type { FileSystem } from "../index.js";
+//# sourceMappingURL=ArtifactWriter.d.ts.map

package/types/artifacts/ArtifactWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ArtifactWriter.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;IA+BI;;;OAGG;IACH,gBAHW,UAAU,OACV,MAAM,EAShB;IAzCD;;;OAGG;IACH,aAFU,UAAU,CAElB;IAEF;;;OAGG;IACH,cAFU,MAAM,CAEb;IAEH;;;OAGG;IACH,aAAI;IAEJ;;;OAGG;IACH,YAAG;IAEH;;;OAGG;IACH,gBAAO;IAeP;;;;;OAKG;IACH,gBALW,MAAM,QACN,MAAM,iCAEJ,cAAc,CAK1B;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,cAAc,CAM1B;IAED;;OAEG;IACH,aA8DC;CACJ;gCAxJ8B,aAAa"}

package/types/artifacts/ChildArtifactWriter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @import { UplcProgram } from "@helios-lang/uplc"
+ * @import { Artifact } from "./Artifact.js"
+ */
+export class ChildArtifactWriter extends ArtifactWriter {
+    /**
+     * @param {Artifact} parent
+     * @param {string} name
+     */
+    constructor(parent: Artifact, name: string);
+    /**
+     * @readonly
+     * @type {Artifact}
+     */
+    readonly parent: Artifact;
+    /**
+     * @readonly
+     * @type {string}
+     */
+    readonly name: string;
+    /**
+     * @type {boolean}
+     */
+    get isMainnet(): boolean;
+    /**
+     * @param {string} name
+     * @param {UplcProgram} program
+     * @returns {ChildArtifactWriter}
+     */
+    writeProgram(name: string, program: UplcProgram): ChildArtifactWriter;
+}
+import { ArtifactWriter } from "./ArtifactWriter.js";
+import type { Artifact } from "./Artifact.js";
+import type { UplcProgram } from "@helios-lang/uplc";
+//# sourceMappingURL=ChildArtifactWriter.d.ts.map

package/types/artifacts/ChildArtifactWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ChildArtifactWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,oBAHW,QAAQ,QACR,MAAM,EAOhB;IArBD;;;OAGG;IACH,iBAFU,QAAQ,CAEZ;IAEN;;;OAGG;IACH,eAFU,MAAM,CAEZ;IAaJ;;OAEG;IACH,yBAEC;IAED;;;;OAIG;IACH,mBAJW,MAAM,WACN,WAAW,GACT,mBAAmB,CAmC/B;CACJ;+BA7E8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}

package/types/artifacts/FunctionArtifact.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @import { UserFuncProps } from "../index.js"
+ * @import { Artifact } from "./Artifact.js"
+ * @import { FunctionDetails } from "./symbols.js"
+ */
+/**
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {FunctionDetails} details
+ */
+export function writeFunctionArtifact(parent: Artifact, name: string, details: FunctionDetails): void;
+import type { Artifact } from "./Artifact.js";
+import type { FunctionDetails } from "./symbols.js";
+//# sourceMappingURL=FunctionArtifact.d.ts.map

package/types/artifacts/FunctionArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/FunctionArtifact.js"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH;;;;GAIG;AACH,8CAJW,QAAQ,QACR,MAAM,WACN,eAAe,QAezB;8BAtB4B,eAAe;qCACR,cAAc"}

package/types/artifacts/ModuleArtifact.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @import { FunctionDetails, ModuleSymbols, TypeDetails } from "./symbols.js"
+ */
+/**
+ * Re-export Artifact to avoid issues with typescript private symbol errors
+ * @typedef {import("./Artifact.js").Artifact} Artifact
+ */
+/**
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {ModuleSymbols} symbols
+ */
+export function writeModuleArtifact(parent: Artifact, name: string, symbols: ModuleSymbols): void;
+/**
+ * @implements {Artifact}
+ */
+export class ModuleArtifact extends ChildArtifactWriter implements Artifact {
+    /**
+     * @param {ModuleSymbols} symbols
+     */
+    writeSymbols(symbols: ModuleSymbols): void;
+}
+/**
+ * Re-export Artifact to avoid issues with typescript private symbol errors
+ */
+export type Artifact = import("./Artifact.js").Artifact;
+import type { ModuleSymbols } from "./symbols.js";
+import { ChildArtifactWriter } from "./ChildArtifactWriter.js";
+//# sourceMappingURL=ModuleArtifact.d.ts.map

package/types/artifacts/ModuleArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/ModuleArtifact.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;GAGG;AAEH;;;;GAIG;AACH,4CAJW,QAAQ,QACR,MAAM,WACN,aAAa,QAUvB;AAED;;GAEG;AACH,mEAFgB,QAAQ;IAWpB;;OAEG;IACH,sBAFW,aAAa,QAuCvB;CACJ;;;;uBAvEY,OAAO,eAAe,EAAE,QAAQ;mCALmB,cAAc;oCAL1C,0BAA0B"}

package/types/artifacts/RootArtifact.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @import { ContractContext, ContractModuleContexts, ContractValidatorContexts, FileSystem, LoadedValidator, WriteContractContextArtifactsOptions } from "../index.js"
+ * @import { Artifact } from "./Artifact.js"
+ */
+/**
+ * @param {any} context - TODO: make this typesafe (`ContractContext<any, any>` or `ContractContext` doesn't seem to work)
+ * @param {WriteContractContextArtifactsOptions} options - not optional, at least the fs and outDir must be specified
+ */
+export function writeContractContextArtifacts(context: any, options: WriteContractContextArtifactsOptions): void;
+import type { WriteContractContextArtifactsOptions } from "../index.js";
+//# sourceMappingURL=RootArtifact.d.ts.map

package/types/artifacts/RootArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RootArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/RootArtifact.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,uDAHW,GAAG,WACH,oCAAoC,QA2B9C;0DAjCyJ,aAAa"}

package/types/artifacts/TypeArtifact.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { Artifact } from "./Artifact.js"
+ * @import { FunctionDetails, TypeDetails } from "./symbols.js"
+ */
+/**
+ *
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {TypeDetails} props
+ * @param {Record<string, FunctionDetails>} members
+ */
+export function writeTypeArtifact(parent: Artifact, name: string, props: TypeDetails, members: Record<string, FunctionDetails>): void;
+import type { Artifact } from "./Artifact.js";
+import type { TypeDetails } from "./symbols.js";
+import type { FunctionDetails } from "./symbols.js";
+//# sourceMappingURL=TypeArtifact.d.ts.map

package/types/artifacts/TypeArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/TypeArtifact.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;;;;GAMG;AACH,0CALW,QAAQ,QACR,MAAM,SACN,WAAW,WACX,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,QAyBzC;8BAlC4B,eAAe;iCACK,cAAc;qCAAd,cAAc"}

package/types/artifacts/ValidatorArtifact.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @import { MintingContext, ScriptHash, SpendingContext, StakingContext } from "@helios-lang/ledger"
+ * @import { Cast } from "../index.js"
+ * @import { Artifact } from "./Artifact.js"
+ * @import { ModuleSymbols } from "./symbols.js"
+ */
+/**
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {ScriptHash} hash
+ * @param {ModuleSymbols} symbols
+ */
+export function writeValidatorArtifact(parent: Artifact, name: string, hash: ScriptHash, symbols: ModuleSymbols): void;
+import type { Artifact } from "./Artifact.js";
+import type { ScriptHash } from "@helios-lang/ledger";
+import type { ModuleSymbols } from "./symbols.js";
+//# sourceMappingURL=ValidatorArtifact.d.ts.map

package/types/artifacts/ValidatorArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidatorArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/ValidatorArtifact.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;;;GAKG;AACH,+CALW,QAAQ,QACR,MAAM,QACN,UAAU,WACV,aAAa,QAYvB;8BApB4B,eAAe;gCAFoC,qBAAqB;mCAGnE,cAAc"}

package/types/artifacts/index.d.ts

@@ -0,0 +1,2 @@
+export { writeContractContextArtifacts } from "./RootArtifact.js";
+//# sourceMappingURL=index.d.ts.map

package/types/artifacts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/artifacts/index.js"],"names":[],"mappings":""}

package/types/artifacts/symbols.d.ts

@@ -0,0 +1,8 @@
+export type FunctionDetails = UserFunc<any, any>;
+export type TypeDetails = {
+    schema: TypeSchema;
+};
+export type ModuleSymbols = Record<string, FunctionDetails | TypeDetails>;
+import type { UserFunc } from "../index.js";
+import type { TypeSchema } from "@helios-lang/type-utils";
+//# sourceMappingURL=symbols.d.ts.map

package/types/artifacts/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../src/artifacts/symbols.js"],"names":[],"mappings":"8BAMa,SAAS,GAAG,EAAE,GAAG,CAAC;0BAIlB;IAAC,MAAM,EAAE,UAAU,CAAA;CAAC;4BAIpB,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CAAC;8BAZvB,aAAa;gCADjB,yBAAyB"}

package/types/cast/Cast.d.ts

@@ -1,8 +1,21 @@
 /**
  * @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"
+ * @import { EnumTypeSchema, TypeSchema } from "@helios-lang/type-utils"
+ * @import { ConstrData, UplcData } from "@helios-lang/uplc"
+ * @import { Cast, CastConfig, CastLike } from "../index.js"
+ */
+/**
+ * @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
+ * @prop {boolean} unwrapSingleFieldEnumVariants - defaults to false. If true, assumes the following input objects for enum variants: `{VariantName: SingleFieldData}`, instead of  the more verbose `{VariantName: {SingleFieldName: SingleFieldData}}`
+ */
+/**
+ * @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 {boolean} unwrapSingleFieldEnumVariants - defaults to false. If true, the following enum variant outputs are created: `{VariantName: SingleFieldData}`, instead of  the more verbose `{VariantName: {SingleFieldName: SingleFieldData}}`
+ * @prop {boolean} isMainnet
  */
 /**
  * @template TStrict
@@ -12,6 +25,36 @@
  * @returns {Cast<TStrict, TPermissive>}
  */
 export function makeCast<TStrict, TPermissive>(schema: TypeSchema, config: CastConfig): Cast<TStrict, TPermissive>;
+/**
+ * @template T
+ * @param {TypeSchema} schema
+ * @param {UplcData} data
+ * @param {{
+ *   isMainnet: boolean,
+ *   dataPath?: string,
+ *   unwrapSingleFieldEnumVariants?: boolean
+ * }} options
+ * @returns {T}
+ */
+export function convertFromUplcData<T>(schema: TypeSchema, data: UplcData, options: {
+    isMainnet: boolean;
+    dataPath?: string;
+    unwrapSingleFieldEnumVariants?: boolean;
+}): T;
+/**
+ * @template T
+ * @param {TypeSchema} schema
+ * @param {T} x
+ * @param {{
+ *   dataPath?: string,
+ *   unwrapSingleFieldEnumVariants?: boolean
+ * }} [options]
+ * @returns {UplcData}
+ */
+export function convertToUplcData<T>(schema: TypeSchema, x: T, options?: {
+    dataPath?: string;
+    unwrapSingleFieldEnumVariants?: boolean;
+} | undefined): UplcData;
 /**
  * @template TStrict
  * @template TPermissive
@@ -20,8 +63,39 @@ export function makeCast<TStrict, TPermissive>(schema: TypeSchema, config: CastC
  * @returns {Cast<TStrict, TPermissive>}
  */
 export function configureCast<TStrict, TPermissive>(cast: CastLike<TStrict, TPermissive>, config: CastConfig): Cast<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;
+    /**
+     * - defaults to false. If true, assumes the following input objects for enum variants: `{VariantName: SingleFieldData}`, instead of  the more verbose `{VariantName: {SingleFieldName: SingleFieldData}}`
+     */
+    unwrapSingleFieldEnumVariants: boolean;
+};
+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;
+    /**
+     * - defaults to false. If true, the following enum variant outputs are created: `{VariantName: SingleFieldData}`, instead of  the more verbose `{VariantName: {SingleFieldName: SingleFieldData}}`
+     */
+    unwrapSingleFieldEnumVariants: boolean;
+    isMainnet: boolean;
+};
 import type { TypeSchema } from "@helios-lang/type-utils";
 import type { CastConfig } from "../index.js";
 import type { Cast } from "../index.js";
+import type { UplcData } from "@helios-lang/uplc";
 import type { CastLike } from "../index.js";
+import type { TypeSchema as TypeSchema_1 } from "@helios-lang/type-utils";
 //# 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":"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"}
+{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/cast/Cast.js"],"names":[],"mappings":"AAsDA;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,yBANa,OAAO,EACP,WAAW,UACb,UAAU,UACV,UAAU,GACR,KAAK,OAAO,EAAE,WAAW,CAAC,CAItC;AAsED;;;;;;;;;;GAUG;AACH,oCAVa,CAAC,UACH,UAAU,QACV,QAAQ,WACR;IACN,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6BAA6B,CAAC,EAAE,OAAO,CAAA;CACxC,GACS,CAAC,CASb;AAED;;;;;;;;;GASG;AACH,kCATa,CAAC,UACH,UAAU,KACV,CAAC;eAEI,MAAM;oCACe,OAAO;gBAE/B,QAAQ,CAUpB;AA6sBD;;;;;;GAMG;AACH,8BANa,OAAO,EACP,WAAW,QACb,SAAS,OAAO,EAAE,WAAW,CAAC,UAC9B,UAAU,GACR,KAAK,OAAO,EAAE,WAAW,CAAC,CAQtC;;;;;UA51BS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;;;;cAC1B,MAAM;;;;mCACN,OAAO;;;;;;UAKP,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;;;;cAC1B,MAAM;;;;mCACN,OAAO;eACP,OAAO;;gCAjB8B,yBAAyB;gCAEzB,aAAa;0BAAb,aAAa;8BADnB,mBAAmB;8BACb,aAAa;gDAFb,yBAAyB"}

package/types/cast/UserFunc.d.ts

@@ -13,7 +13,46 @@
 export function makeUserFunc<ArgsT extends {
     [argName: string]: any;
 }, RetT>(uplc: UplcProgram, props: UserFuncProps): UserFunc<ArgsT, RetT>;
+/**
+ * @template {{[argName: string]: any}} ArgsT
+ * @template RetT
+ * @param {UplcProgram} program
+ * @param {UserFuncProps} props
+ * @param {ArgsT} namedArgs
+ * @param {UplcLogger | undefined} logOptions
+ * @returns {RetT}
+ */
+export function evalUserFunc<ArgsT extends {
+    [argName: string]: any;
+}, RetT>(program: UplcProgram, props: UserFuncProps, namedArgs: ArgsT, logOptions?: UplcLogger | undefined): RetT;
+/**
+ * @template {{[argName: string]: any}} ArgsT
+ * @template RetT
+ * @param {UplcProgram} program
+ * @param {UserFuncProps} props
+ * @param {UnsafeArgsT<ArgsT>} namedArgs
+ * @param {UplcLogger | undefined} logOptions
+ * @returns {RetT extends void ? void : UplcData}
+ */
+export function evalUserFuncUnsafe<ArgsT extends {
+    [argName: string]: any;
+}, RetT>(program: UplcProgram, props: UserFuncProps, namedArgs: UnsafeArgsT<ArgsT>, logOptions?: UplcLogger | undefined): RetT extends void ? void : UplcData;
+/**
+ * @template {{[argName: string]: any}} ArgsT
+ * @param {UplcProgram} program
+ * @param {UserFuncProps} props
+ * @param {UnsafeArgsT<ArgsT>} namedArgs
+ * @param {UplcLogger | undefined} logOptions - optional, passed to UplcProgram.eval if provided
+ * @returns {CekResult}
+ */
+export function profileUserFunc<ArgsT extends {
+    [argName: string]: any;
+}>(program: UplcProgram, props: UserFuncProps, namedArgs: UnsafeArgsT<ArgsT>, logOptions?: UplcLogger | undefined): CekResult;
 import type { UplcProgram } from "@helios-lang/uplc";
 import type { UserFuncProps } from "../index.js";
 import type { UserFunc } from "../index.js";
+import type { UplcLogger } from "@helios-lang/uplc";
+import type { UnsafeArgsT } from "../index.js";
+import type { UplcData } from "@helios-lang/uplc";
+import type { CekResult } from "@helios-lang/uplc";
 //# sourceMappingURL=UserFunc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UserFunc.d.ts","sourceRoot":"","sources":["../../src/cast/UserFunc.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;;;;GAMG;AACH,6BANwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI,QACN,WAAW,SACX,aAAa,GACX,SAAS,KAAK,EAAE,IAAI,CAAC,CAIjC;iCAb2E,mBAAmB;mCACpB,aAAa;8BAAb,aAAa"}
+{"version":3,"file":"UserFunc.d.ts","sourceRoot":"","sources":["../../src/cast/UserFunc.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;;;;GAMG;AACH,6BANwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI,QACN,WAAW,SACX,aAAa,GACX,SAAS,KAAK,EAAE,IAAI,CAAC,CAIjC;AAgED;;;;;;;;GAQG;AACH,6BARwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI,WACN,WAAW,SACX,aAAa,aACb,KAAK,eACL,UAAU,GAAG,SAAS,GACpB,IAAI,CA8ChB;AAED;;;;;;;;GAQG;AACH,mCARwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI,WACN,WAAW,SACX,aAAa,aACb,YAAY,KAAK,CAAC,eAClB,UAAU,GAAG,SAAS,GACpB,IAAI,SAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,CAmB/C;AAED;;;;;;;GAOG;AACH,gCAPwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,WAC5B,WAAW,SACX,aAAa,aACb,YAAY,KAAK,CAAC,eAClB,UAAU,GAAG,SAAS,GACpB,SAAS,CA6GrB;iCAnR2E,mBAAmB;mCACpB,aAAa;8BAAb,aAAa;gCADZ,mBAAmB;iCACpB,aAAa;8BADZ,mBAAmB;+BAAnB,mBAAmB"}

package/types/cast/index.d.ts

@@ -1,3 +1,3 @@
-export { makeUserFunc } from "./UserFunc.js";
-export { makeCast, configureCast } from "./Cast.js";
+export { configureCast, convertFromUplcData, convertToUplcData, makeCast } from "./Cast.js";
+export { evalUserFunc, evalUserFuncUnsafe, makeUserFunc, profileUserFunc } from "./UserFunc.js";
 //# sourceMappingURL=index.d.ts.map

package/types/codegen/LoadedScriptsWriter.d.ts

@@ -7,5 +7,23 @@
  * @returns {LoadedScriptsWriter}
  */
 export function makeLoadedScriptsWriter(): LoadedScriptsWriter;
+/**
+ * @param {TypeCheckedUserFunc} props
+ * @param {boolean} unsafe
+ * @returns {string}
+ */
+export function genUserFuncRetType(props: TypeCheckedUserFunc, unsafe?: boolean): string;
+/**
+ * @param {TypeCheckedUserFunc} props
+ * @param {boolean} [unsafe]
+ * @returns {string}
+ */
+export function genUserFuncArgsType(props: TypeCheckedUserFunc, unsafe?: boolean | undefined): string;
+/**
+ * @param {TypeCheckedUserFunc} fn
+ * @returns {[string, string]}
+ */
+export function genFuncType(fn: TypeCheckedUserFunc): [string, string];
 import type { LoadedScriptsWriter } from "../index.js";
+import type { TypeCheckedUserFunc } from "../index.js";
 //# sourceMappingURL=LoadedScriptsWriter.d.ts.map

package/types/codegen/LoadedScriptsWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LoadedScriptsWriter.d.ts","sourceRoot":"","sources":["../../src/codegen/LoadedScriptsWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,2CAFa,mBAAmB,CAI/B;yCATqG,aAAa"}
+{"version":3,"file":"LoadedScriptsWriter.d.ts","sourceRoot":"","sources":["../../src/codegen/LoadedScriptsWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,2CAFa,mBAAmB,CAI/B;AAsXD;;;;GAIG;AACH,0CAJW,mBAAmB,WACnB,OAAO,GACL,MAAM,CAUlB;AAED;;;;GAIG;AACH,2CAJW,mBAAmB,iCAEjB,MAAM,CAyBlB;AAED;;;GAGG;AACH,gCAHW,mBAAmB,GACjB,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5B;yCAlbqG,aAAa;yCAAb,aAAa"}

package/types/codegen/TypeSchema.d.ts

@@ -4,5 +4,10 @@
  * @returns {[string, string]} - the first entry is the strict canonical type, the second is the permissive type
  */
 export function genTypes(schema: TypeSchema): [string, string];
+/**
+ * @param {TypeSchema} schema
+ * @returns {Map<string, string>} - key=name, value=from
+ */
+export function collectBuiltinTypes(schema: TypeSchema): Map<string, string>;
 import type { TypeSchema } from "@helios-lang/type-utils";
 //# sourceMappingURL=TypeSchema.d.ts.map

package/types/codegen/TypeSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypeSchema.d.ts","sourceRoot":"","sources":["../../src/codegen/TypeSchema.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAGH,iCALW,UAAU,GACR,CAAC,MAAM,EAAE,MAAM,CAAC,CA8J5B;gCAtK8B,yBAAyB"}
+{"version":3,"file":"TypeSchema.d.ts","sourceRoot":"","sources":["../../src/codegen/TypeSchema.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAGH,iCALW,UAAU,GACR,CAAC,MAAM,EAAE,MAAM,CAAC,CA8J5B;AAED;;;GAGG;AACH,4CAHW,UAAU,GACR,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAW/B;gCArL8B,yBAAyB"}

package/types/context/writeContractContextArtifacts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @import { StringWriter } from "@helios-lang/codec-utils"
+ * @import { MintingPolicyHash, ScriptHash, StakingValidatorHash } from "@helios-lang/ledger"
+ * @import { UplcProgram } from "@helios-lang/uplc"
+ * @import { Cast, CastConfig, ContractContext, FileSystem, UserFunc, WriteContractContextArtifactsOptions } from "../index.js"
+ */
+/**
+ * @typedef {(uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>} FunctionDetails
+ */
+/**
+ * @typedef {Cast<any, any>} TypeDetails
+ */
+/**
+ * @typedef {Record<string, FunctionDetails | TypeDetails>} ModuleSymbols
+ */
+/**
+ * @param {ContractContext<any, any>} context
+ * @param {WriteContractContextArtifactsOptions} options - not optional, at least the fs and outDir must be specified
+ */
+export function writeContractContextArtifacts(context: ContractContext<any, any>, options: WriteContractContextArtifactsOptions): void;
+export type FunctionDetails = (uplc: UplcProgram, config: CastConfig) => UserFunc<any, any>;
+export type TypeDetails = Cast<any, any>;
+export type ModuleSymbols = Record<string, FunctionDetails | TypeDetails>;
+import type { ContractContext } from "../index.js";
+import type { WriteContractContextArtifactsOptions } from "../index.js";
+import type { UplcProgram } from "@helios-lang/uplc";
+import type { CastConfig } from "../index.js";
+import type { UserFunc } from "../index.js";
+import type { Cast } from "../index.js";
+//# sourceMappingURL=writeContractContextArtifacts.d.ts.map

package/types/context/writeContractContextArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeContractContextArtifacts.d.ts","sourceRoot":"","sources":["../../src/context/writeContractContextArtifacts.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;GAGG;AACH,uDAHW,gBAAgB,GAAG,EAAE,GAAG,CAAC,WACzB,oCAAoC,QAqB9C;8BAlCY,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,KAAK,SAAS,GAAG,EAAE,GAAG,CAAC;0BAI7D,KAAK,GAAG,EAAE,GAAG,CAAC;4BAId,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CAAC;qCAZwD,aAAa;0DAAb,aAAa;iCAD/F,mBAAmB;gCAC+D,aAAa;8BAAb,aAAa;0BAAb,aAAa"}