chore: Wrapper Data Contract

lib/actions/createAction.ts

@@ -1,51 +1,56 @@
 import { Config, ExtractConfigType } from "../config/builder/config"
 import { ActionMetaData, ActionResult, Effects, ExportedAction } from "../types"
-import { Utils, utils } from "../util"
+import { Utils, createUtils, utils } from "../util"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 export class CreatedAction<
-  WrapperData,
-  ConfigType extends
-    | Record<string, any>
-    | Config<any, WrapperData>
-    | Config<any, never>,
+  WD,
+  ConfigType extends Record<string, any> | Config<any, WD> | Config<any, never>,
   Type extends Record<string, any> = ExtractConfigType<ConfigType>,
 > {
   private constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
     public readonly myMetaData: ActionMetaData,
     readonly fn: (options: {
       effects: Effects
-      utils: Utils<WrapperData>
+      utils: Utils<WD>
       input: Type
     }) => Promise<ActionResult>,
-    readonly input: Config<Type, WrapperData> | Config<Type, never>,
+    readonly input: Config<Type, WD> | Config<Type, never>,
   ) {}
   public validator = this.input.validator
 
   static of<
-    WrapperData,
+    WD,
     ConfigType extends
       | Record<string, any>
       | Config<any, any>
       | Config<any, never>,
     Type extends Record<string, any> = ExtractConfigType<ConfigType>,
   >(
+    wrapperDataContract: WrapperDataContract<WD>,
     metaData: Omit<ActionMetaData, "input"> & {
-      input: Config<Type, WrapperData> | Config<Type, never>
+      input: Config<Type, WD> | Config<Type, never>
     },
     fn: (options: {
       effects: Effects
-      utils: Utils<WrapperData>
+      utils: Utils<WD>
       input: Type
     }) => Promise<ActionResult>,
   ) {
     const { input, ...rest } = metaData
-    return new CreatedAction<WrapperData, ConfigType, Type>(rest, fn, input)
+    return new CreatedAction<WD, ConfigType, Type>(
+      wrapperDataContract,
+      rest,
+      fn,
+      input,
+    )
   }
 
   exportedAction: ExportedAction = ({ effects, input }) => {
     return this.fn({
       effects,
-      utils: utils<WrapperData>(effects),
+      utils: createUtils(this.wrapperDataContract, effects),
       input: this.validator.unsafeCast(input),
     })
   }
@@ -53,7 +58,7 @@ export class CreatedAction<
   run = async ({ effects, input }: { effects: Effects; input?: Type }) => {
     return this.fn({
       effects,
-      utils: utils<WrapperData>(effects),
+      utils: createUtils(this.wrapperDataContract, effects),
       input: this.validator.unsafeCast(input),
     })
   }
@@ -61,7 +66,7 @@ export class CreatedAction<
   async getConfig({ effects }: { effects: Effects }) {
     return this.input.build({
       effects,
-      utils: utils<WrapperData>(effects) as any,
+      utils: createUtils(this.wrapperDataContract, effects) as any,
     })
   }
 }

lib/autoconfig/AutoConfig.ts

@@ -2,6 +2,7 @@ import { AutoConfigure, DeepPartial, Effects, ExpectedExports } from "../types"
 import { Utils, utils } from "../util"
 import { deepEqual } from "../util/deepEqual"
 import { deepMerge } from "../util/deepMerge"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 export type AutoConfigFrom<WD, Input, NestedConfigs> = {
   [key in keyof NestedConfigs & string]: (options: {
@@ -13,6 +14,7 @@ export type AutoConfigFrom<WD, Input, NestedConfigs> = {
 }
 export class AutoConfig<WD, Input, NestedConfigs> {
   constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
     readonly configs: AutoConfigFrom<WD, Input, NestedConfigs>,
     readonly path: keyof AutoConfigFrom<WD, Input, NestedConfigs>,
   ) {}
@@ -23,7 +25,7 @@ export class AutoConfig<WD, Input, NestedConfigs> {
     const origConfig = JSON.parse(JSON.stringify(options.localConfig))
     const newOptions = {
       ...options,
-      utils: utils<WD>(options.effects),
+      utils: utils(this.wrapperDataContract, options.effects),
       localConfig: options.localConfig as Input,
       remoteConfig: options.remoteConfig as any,
     }
@@ -44,7 +46,7 @@ export class AutoConfig<WD, Input, NestedConfigs> {
   ): ReturnType<AutoConfigure["autoConfigure"]> {
     const newOptions = {
       ...options,
-      utils: utils<WD>(options.effects),
+      utils: utils(this.wrapperDataContract, options.effects),
       localConfig: options.localConfig as Input,
       remoteConfig: options.remoteConfig as any,
     }

lib/autoconfig/setupAutoConfig.ts

@@ -1,4 +1,5 @@
 import { SDKManifest } from "../manifest/ManifestTypes"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 import { AutoConfig, AutoConfigFrom } from "./AutoConfig"
 
 export function setupAutoConfig<
@@ -8,7 +9,10 @@ export function setupAutoConfig<
   NestedConfigs extends {
     [key in keyof Manifest["dependencies"]]: unknown
   },
->(configs: AutoConfigFrom<WD, Input, NestedConfigs>) {
+>(
+  wrapperDataContract: WrapperDataContract<WD>,
+  configs: AutoConfigFrom<WD, Input, NestedConfigs>,
+) {
   type C = typeof configs
   const answer = { ...configs } as unknown as {
     [k in keyof C]: AutoConfig<WD, Input, NestedConfigs>
@@ -18,7 +22,7 @@ export function setupAutoConfig<
       WD,
       Input,
       NestedConfigs
-    >(configs, key as keyof typeof configs)
+    >(wrapperDataContract, configs, key as keyof typeof configs)
   }
   return answer
 }

lib/config/builder/list.ts

@@ -9,6 +9,7 @@ import {
   ValueSpecText,
 } from "../configTypes"
 import { Parser, arrayOf, number, string } from "ts-matches"
+import { WrapperDataContract } from "../../wrapperData/wrapperDataContract"
 /**
  * Used as a subtype of Value.list
 ```ts
@@ -74,6 +75,7 @@ export class List<Type, WD> {
     }, arrayOf(string))
   }
   static dynamicText<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -167,6 +169,7 @@ export class List<Type, WD> {
     }, arrayOf(number))
   }
   static dynamicNumber<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {

lib/config/builder/value.ts

@@ -24,6 +24,7 @@ import {
   unknown,
 } from "ts-matches"
 import { once } from "../../util/once"
+import { WrapperDataContract } from "../../wrapperData/wrapperDataContract"
 
 type RequiredDefault<A> =
   | false
@@ -121,6 +122,7 @@ export class Value<Type, WD> {
     )
   }
   static dynamicToggle<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     a: LazyBuild<
       WD,
       {
@@ -184,6 +186,7 @@ export class Value<Type, WD> {
     )
   }
   static dynamicText<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -255,6 +258,7 @@ export class Value<Type, WD> {
     )
   }
   static dynamicTextarea<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -321,6 +325,7 @@ export class Value<Type, WD> {
     )
   }
   static dynamicNumber<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -382,6 +387,7 @@ export class Value<Type, WD> {
   }
 
   static dynamicColor<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -439,6 +445,7 @@ export class Value<Type, WD> {
     )
   }
   static dynamicDatetime<WD = never>(
+    _wrapperDataContract: WrapperDataContract<WD>,
     getA: LazyBuild<
       WD,
       {
@@ -630,35 +637,34 @@ export class Value<Type, WD> {
       asRequiredParser(aVariants.validator, a),
     )
   }
-  static filteredUnion<WrapperData = never>(
-    getDisabledFn: LazyBuild<WrapperData, string[]>,
+  static filteredUnion<
+    Required extends RequiredDefault<string>,
+    Type extends Record<string, any>,
+    WD = never,
+  >(
+    _wrapperDataContract: WrapperDataContract<WD>,
+    getDisabledFn: LazyBuild<WD, string[]>,
+    a: {
+      name: string
+      description?: string | null
+      warning?: string | null
+      required: Required
+    },
+    aVariants: Variants<Type, WD> | Variants<Type, never>,
   ) {
-    return <
-      Required extends RequiredDefault<string>,
-      Type extends Record<string, any>,
-    >(
-      a: {
-        name: string
-        description?: string | null
-        warning?: string | null
-        required: Required
-      },
-      aVariants: Variants<Type, WrapperData> | Variants<Type, never>,
-    ) => {
-      return new Value<AsRequired<Type, Required>, WrapperData>(
-        async (options) => ({
-          type: "union" as const,
-          description: null,
-          warning: null,
-          ...a,
-          variants: await aVariants.build(options as any),
-          ...requiredLikeToAbove(a.required),
-          disabled: (await getDisabledFn(options)) || [],
-          immutable: false,
-        }),
-        asRequiredParser(aVariants.validator, a),
-      )
-    }
+    return new Value<AsRequired<Type, Required>, WD>(
+      async (options) => ({
+        type: "union" as const,
+        description: null,
+        warning: null,
+        ...a,
+        variants: await aVariants.build(options as any),
+        ...requiredLikeToAbove(a.required),
+        disabled: (await getDisabledFn(options)) || [],
+        immutable: false,
+      }),
+      asRequiredParser(aVariants.validator, a),
+    )
   }
 
   static list<Type, WrapperData>(a: List<Type, WrapperData>) {
@@ -686,33 +692,3 @@ export class Value<Type, WD> {
     return this as any as Value<Type, NewWrapperData>
   }
 }
-
-type Wrapper = { test: 1 | "5" }
-const valueA = Value.dynamicText<Wrapper>(() => ({
-  name: "a",
-  required: false,
-}))
-const variantForC = Variants.of({
-  lnd: {
-    name: "lnd Name",
-    spec: Config.of({
-      name: Value.text({
-        name: "Node Name",
-        required: false,
-      }),
-    }),
-  },
-})
-const valueC = Value.filteredUnion<Wrapper>(() => [])(
-  { name: "a", required: false },
-  variantForC,
-)
-const valueB = Value.text({
-  name: "a",
-  required: false,
-})
-const test = Config.of({
-  a: valueA,
-  b: valueB,
-  c: valueC,
-})

lib/config/constants.ts

@@ -1,12 +1,18 @@
 import { SmtpValue } from "../types"
+import {
+  createWrapperDataContract,
+  neverWrapperDataContract,
+} from "../wrapperData/wrapperDataContract"
 import { Config, ConfigSpecOf } from "./builder/config"
 import { Value } from "./builder/value"
 import { Variants } from "./builder/variants"
 
-export const smtpConfig = Value.filteredUnion(async ({ effects, utils }) => {
-  const smtp = await utils.getSystemSmtp().once()
-  return smtp ? [] : ["system"]
-})(
+export const smtpConfig = Value.filteredUnion(
+  neverWrapperDataContract,
+  async ({ effects, utils }) => {
+    const smtp = await utils.getSystemSmtp().once()
+    return smtp ? [] : ["system"]
+  },
   {
     name: "SMTP",
     description: "Optionally provide an SMTP server for sending email",

lib/config/setupConfig.ts

@@ -4,6 +4,7 @@ import * as D from "./dependencies"
 import { Config, ExtractConfigType } from "./builder/config"
 import { Utils, utils } from "../util"
 import nullIfEmpty from "../util/nullIfEmpty"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 declare const dependencyProof: unique symbol
 export type DependenciesReceipt = void & {
@@ -52,6 +53,7 @@ export function setupConfig<
   Manifest extends SDKManifest,
   Type extends Record<string, any> = ExtractConfigType<ConfigType>,
 >(
+  wrapperDataContract: WrapperDataContract<WD>,
   spec: Config<Type, WD> | Config<Type, never>,
   write: Save<WD, Type, Manifest>,
   read: Read<WD, Type>,
@@ -66,7 +68,7 @@ export function setupConfig<
       const { restart } = await write({
         input: JSON.parse(JSON.stringify(input)),
         effects,
-        utils: utils<WD>(effects),
+        utils: utils(wrapperDataContract, effects),
         dependencies: D.dependenciesSet<Manifest>(),
       })
       if (restart) {
@@ -74,7 +76,7 @@ export function setupConfig<
       }
     }) as ExpectedExports.setConfig,
     getConfig: (async ({ effects }) => {
-      const myUtils = utils<WD>(effects)
+      const myUtils = utils(wrapperDataContract, effects)
       const configValue = nullIfEmpty(
         (await read({ effects, utils: myUtils })) || null,
       )

lib/inits/migrations/Migration.ts

@@ -1,27 +1,33 @@
 import { ManifestVersion } from "../../manifest/ManifestTypes"
 import { Effects } from "../../types"
+import { Utils } from "../../util"
+import { WrapperDataContract } from "../../wrapperData/wrapperDataContract"
 
-export class Migration<Version extends ManifestVersion> {
+export class Migration<WD, Version extends ManifestVersion> {
   constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
     readonly options: {
       version: Version
-      up: (opts: { effects: Effects }) => Promise<void>
-      down: (opts: { effects: Effects }) => Promise<void>
+      up: (opts: { effects: Effects; utils: Utils<WD> }) => Promise<void>
+      down: (opts: { effects: Effects; utils: Utils<WD> }) => Promise<void>
     },
   ) {}
-  static of<Version extends ManifestVersion>(options: {
-    version: Version
-    up: (opts: { effects: Effects }) => Promise<void>
-    down: (opts: { effects: Effects }) => Promise<void>
-  }) {
-    return new Migration(options)
+  static of<WD, Version extends ManifestVersion>(
+    wrapperDataContract: WrapperDataContract<WD>,
+    options: {
+      version: Version
+      up: (opts: { effects: Effects; utils: Utils<WD> }) => Promise<void>
+      down: (opts: { effects: Effects; utils: Utils<WD> }) => Promise<void>
+    },
+  ) {
+    return new Migration(wrapperDataContract, options)
   }
 
-  async up(opts: { effects: Effects }) {
+  async up(opts: { effects: Effects; utils: Utils<WD> }) {
     this.up(opts)
   }
 
-  async down(opts: { effects: Effects }) {
+  async down(opts: { effects: Effects; utils: Utils<WD> }) {
     this.down(opts)
   }
 }

lib/inits/migrations/setupMigrations.ts

@@ -2,38 +2,47 @@ import { setupActions } from "../../actions/setupActions"
 import { EmVer } from "../../emverLite/mod"
 import { SDKManifest } from "../../manifest/ManifestTypes"
 import { ExpectedExports } from "../../types"
+import { createUtils } from "../../util"
 import { once } from "../../util/once"
+import { WrapperDataContract } from "../../wrapperData/wrapperDataContract"
 import { Migration } from "./Migration"
 
-export class Migrations {
+export class Migrations<WD> {
   private constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
     readonly manifest: SDKManifest,
-    readonly migrations: Array<Migration<any>>,
+    readonly migrations: Array<Migration<WD, any>>,
   ) {}
   private sortedMigrations = once(() => {
-    const migrationsAsVersions = (this.migrations as Array<Migration<any>>).map(
-      (x) => [EmVer.parse(x.options.version), x] as const,
-    )
+    const migrationsAsVersions = (
+      this.migrations as Array<Migration<WD, any>>
+    ).map((x) => [EmVer.parse(x.options.version), x] as const)
     migrationsAsVersions.sort((a, b) => a[0].compareForSort(b[0]))
     return migrationsAsVersions
   })
   private currentVersion = once(() => EmVer.parse(this.manifest.version))
-  static of<Migrations extends Array<Migration<any>>>(
+  static of<WD, Migrations extends Array<Migration<WD, any>>>(
+    wrapperDataContract: WrapperDataContract<WD>,
     manifest: SDKManifest,
     ...migrations: EnsureUniqueId<Migrations>
   ) {
-    return new Migrations(manifest, migrations as Array<Migration<any>>)
+    return new Migrations(
+      wrapperDataContract,
+      manifest,
+      migrations as Array<Migration<WD, any>>,
+    )
   }
   async init({
     effects,
     previousVersion,
   }: Parameters<ExpectedExports.init>[0]) {
+    const utils = createUtils(this.wrapperDataContract, effects)
     if (!!previousVersion) {
       const previousVersionEmVer = EmVer.parse(previousVersion)
       for (const [_, migration] of this.sortedMigrations()
         .filter((x) => x[0].greaterThan(previousVersionEmVer))
         .filter((x) => x[0].lessThanOrEqual(this.currentVersion()))) {
-        await migration.up({ effects })
+        await migration.up({ effects, utils })
       }
     }
   }
@@ -41,29 +50,34 @@ export class Migrations {
     effects,
     nextVersion,
   }: Parameters<ExpectedExports.uninit>[0]) {
+    const utils = createUtils(this.wrapperDataContract, effects)
     if (!!nextVersion) {
       const nextVersionEmVer = EmVer.parse(nextVersion)
       const reversed = [...this.sortedMigrations()].reverse()
       for (const [_, migration] of reversed
         .filter((x) => x[0].greaterThan(nextVersionEmVer))
         .filter((x) => x[0].lessThanOrEqual(this.currentVersion()))) {
-        await migration.down({ effects })
+        await migration.down({ effects, utils })
       }
     }
   }
 }
 
-export function setupMigrations<Migrations extends Array<Migration<any>>>(
+export function setupMigrations<
+  WD,
+  Migrations extends Array<Migration<WD, any>>,
+>(
+  wrapperDataContract: WrapperDataContract<WD>,
   manifest: SDKManifest,
   ...migrations: EnsureUniqueId<Migrations>
 ) {
-  return Migrations.of(manifest, ...migrations)
+  return Migrations.of(wrapperDataContract, manifest, ...migrations)
 }
 
 // prettier-ignore
 export type EnsureUniqueId<A, B = A, ids = never> =
   B extends [] ? A : 
-  B extends [Migration<infer id>, ...infer Rest] ? (
+  B extends [Migration<any, infer id>, ...infer Rest] ? (
     id extends ids ? "One of the ids are not unique"[] :
     EnsureUniqueId<A, Rest, id | ids>
   ) : "There exists a migration that is not a Migration"[]

lib/inits/setupInit.ts

@@ -4,7 +4,7 @@ import { Install } from "./setupInstall"
 import { Uninstall } from "./setupUninstall"
 
 export function setupInit<WrapperData>(
-  migrations: Migrations,
+  migrations: Migrations<WrapperData>,
   install: Install<WrapperData>,
   uninstall: Uninstall<WrapperData>,
 ): {

lib/inits/setupInstall.ts

@@ -1,24 +1,38 @@
 import { Effects, ExpectedExports } from "../types"
 import { Utils, utils } from "../util"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
-export type InstallFn<WrapperData> = (opts: {
+export type InstallFn<WD> = (opts: {
   effects: Effects
-  utils: Utils<WrapperData>
+  utils: Utils<WD>
 }) => Promise<void>
-export class Install<WrapperData> {
-  private constructor(readonly fn: InstallFn<WrapperData>) {}
-  static of<WrapperData>(fn: InstallFn<WrapperData>) {
-    return new Install(fn)
+export class Install<WD> {
+  private constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
+    readonly fn: InstallFn<WD>,
+  ) {}
+  static of<WD>(
+    wrapperDataContract: WrapperDataContract<WD>,
+    fn: InstallFn<WD>,
+  ) {
+    return new Install(wrapperDataContract, fn)
   }
 
   async init({
     effects,
     previousVersion,
   }: Parameters<ExpectedExports.init>[0]) {
-    if (!previousVersion) await this.fn({ effects, utils: utils(effects) })
+    if (!previousVersion)
+      await this.fn({
+        effects,
+        utils: utils(this.wrapperDataContract, effects),
+      })
   }
 }
 
-export function setupInstall<WrapperData>(fn: InstallFn<WrapperData>) {
-  return Install.of(fn)
+export function setupInstall<WD>(
+  wrapperDataContract: WrapperDataContract<WD>,
+  fn: InstallFn<WD>,
+) {
+  return Install.of(wrapperDataContract, fn)
 }

lib/inits/setupUninstall.ts

@@ -1,24 +1,38 @@
 import { Effects, ExpectedExports } from "../types"
 import { Utils, utils } from "../util"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 export type UninstallFn<WrapperData> = (opts: {
   effects: Effects
   utils: Utils<WrapperData>
 }) => Promise<void>
-export class Uninstall<WrapperData> {
-  private constructor(readonly fn: UninstallFn<WrapperData>) {}
-  static of<WrapperData>(fn: UninstallFn<WrapperData>) {
-    return new Uninstall(fn)
+export class Uninstall<WD> {
+  private constructor(
+    readonly wrapperDataContract: WrapperDataContract<WD>,
+    readonly fn: UninstallFn<WD>,
+  ) {}
+  static of<WD>(
+    wrapperDataContract: WrapperDataContract<WD>,
+    fn: UninstallFn<WD>,
+  ) {
+    return new Uninstall(wrapperDataContract, fn)
   }
 
   async uninit({
     effects,
     nextVersion,
   }: Parameters<ExpectedExports.uninit>[0]) {
-    if (!nextVersion) await this.fn({ effects, utils: utils(effects) })
+    if (!nextVersion)
+      await this.fn({
+        effects,
+        utils: utils(this.wrapperDataContract, effects),
+      })
   }
 }
 
-export function setupUninstall<WrapperData>(fn: UninstallFn<WrapperData>) {
-  return Uninstall.of(fn)
+export function setupUninstall<WD>(
+  wrapperDataContract: WrapperDataContract<WD>,
+  fn: UninstallFn<WD>,
+) {
+  return Uninstall.of(wrapperDataContract, fn)
 }

lib/mainFn/index.ts

@@ -1,5 +1,5 @@
 import { Effects, ExpectedExports } from "../types"
-import { Utils, utils } from "../util"
+import { createMainUtils, Utils, utils } from "../util"
 import { Daemons } from "./Daemons"
 import "./exportInterfaces"
 import "./LocalBinding"
@@ -11,6 +11,7 @@ import "./TorBinding"
 import "./TorHostname"
 
 import "./Daemons"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 /**
  * Used to ensure that the main function is running with the valid proofs.
@@ -22,17 +23,18 @@ import "./Daemons"
  * @param fn
  * @returns
  */
-export const setupMain = <WrapperData>(
+export const setupMain = <WD>(
+  wrapperDataContract: WrapperDataContract<WD>,
   fn: (o: {
     effects: Effects
     started(onTerm: () => void): null
-    utils: Utils<WrapperData, {}>
+    utils: Utils<WD, {}>
   }) => Promise<Daemons<any>>,
 ): ExpectedExports.main => {
   return async (options) => {
     const result = await fn({
       ...options,
-      utils: utils<WrapperData, {}>(options.effects),
+      utils: createMainUtils(wrapperDataContract, options.effects),
     })
     await result.build().then((x) => x.wait())
   }

lib/test/configBuilder.test.ts

@@ -5,6 +5,10 @@ import { Value } from "../config/builder/value"
 import { Variants } from "../config/builder/variants"
 import { ValueSpec } from "../config/configTypes"
 import { Parser } from "ts-matches"
+import {
+  createWrapperDataContract,
+  neverWrapperDataContract,
+} from "../wrapperData/wrapperDataContract"
 
 type test = unknown | { test: 5 }
 describe("builder tests", () => {
@@ -299,7 +303,7 @@ describe("values", () => {
       utils: "utils",
     } as any
     test("toggle", async () => {
-      const value = Value.dynamicToggle<{}>(async () => ({
+      const value = Value.dynamicToggle(neverWrapperDataContract, async () => ({
         name: "Testing",
         description: null,
         warning: null,
@@ -317,7 +321,7 @@ describe("values", () => {
       })
     })
     test("text", async () => {
-      const value = Value.dynamicText(async () => ({
+      const value = Value.dynamicText(neverWrapperDataContract, async () => ({
         name: "Testing",
         required: { default: null },
       }))
@@ -333,7 +337,7 @@ describe("values", () => {
       })
     })
     test("text with default", async () => {
-      const value = Value.dynamicText(async () => ({
+      const value = Value.dynamicText(neverWrapperDataContract, async () => ({
         name: "Testing",
         required: { default: "this is a default value" },
       }))
@@ -348,7 +352,7 @@ describe("values", () => {
       })
     })
     test("optional text", async () => {
-      const value = Value.dynamicText(async () => ({
+      const value = Value.dynamicText(neverWrapperDataContract, async () => ({
         name: "Testing",
         required: false,
       }))
@@ -364,7 +368,7 @@ describe("values", () => {
       })
     })
     test("color", async () => {
-      const value = Value.dynamicColor<null>(async () => ({
+      const value = Value.dynamicColor(neverWrapperDataContract, async () => ({
         name: "Testing",
         required: false,
         description: null,
@@ -383,17 +387,20 @@ describe("values", () => {
       })
     })
     test("datetime", async () => {
-      const value = Value.dynamicDatetime<{ test: "a" }>(async ({ utils }) => {
-        ;async () => {
-          ;(await utils.getOwnWrapperData("/test").once()) satisfies "a"
-        }
+      const value = Value.dynamicDatetime(
+        createWrapperDataContract<{ test: "a" }>(),
+        async ({ utils }) => {
+          ;async () => {
+            ;(await utils.getOwnWrapperData("/test").once()) satisfies "a"
+          }
 
-        return {
-          name: "Testing",
-          required: { default: null },
-          inputmode: "date",
-        }
-      })
+          return {
+            name: "Testing",
+            required: { default: null },
+            inputmode: "date",
+          }
+        },
+      )
       const validator = value.validator
       validator.unsafeCast("2021-01-01")
       validator.unsafeCast(null)
@@ -408,15 +415,18 @@ describe("values", () => {
       })
     })
     test("textarea", async () => {
-      const value = Value.dynamicTextarea(async () => ({
-        name: "Testing",
-        required: false,
-        description: null,
-        warning: null,
-        minLength: null,
-        maxLength: null,
-        placeholder: null,
-      }))
+      const value = Value.dynamicTextarea(
+        neverWrapperDataContract,
+        async () => ({
+          name: "Testing",
+          required: false,
+          description: null,
+          warning: null,
+          minLength: null,
+          maxLength: null,
+          placeholder: null,
+        }),
+      )
       const validator = value.validator
       validator.unsafeCast("test text")
       expect(() => validator.unsafeCast(null)).toThrowError()
@@ -427,7 +437,7 @@ describe("values", () => {
       })
     })
     test("number", async () => {
-      const value = Value.dynamicNumber(() => ({
+      const value = Value.dynamicNumber(neverWrapperDataContract, () => ({
         name: "Testing",
         required: { default: null },
         integer: false,
@@ -500,7 +510,9 @@ describe("values", () => {
   })
   describe("filtering", () => {
     test("union", async () => {
-      const value = Value.filteredUnion(() => ["a", "c"])(
+      const value = Value.filteredUnion(
+        neverWrapperDataContract,
+        () => ["a", "c"],
         {
           name: "Testing",
           required: { default: null },
@@ -608,7 +620,7 @@ describe("Builder List", () => {
   describe("dynamic", () => {
     test("text", async () => {
       const value = Value.list(
-        List.dynamicText(() => ({
+        List.dynamicText(neverWrapperDataContract, () => ({
           name: "test",
           spec: { patterns: [] },
         })),
@@ -626,7 +638,7 @@ describe("Builder List", () => {
   })
   test("number", async () => {
     const value = Value.list(
-      List.dynamicNumber(() => ({
+      List.dynamicNumber(neverWrapperDataContract, () => ({
         name: "test",
         spec: { integer: true },
       })),

lib/test/wrapperData.test.ts

@@ -1,11 +1,13 @@
 import { Effects } from "../types"
-import { utils } from "../util"
+import { createMainUtils, utils } from "../util"
+import { createWrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 type WrapperType = {
   config: {
     someValue: "a" | "b"
   }
 }
+const wrapperDataContract = createWrapperDataContract<WrapperType>()
 const todo = <A>(): A => {
   throw new Error("not implemented")
 }
@@ -13,23 +15,23 @@ const noop = () => {}
 describe("wrapperData", () => {
   test("types", async () => {
     ;async () => {
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData("/config", {
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData("/config", {
         someValue: "a",
       })
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData(
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData(
         "/config/someValue",
         "b",
       )
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData("", {
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData("", {
         config: { someValue: "b" },
       })
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData(
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData(
         "/config/someValue",
 
         // @ts-expect-error Type is wrong for the setting value
         5,
       )
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData(
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData(
         // @ts-expect-error Path is wrong
         "/config/someVae3lue",
         "someValue",
@@ -50,47 +52,47 @@ describe("wrapperData", () => {
         path: "/config/some2Value",
         value: "a",
       })
-      ;(await utils<WrapperType, {}>(todo<Effects>())
+      ;(await createMainUtils(wrapperDataContract, todo<Effects>())
         .getOwnWrapperData("/config/someValue")
         .const()) satisfies string
-      ;(await utils<WrapperType, {}>(todo<Effects>())
+      ;(await createMainUtils(wrapperDataContract, todo<Effects>())
         .getOwnWrapperData("/config")
         .const()) satisfies WrapperType["config"]
-      await utils<WrapperType, {}>(todo<Effects>())
+      await createMainUtils(wrapperDataContract, todo<Effects>())
         // @ts-expect-error Path is wrong
         .getOwnWrapperData("/config/somdsfeValue")
         .const()
       ///  ----------------- ERRORS -----------------
 
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData("", {
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData("", {
         // @ts-expect-error Type is wrong for the setting value
         config: { someValue: "notInAOrB" },
       })
-      utils<WrapperType>(todo<Effects>()).setOwnWrapperData(
+      utils(wrapperDataContract, todo<Effects>()).setOwnWrapperData(
         "/config/someValue",
         // @ts-expect-error Type is wrong for the setting value
         "notInAOrB",
       )
-      ;(await utils<WrapperType>(todo<Effects>())
+      ;(await utils(wrapperDataContract, todo<Effects>())
         .getOwnWrapperData("/config/someValue")
         // @ts-expect-error Const should normally not be callable
         .const()) satisfies string
-      ;(await utils<WrapperType>(todo<Effects>())
+      ;(await utils(wrapperDataContract, todo<Effects>())
         .getOwnWrapperData("/config")
         // @ts-expect-error Const should normally not be callable
         .const()) satisfies WrapperType["config"]
-      await utils<WrapperType>(todo<Effects>())
+      await utils(wrapperDataContract, todo<Effects>())
         // @ts-expect-error Path is wrong
         .getOwnWrapperData("/config/somdsfeValue")
         // @ts-expect-error Const should normally not be callable
         .const()
 
       ///
-      ;(await utils<WrapperType>(todo<Effects>())
+      ;(await utils(wrapperDataContract, todo<Effects>())
         .getOwnWrapperData("/config/someValue")
         // @ts-expect-error satisfies type is wrong
         .const()) satisfies number
-      ;(await utils<WrapperType, {}>(todo<Effects>())
+      ;(await createMainUtils(wrapperDataContract, todo<Effects>())
         // @ts-expect-error Path is wrong
         .getOwnWrapperData("/config/")
         .const()) satisfies WrapperType["config"]

lib/util/index.ts

@@ -2,7 +2,7 @@ import { Parser, string } from "ts-matches"
 import * as T from "../types"
 import FileHelper from "./fileHelper"
 import nullIfEmpty from "./nullIfEmpty"
-import { GetWrapperData, getWrapperData } from "./getWrapperData"
+import { GetWrapperData, getWrapperData } from "../wrapperData/getWrapperData"
 import {
   CheckResult,
   checkPortListening,
@@ -13,7 +13,7 @@ import { GetSystemSmtp } from "./GetSystemSmtp"
 
 import "./nullIfEmpty"
 import "./fileHelper"
-import "./getWrapperData"
+import "../wrapperData/getWrapperData"
 import "./deepEqual"
 import "./deepMerge"
 import "./once"
@@ -23,6 +23,7 @@ import { NetworkBuilder } from "../mainFn/NetworkBuilder"
 import { TorHostname } from "../mainFn/TorHostname"
 import { DefaultString } from "../config/configTypes"
 import { getDefaultString } from "./getDefaultString"
+import { WrapperDataContract } from "../wrapperData/wrapperDataContract"
 
 // prettier-ignore
 export type FlattenIntersection<T> = 
@@ -37,12 +38,6 @@ export const isKnownError = (e: unknown): e is T.KnownError =>
 
 declare const affine: unique symbol
 
-export type WrapperDataOptionals<WrapperData, Path extends string> = {
-  validator?: Parser<unknown, ExtractWrapperData<WrapperData, Path>>
-  /** Defaults to what ever the package currently in */
-  packageId?: string | undefined
-}
-
 export type Utils<WD, WrapperOverWrite = { const: never }> = {
   createOrUpdateVault: (opts: {
     key: string
@@ -88,9 +83,10 @@ export type Utils<WD, WrapperOverWrite = { const: never }> = {
   torHostName: (id: string) => TorHostname
   nullIfEmpty: typeof nullIfEmpty
 }
-export const utils = <WrapperData = never, WrapperOverWrite = { const: never }>(
+export const utils = <WD = never, WrapperOverWrite = { const: never }>(
+  _wrapperDataContract: WrapperDataContract<WD>,
   effects: T.Effects,
-): Utils<WrapperData, WrapperOverWrite> => ({
+): Utils<WD, WrapperOverWrite> => ({
   createOrUpdateVault: async ({
     key,
     value,
@@ -125,12 +121,12 @@ export const utils = <WrapperData = never, WrapperOverWrite = { const: never }>(
       packageId,
     }) as any,
   getOwnWrapperData: <Path extends string>(
-    path: T.EnsureWrapperDataPath<WrapperData, Path>,
-  ) => getWrapperData<WrapperData, Path>(effects, path as any) as any,
+    path: T.EnsureWrapperDataPath<WD, Path>,
+  ) => getWrapperData<WD, Path>(effects, path as any) as any,
   setOwnWrapperData: <Path extends string | never>(
-    path: T.EnsureWrapperDataPath<WrapperData, Path>,
-    value: ExtractWrapperData<WrapperData, Path>,
-  ) => effects.setWrapperData<WrapperData, Path>({ value, path: path as any }),
+    path: T.EnsureWrapperDataPath<WD, Path>,
+    value: ExtractWrapperData<WD, Path>,
+  ) => effects.setWrapperData<WD, Path>({ value, path: path as any }),
   checkPortListening: checkPortListening.bind(null, effects),
   checkWebUrl: checkWebUrl.bind(null, effects),
   bindLan: async (port: number) => LocalPort.bindLan(effects, port),
@@ -138,6 +134,12 @@ export const utils = <WrapperData = never, WrapperOverWrite = { const: never }>(
   torHostName: (id: string) => TorHostname.of(effects, id),
 })
 
+export const createUtils = utils
+export const createMainUtils = <WD>(
+  wrapperDataContract: WrapperDataContract<WD>,
+  effects: T.Effects,
+) => createUtils<WD, {}>(wrapperDataContract, effects)
+
 type NeverPossible = { [affine]: string }
 export type NoAny<A> = NeverPossible extends A
   ? keyof NeverPossible extends keyof A

lib/wrapperData/getWrapperData.ts

@@ -1,6 +1,6 @@
 import { Parser } from "ts-matches"
 import { Effects, EnsureWrapperDataPath, ExtractWrapperData } from "../types"
-import { NoAny } from "."
+import { NoAny } from "../util"
 
 export class GetWrapperData<WrapperData, Path extends string> {
   constructor(

lib/wrapperData/wrapperDataContract.ts

@@ -0,0 +1,14 @@
+export declare const wrapperDataContractType: unique symbol
+export type WrapperDataContract<A> = {
+  [wrapperDataContractType]: A
+}
+export const neverWrapperDataContract: WrapperDataContract<never> = null as any
+/**
+ * Used to indicate the type of the wrapper data. To be used in areas where
+ * we need to know the wrapper data value
+ */
+export function createWrapperDataContract<A = never>(): A extends never
+  ? "Wrapper Data Contract must be created with a generic"
+  : WrapperDataContract<A> {
+  return null as any
+}