@start9labs/start-sdk 0.4.0-beta.3 → 0.4.0-beta.31

package/package/lib/StartSdk.d.ts

@@ -1,54 +1,49 @@
 import { Value } from "../../base/lib/actions/input/builder/value";
-import { InputSpec, LazyBuild } from "../../base/lib/actions/input/builder/inputSpec";
-import { DefaultString, ListValueSpecText, Pattern, RandomString, ValueSpecDatetime, ValueSpecText } from "../../base/lib/actions/input/inputSpecTypes";
+import { InputSpec } from "../../base/lib/actions/input/builder/inputSpec";
 import { Variants } from "../../base/lib/actions/input/builder/variants";
-import { Action, Actions } from "../../base/lib/actions/setupActions";
-import { SyncOptions, ServiceInterfaceId, PackageId, ServiceInterfaceType, Effects } from "../../base/lib/types";
+import { Action, ActionInfo, Actions } from "../../base/lib/actions/setupActions";
+import { ServiceInterfaceId, PackageId, ServiceInterfaceType, Effects } from "../../base/lib/types";
 import * as patterns from "../../base/lib/util/patterns";
 import { BackupSync, Backups } from "./backup/Backups";
-import { Daemons } from "./mainFn/Daemons";
-import { HealthCheck } from "./health/HealthCheck";
+import { Daemon, Daemons } from "./mainFn/Daemons";
 import { checkPortListening } from "./health/checkFns/checkPortListening";
 import { List } from "../../base/lib/actions/input/builder/list";
-import { InstallFn, PostInstall, PreInstall } from "./inits/setupInstall";
 import { SetupBackupsParams } from "./backup/setupBackups";
-import { UninstallFn } from "./inits/setupUninstall";
 import { changeOnFirstSuccess, cooldownTrigger } from "./trigger";
-import { UpdateServiceInterfaces } from "../../base/lib/interfaces/setupInterfaces";
 import { MultiHost, Scheme } from "../../base/lib/interfaces/Host";
 import { ServiceInterfaceBuilder } from "../../base/lib/interfaces/ServiceInterfaceBuilder";
 import { GetSystemSmtp } from "./util";
 import { nullIfEmpty } from "./util";
-import { CommandOptions, MountOptions, SubContainer } from "./util/SubContainer";
+import { CommandOptions, SubContainer, SubContainerOwned } from "./util/SubContainer";
 import { Mounts } from "./mainFn/Mounts";
 import * as T from "../../base/lib/types";
-import { ExposedStorePaths } from "./store/setupExposeStore";
-import { PathBuilder } from "../../base/lib/util/PathBuilder";
 import { CheckDependencies } from "../../base/lib/dependencies/dependencies";
 import { GetSslCertificate } from "./util";
-import { VersionGraph } from "./version";
+import { getDataVersion, setDataVersion } from "./version";
 import { MaybeFn } from "../../base/lib/actions/setupActions";
 import { GetInput } from "../../base/lib/actions/setupActions";
 import { Run } from "../../base/lib/actions/setupActions";
 import * as actions from "../../base/lib/actions";
-export declare const OSVersion: "0.4.0-alpha.0";
+import { setupInit, setupUninit, setupOnInit, setupOnUninit } from "../../base/lib/inits";
+export declare const OSVersion: "0.4.0-alpha.7";
 type AnyNeverCond<T extends any[], Then, Else> = T extends [] ? Else : T extends [never, ...Array<any>] ? Then : T extends [any, ...infer U] ? AnyNeverCond<U, Then, Else> : never;
-export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
+export declare class StartSdk<Manifest extends T.SDKManifest> {
     readonly manifest: Manifest;
     private constructor();
-    static of(): StartSdk<never, never>;
-    withManifest<Manifest extends T.SDKManifest = never>(manifest: Manifest): StartSdk<Manifest, Store>;
-    withStore<Store extends Record<string, any>>(): StartSdk<Manifest, Store>;
-    build(isReady: AnyNeverCond<[Manifest, Store], "Build not ready", true>): {
+    static of(): StartSdk<never>;
+    withManifest<Manifest extends T.SDKManifest = never>(manifest: Manifest): StartSdk<Manifest>;
+    build(isReady: AnyNeverCond<[Manifest], "Build not ready", true>): {
+        setDataVersion: typeof setDataVersion;
+        getDataVersion: typeof getDataVersion;
         action: {
             run: <Input extends Record<string, unknown>>(options: {
                 effects: T.Effects;
                 actionId: T.ActionId;
                 input?: actions.RunActionInput<Input>;
             }) => Promise<T.ActionResult | null>;
-            request: <T extends Action<T.ActionId, any, any>>(effects: T.Effects, packageId: T.PackageId, action: T, severity: T.ActionSeverity, options?: actions.ActionRequestOptions<T>) => Promise<null>;
-            requestOwn: <T extends Action<T.ActionId, Store, any>>(effects: T.Effects, action: T, severity: T.ActionSeverity, options?: actions.ActionRequestOptions<T>) => Promise<null>;
-            clearRequest: (effects: T.Effects, ...replayIds: string[]) => Promise<null>;
+            createTask: <T extends ActionInfo<T.ActionId, any>>(effects: T.Effects, packageId: T.PackageId, action: T, severity: T.TaskSeverity, options?: actions.TaskOptions<T>) => Promise<null>;
+            createOwnTask: <T extends ActionInfo<T.ActionId, any>>(effects: T.Effects, action: T, severity: T.TaskSeverity, options?: actions.TaskOptions<T>) => Promise<null>;
+            clearTask: (effects: T.Effects, ...replayIds: string[]) => Promise<null>;
         };
         checkDependencies: <DependencyId extends keyof Manifest["dependencies"] & PackageId = keyof Manifest["dependencies"] & PackageId>(effects: Effects, packageIds?: DependencyId[]) => Promise<CheckDependencies<DependencyId>>;
         serviceInterface: {
@@ -67,26 +62,13 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             once: () => Promise<string>;
             watch: () => AsyncGenerator<string, void, unknown>;
             onChange: (callback: (value: string | null, error?: Error) => void | Promise<void>) => void;
-        };
-        store: {
-            get: <E extends Effects, StoreValue = unknown>(effects: E, packageId: string, path: PathBuilder<Store, StoreValue>) => import("./store/getStore").GetStore<Store, StoreValue>;
-            getOwn: <E extends Effects, StoreValue = unknown>(effects: E, path: PathBuilder<Store, StoreValue>) => import("./store/getStore").GetStore<Store, StoreValue>;
-            setOwn: <E extends Effects, Path extends PathBuilder<Store, unknown>>(effects: E, path: Path, value: Path extends PathBuilder<Store, infer Value> ? Value : never) => Promise<null>;
+            waitFor: (pred: (value: string | null) => boolean) => Promise<string | null>;
         };
         MultiHost: {
             of: (effects: Effects, id: string) => MultiHost;
         };
         nullIfEmpty: typeof nullIfEmpty;
         useEntrypoint: (overrideCmd?: string[]) => T.UseEntrypoint;
-        runCommand: <A extends string>(effects: Effects, image: {
-            imageId: keyof Manifest["images"] & T.ImageId;
-            sharedRun?: boolean;
-        }, command: T.CommandType, options: CommandOptions & {
-            mounts: Mounts<Manifest>;
-        }, name?: string) => Promise<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
-        }>;
         /**
          * @description Use this class to create an Action. By convention, each Action should receive its own file.
          *
@@ -149,7 +131,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               )
              * ```
             */
-            withInput: <Id extends T.ActionId, InputSpecType extends Record<string, any> | InputSpec<any, any> | InputSpec<any, never>>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, inputSpec: InputSpecType, getInput: GetInput<InputSpecType>, run: Run<InputSpecType>) => Action<Id, unknown, InputSpecType>;
+            withInput: <Id extends T.ActionId, Type extends Record<string, any>>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, inputSpec: InputSpec<Type>, getInput: GetInput<Type>, run: Run<Type>) => Action<Id, Type>;
             /**
              * @description Use this function to create an action that does not accept form input
              * @param id - a unique ID for this action
@@ -159,6 +141,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
              * In this example, we create an action that returns a secret phrase for the user to see.
              *
              * ```
+              import { store } from '../file-models/store.json'
               import { sdk } from '../sdk'
     
               export const showSecretPhrase = sdk.Action.withoutInput(
@@ -183,9 +166,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                     'Below is your secret phrase. Use it to gain access to extraordinary places',
                   result: {
                     type: 'single',
-                    value: await sdk.store
-                      .getOwn(effects, sdk.StorePath.secretPhrase)
-                      .const(),
+                    value: (await store.read.once())?.secretPhrase,
                     copyable: true,
                     qr: true,
                     masked: true,
@@ -194,19 +175,19 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               )
              * ```
             */
-            withoutInput: <Id extends T.ActionId>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, run: Run<{}>) => Action<Id, unknown, {}>;
+            withoutInput: <Id extends T.ActionId>(id: Id, metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>, run: Run<{}>) => Action<Id, {}>;
         };
         inputSpecConstants: {
-            smtpInputSpec: Value<import("../../base/lib/actions/input/builder/variants").UnionRes<never, {
+            smtpInputSpec: Value<import("../../base/lib/actions/input/builder/variants").UnionRes<{
                 disabled: {
                     name: string;
-                    spec: InputSpec<{}, Store_1>;
+                    spec: InputSpec<{}>;
                 };
                 system: {
                     name: string;
                     spec: InputSpec<{
                         customFrom: string | null;
-                    }, Store_1>;
+                    }>;
                 };
                 custom: {
                     name: string;
@@ -216,9 +197,9 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                         from: string;
                         login: string;
                         password: string | null | undefined;
-                    }, never>;
+                    }>;
                 };
-            }, "disabled" | "system" | "custom">, never>;
+            }>>;
         };
         /**
          * @description Use this function to create a service interface.
@@ -237,7 +218,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             schemeOverride: null,
             username: null,
             path: '',
-            search: {},
+            query: {},
           })
          * ```
          */
@@ -248,14 +229,14 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             id: string;
             /** The human readable description. */
             description: string;
-            /** Affects how the interface appears to the user. One of: 'ui', 'api', 'p2p'. If 'ui', the user will see a "Launch UI" button */
+            /** Affects how the interface appears to the user. One of: 'ui', 'api', 'p2p'. If 'ui', the user will see an option to open the UI in a new tab */
             type: ServiceInterfaceType;
             /** (optional) prepends the provided username to all URLs. */
             username: null | string;
             /** (optional) appends the provided path to all URLs. */
             path: string;
             /** (optional) appends the provided query params to all URLs. */
-            search: Record<string, string>;
+            query: Record<string, string>;
             /** (optional) overrides the protocol prefix provided by the bind function.
              *
              * @example `ftp://`
@@ -269,7 +250,6 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
         }) => ServiceInterfaceBuilder;
         getSystemSmtp: <E extends Effects>(effects: E) => GetSystemSmtp;
         getSslCerificate: <E extends Effects>(effects: E, hostnames: string[], algorithm?: T.Algorithm) => GetSslCertificate;
-        HealthCheck: typeof HealthCheck;
         healthCheck: {
             checkPortListening: typeof checkPortListening;
             checkWebUrl: (effects: Effects, url: string, { timeout, successMessage, errorMessage, }?: {
@@ -277,7 +257,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 successMessage?: string | undefined;
                 errorMessage?: string | undefined;
             }) => Promise<import("./health/checkFns").HealthCheckResult>;
-            runHealthScript: (runCommand: string[], subcontainer: SubContainer, { timeout, errorMessage, message, }?: {
+            runHealthScript: <Manifest_1 extends T.SDKManifest>(runCommand: string[], subcontainer: SubContainer<Manifest_1>, { timeout, errorMessage, message, }?: {
                 timeout?: number | undefined;
                 errorMessage?: string | undefined;
                 message?: ((res: string) => string) | undefined;
@@ -299,8 +279,8 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          * ```
          */
         Actions: {
-            new (actions: {}): Actions<Store, {}>;
-            of<Store_2>(): Actions<Store_2, {}>;
+            new (actions: {}): Actions<{}>;
+            of(): Actions<{}>;
         };
         /**
          * @description Use this function to determine which volumes are backed up when a user creates a backup, including advanced options.
@@ -329,16 +309,16 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          */
         setupBackups: (options: SetupBackupsParams<Manifest>) => {
             createBackup: T.ExpectedExports.createBackup;
-            restoreBackup: T.ExpectedExports.restoreBackup;
+            restoreInit: import("../../base/lib/inits").InitScript;
         };
         /**
          * @description Use this function to set dependency information.
          * @example
-         * In this example, we create a perpetual dependency on Hello World >=1.0.0:0, where Hello World must be running and passing its "primary" health check.
+         * In this example, we create a dependency on Hello World >=1.0.0:0, where Hello World must be running and passing its "primary" health check.
          *
          * ```
           export const setDependencies = sdk.setupDependencies(
-            async ({ effects, input }) => {
+            async ({ effects }) => {
               return {
                 'hello-world': {
                   kind: 'running',
@@ -349,76 +329,59 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             },
           )
          * ```
-         * @example
-         * In this example, we create a conditional dependency on Hello World based on a hypothetical "needsWorld" boolean in our Store.
-         * Using .const() ensures that if the "needsWorld" boolean changes, setupDependencies will re-run.
-         *
-         * ```
-          export const setDependencies = sdk.setupDependencies(
-            async ({ effects }) => {
-              if (sdk.store.getOwn(sdk.StorePath.needsWorld).const()) {
-                return {
-                  'hello-world': {
-                    kind: 'running',
-                    versionRange: '>=1.0.0',
-                    healthChecks: ['primary'],
-                  },
-                }
-              }
-              return {}
-            },
-          )
-         * ```
          */
         setupDependencies: (fn: (options: {
             effects: T.Effects;
-        }) => Promise<T.CurrentDependenciesResult<Manifest>>) => (options: {
-            effects: T.Effects;
-        }) => Promise<null>;
-        setupInit: (versions: VersionGraph<string>, preInstall: PreInstall<Manifest, Store>, postInstall: PostInstall<Manifest, Store>, uninstall: import("./inits/setupUninstall").Uninstall<Manifest, Store>, setServiceInterfaces: UpdateServiceInterfaces<any>, setDependencies: (options: {
-            effects: T.Effects;
-        }) => Promise<null | void | undefined>, actions: Actions<Store, any>, initStore: Store, exposedStore: ExposedStorePaths) => {
-            packageInit: T.ExpectedExports.packageInit;
-            packageUninit: T.ExpectedExports.packageUninit;
-            containerInit: T.ExpectedExports.containerInit;
-        };
+        }) => Promise<T.CurrentDependenciesResult<Manifest>>) => (effects: T.Effects) => Promise<null>;
+        /**
+         * @description Use this function to create an InitScript that runs every time the service initializes (install, update, restore, rebuild, and server bootup)
+         */
+        setupOnInit: typeof setupOnInit;
         /**
-         * @description Use this function to execute arbitrary logic *once*, on initial install *before* interfaces, actions, and dependencies are updated.
+         * @description Use this function to create an UninitScript that runs every time the service uninitializes (update, uninstall, and server shutdown)
+         */
+        setupOnUninit: typeof setupOnUninit;
+        /**
+         * @description Use this function to setup what happens when the service initializes.
+         *
+         *    This happens when the server boots, or a service is installed, updated, or restored
+         *
+         *    Not every init script does something on every initialization. For example, versions only does something on install or update
+         *
+         *    These scripts are run in the order they are supplied
          * @example
-         * In the this example, we initialize a config file
          *
          * ```
-          const preInstall = sdk.setupPreInstall(async ({ effects }) => {
-            await configFile.write(effects, { name: 'World' })
-          })
+          export const init = sdk.setupInit(
+            restoreInit,
+            versions,
+            setDependencies,
+            setInterfaces,
+            actions,
+            postInstall,
+          )
          * ```
          */
-        setupPreInstall: (fn: InstallFn<Manifest, Store>) => PreInstall<Manifest, Store>;
+        setupInit: typeof setupInit;
         /**
-         * @description Use this function to execute arbitrary logic *once*, on initial install *after* interfaces, actions, and dependencies are updated.
+         * @description Use this function to setup what happens when the service uninitializes.
+         *
+         *    This happens when the server shuts down, or a service is uninstalled or updated
+         *
+         *    Not every uninit script does something on every uninitialization. For example, versions only does something on uninstall or update
+         *
+         *    These scripts are run in the order they are supplied
          * @example
-         * In the this example, we bootstrap our Store with a random, 16-char admin password.
          *
          * ```
-          const postInstall = sdk.setupPostInstall(async ({ effects }) => {
-            await sdk.store.setOwn(
-              effects,
-              sdk.StorePath.adminPassword,
-              utils.getDefaultString({
-                charset: 'a-z,A-Z,1-9,!,@,$,%,&,',
-                len: 16,
-              }),
-            )
-          })
+          export const uninit = sdk.setupUninit(
+            versions,
+          )
          * ```
          */
-        setupPostInstall: (fn: InstallFn<Manifest, Store>) => PostInstall<Manifest, Store>;
+        setupUninit: typeof setupUninit;
         /**
          * @description Use this function to determine how this service will be hosted and served. The function executes on service install, service update, and inputSpec save.
-         *
-         *   "input" will be of type `Input` for inputSpec save. It will be `null` for install and update.
-         *
-         *   To learn about creating multi-hosts and interfaces, check out the {@link https://docs.start9.com/packaging-guide/learn/interfaces documentation}.
          * @param inputSpec - The inputSpec spec of this service as exported from /inputSpec/spec.
          * @param fn - an async function that returns an array of interface receipts. The function always has access to `effects`; it has access to `input` only after inputSpec save, otherwise `input` will be null.
          * @example
@@ -426,8 +389,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
          *
          * ```
           export const setInterfaces = sdk.setupInterfaces(
-            inputSpecSpec,
-            async ({ effects, input }) => {
+            async ({ effects }) => {
               // ** UI multi-host **
               const uiMulti = sdk.MultiHost.of(effects, 'ui-multi')
               const uiMultiOrigin = await uiMulti.bindPort(80, {
@@ -443,7 +405,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '',
-                search: {},
+                query: {},
               })
               // Admin UI
               const adminUi = sdk.createInterface(effects, {
@@ -455,7 +417,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '/admin',
-                search: {},
+                query: {},
               })
               // UI receipt
               const uiReceipt = await uiMultiOrigin.export([primaryUi, adminUi])
@@ -475,7 +437,7 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
                 schemeOverride: null,
                 username: null,
                 path: '',
-                search: {},
+                query: {},
               })
               // API receipt
               const apiReceipt = await apiMultiOrigin.export([api])
@@ -491,10 +453,6 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             effects: Effects;
             started(onTerm: () => PromiseLike<void>): PromiseLike<null>;
         }) => Promise<Daemons<Manifest, any>>) => T.ExpectedExports.main;
-        /**
-         * Use this function to execute arbitrary logic *once*, on uninstall only. Most services will not use this.
-         */
-        setupUninstall: (fn: UninstallFn<Manifest, Store>) => import("./inits/setupUninstall").Uninstall<Manifest, Store>;
         trigger: {
             defaultTrigger: import("./trigger").Trigger;
             cooldownTrigger: typeof cooldownTrigger;
@@ -505,12 +463,12 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             }) => import("./trigger").Trigger;
         };
         Mounts: {
-            of(): Mounts<Manifest>;
+            of: () => Mounts<Manifest, never>;
         };
         Backups: {
-            volumes: (...volumeNames: Array<Manifest["volumes"][number] & string>) => Backups<Manifest>;
-            addSets: (...options: BackupSync<Manifest["volumes"][number] & string>[]) => Backups<Manifest>;
-            withOptions: (options?: Partial<SyncOptions>) => Backups<Manifest>;
+            ofVolumes: (...volumeNames: Manifest["volumes"][number][]) => Backups<Manifest>;
+            ofSyncs: (...syncs: BackupSync<Manifest["volumes"][number]>[]) => Backups<Manifest>;
+            withOptions: (options?: Partial<T.SyncOptions>) => Backups<Manifest>;
         };
         InputSpec: {
             /**
@@ -540,447 +498,41 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
               })
              * ```
              */
-            of: <Spec extends Record<string, Value<any, Store> | Value<any, never>>>(spec: Spec) => InputSpec<{ [K in keyof Spec]: Spec[K] extends Value<infer T, never> | Value<infer T, Store> ? T : never; }, Store>;
+            of: <Spec extends Record<string, Value<any>>>(spec: Spec) => InputSpec<{ [K in keyof Spec]: Spec[K] extends Value<infer T> ? T : never; }>;
+        };
+        Daemon: {
+            readonly of: <C extends SubContainer<Manifest, Effects> | null>(effects: T.Effects, subcontainer: C, exec: import("./mainFn/Daemons").DaemonCommandType<Manifest, C>) => Promise<Daemon<Manifest, SubContainer<Manifest, Effects> | null>>;
         };
         Daemons: {
-            of(effects: Effects, started: (onTerm: () => PromiseLike<void>) => PromiseLike<null>, healthChecks: HealthCheck[]): Daemons<Manifest, never>;
+            of(effects: Effects, started: ((onTerm: () => PromiseLike<void>) => PromiseLike<null>) | null): Daemons<Manifest, never>;
         };
         SubContainer: {
+            /**
+             * @description Create a new SubContainer
+             * @param effects
+             * @param image - what container image to use
+             * @param mounts - what to mount to the subcontainer
+             * @param name - a name to use to refer to the subcontainer for debugging purposes
+             */
             of(effects: Effects, image: {
                 imageId: T.ImageId & keyof Manifest["images"];
                 sharedRun?: boolean;
-            }, name: string): Promise<SubContainer>;
-            with<T>(effects: T.Effects, image: {
-                imageId: T.ImageId & keyof Manifest["images"];
-                sharedRun?: boolean;
-            }, mounts: {
-                options: MountOptions;
-                mountpoint: string;
-            }[], name: string, fn: (subContainer: SubContainer) => Promise<T>): Promise<T>;
-        };
-        List: {
-            /**
-             * @description Create a list of text inputs.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
-             */
-            text: typeof List.text;
-            /**
-             * @description Create a list of objects.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
-             */
-            obj: <Type extends Record<string, any>>(a: Parameters<typeof List.obj<Type, Store>>[0], aSpec: Parameters<typeof List.obj<Type, Store>>[1]) => List<Type[], Store>;
+            }, mounts: Mounts<Manifest> | null, name: string): Promise<SubContainerOwned<Manifest, Effects>>;
             /**
-             * @description Create a list of dynamic text inputs.
-             * @param a - attributes of the list itself.
-             * @param aSpec - attributes describing each member of the list.
+             * @description Run a function with a temporary SubContainer
+             * @param effects
+             * @param image - what container image to use
+             * @param mounts - what to mount to the subcontainer
+             * @param name - a name to use to refer to the ephemeral subcontainer for debugging purposes
              */
-            dynamicText: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default?: string[];
-                minLength?: number | null;
-                maxLength?: number | null;
-                disabled?: false | string;
-                generate?: null | RandomString;
-                spec: {
-                    masked?: boolean;
-                    placeholder?: string | null;
-                    minLength?: number | null;
-                    maxLength?: number | null;
-                    patterns?: Pattern[];
-                    inputmode?: ListValueSpecText["inputmode"];
-                };
-            }>) => List<string[], Store>;
-        };
-        StorePath: PathBuilder<Store, Store>;
-        Value: {
-            /**
-             * @description Displays a boolean toggle to enable/disable
-             * @example
-             * ```
-              toggleExample: Value.toggle({
-                // required
-                name: 'Toggle Example',
-                default: true,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            toggle: typeof Value.toggle;
-            /**
-             * @description Displays a text input field
-             * @example
-             * ```
-              textExample: Value.text({
-                // required
-                name: 'Text Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                generate: null,
-                inputmode: 'text',
-                masked: false,
-                minLength: null,
-                maxLength: null,
-                patterns: [],
-                immutable: false,
-              }),
-             * ```
-             */
-            text: typeof Value.text;
-            /**
-             * @description Displays a large textarea field for long form entry.
-             * @example
-             * ```
-              textareaExample: Value.textarea({
-                // required
-                name: 'Textarea Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                minLength: null,
-                maxLength: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            textarea: typeof Value.textarea;
-            /**
-             * @description Displays a number input field
-             * @example
-             * ```
-              numberExample: Value.number({
-                // required
-                name: 'Number Example',
-                required: false,
-                default: null,
-                integer: true,
-             
-                // optional
-                description: null,
-                placeholder: null,
-                warning: null,
-                min: null,
-                max: null,
-                immutable: false,
-                step: null,
-                units: null,
-              }),
-             * ```
-             */
-            number: typeof Value.number;
-            /**
-             * @description Displays a browser-native color selector.
-             * @example
-             * ```
-              colorExample: Value.color({
-                // required
-                name: 'Color Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-              }),
-             * ```
-             */
-            color: typeof Value.color;
-            /**
-             * @description Displays a browser-native date/time selector.
-             * @example
-             * ```
-              datetimeExample: Value.datetime({
-                // required
-                name: 'Datetime Example',
-                required: false,
-                default: null,
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                inputmode: 'datetime-local',
-                min: null,
-                max: null,
-              }),
-             * ```
-             */
-            datetime: typeof Value.datetime;
-            /**
-             * @description Displays a select modal with radio buttons, allowing for a single selection.
-             * @example
-             * ```
-              selectExample: Value.select({
-                // required
-                name: 'Select Example',
-                default: 'radio1',
-                values: {
-                  radio1: 'Radio 1',
-                  radio2: 'Radio 2',
-                },
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                disabled: false,
-              }),
-             * ```
-             */
-            select: typeof Value.select;
-            /**
-             * @description Displays a select modal with checkboxes, allowing for multiple selections.
-             * @example
-             * ```
-              multiselectExample: Value.multiselect({
-                // required
-                name: 'Multiselect Example',
-                values: {
-                  option1: 'Option 1',
-                  option2: 'Option 2',
-                },
-                default: [],
-             
-                // optional
-                description: null,
-                warning: null,
-                immutable: false,
-                disabled: false,
-                minlength: null,
-                maxLength: null,
-              }),
-             * ```
-             */
-            multiselect: typeof Value.multiselect;
-            /**
-             * @description Display a collapsable grouping of additional fields, a "sub form". The second value is the inputSpec spec for the sub form.
-             * @example
-             * ```
-              objectExample: Value.object(
-                {
-                  // required
-                  name: 'Object Example',
-             
-                  // optional
-                  description: null,
-                  warning: null,
-                },
-                InputSpec.of({}),
-              ),
-             * ```
-             */
-            object: typeof Value.object;
-            /**
-             * @description Displays a dropdown, allowing for a single selection. Depending on the selection, a different object ("sub form") is presented.
-             * @example
-             * ```
-              unionExample: Value.union(
-                {
-                  // required
-                  name: 'Union Example',
-                  default: 'option1',
-             
-                  // optional
-                  description: null,
-                  warning: null,
-                  disabled: false,
-                  immutable: false,
-                },
-                Variants.of({
-                  option1: {
-                    name: 'Option 1',
-                    spec: InputSpec.of({}),
-                  },
-                  option2: {
-                    name: 'Option 2',
-                    spec: InputSpec.of({}),
-                  },
-                }),
-              ),
-             * ```
-             */
-            union: typeof Value.union;
-            /**
-             * @description Presents an interface to add/remove/edit items in a list.
-             * @example
-             * In this example, we create a list of text inputs.
-             *
-             * ```
-              listExampleText: Value.list(
-                List.text(
-                  {
-                    // required
-                    name: 'Text List',
-    
-                    // optional
-                    description: null,
-                    warning: null,
-                    default: [],
-                    minLength: null,
-                    maxLength: null,
-                  },
-                  {
-                    // required
-                    patterns: [],
-    
-                    // optional
-                    placeholder: null,
-                    generate: null,
-                    inputmode: 'url',
-                    masked: false,
-                    minLength: null,
-                    maxLength: null,
-                  },
-                ),
-              ),
-             * ```
-             * @example
-             * In this example, we create a list of objects.
-             *
-             * ```
-              listExampleObject: Value.list(
-                List.obj(
-                  {
-                    // required
-                    name: 'Object List',
-    
-                    // optional
-                    description: null,
-                    warning: null,
-                    default: [],
-                    minLength: null,
-                    maxLength: null,
-                  },
-                  {
-                    // required
-                    spec: InputSpec.of({}),
-    
-                    // optional
-                    displayAs: null,
-                    uniqueBy: null,
-                  },
-                ),
-              ),
-             * ```
-             */
-            list: typeof Value.list;
-            hidden: typeof Value.hidden;
-            dynamicToggle: (a: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: boolean;
-                disabled?: false | string;
-            }>) => Value<boolean, Store>;
-            dynamicText: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: DefaultString | null;
-                required: boolean;
-                masked?: boolean;
-                placeholder?: string | null;
-                minLength?: number | null;
-                maxLength?: number | null;
-                patterns?: Pattern[];
-                inputmode?: ValueSpecText["inputmode"];
-                disabled?: string | false;
-                generate?: null | RandomString;
-            }>) => Value<string | null, Store>;
-            dynamicTextarea: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                minLength?: number | null;
-                maxLength?: number | null;
-                placeholder?: string | null;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicNumber: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: number | null;
-                required: boolean;
-                min?: number | null;
-                max?: number | null;
-                step?: number | null;
-                integer: boolean;
-                units?: string | null;
-                placeholder?: string | null;
-                disabled?: false | string;
-            }>) => Value<number | null, Store>;
-            dynamicColor: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicDatetime: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string | null;
-                required: boolean;
-                inputmode?: ValueSpecDatetime["inputmode"];
-                min?: string | null;
-                max?: string | null;
-                disabled?: false | string;
-            }>) => Value<string | null, Store>;
-            dynamicSelect: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string;
-                values: Record<string, string>;
-                disabled?: false | string | string[];
-            }>) => Value<string, Store>;
-            dynamicMultiselect: (getA: LazyBuild<Store, {
-                name: string;
-                description?: string | null;
-                warning?: string | null;
-                default: string[];
-                values: Record<string, string>;
-                minLength?: number | null;
-                maxLength?: number | null;
-                disabled?: false | string | string[];
-            }>) => Value<string[], Store>;
-            filteredUnion: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store> | InputSpec<any, never>;
-            }; }>(getDisabledFn: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[0], a: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[1], aVariants: Parameters<typeof Value.filteredUnion<VariantValues, Store>>[2]) => Value<import("../../base/lib/actions/input/builder/variants").UnionRes<Store, VariantValues, keyof VariantValues & string> | import("../../base/lib/actions/input/builder/variants").UnionRes<never, VariantValues, keyof VariantValues & string>, Store>;
-            dynamicUnion: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store> | InputSpec<any, never>;
-            }; }>(getA: Parameters<typeof Value.dynamicUnion<VariantValues, Store>>[0], aVariants: Parameters<typeof Value.dynamicUnion<VariantValues, Store>>[1]) => Value<import("../../base/lib/actions/input/builder/variants").UnionRes<Store, VariantValues, keyof VariantValues & string> | import("../../base/lib/actions/input/builder/variants").UnionRes<never, VariantValues, keyof VariantValues & string>, Store>;
-        };
-        Variants: {
-            of: <VariantValues extends { [K in string]: {
-                name: string;
-                spec: InputSpec<any, Store>;
-            }; }>(a: VariantValues) => Variants<VariantValues, Store>;
+            withTemp<T>(effects: T.Effects, image: {
+                imageId: T.ImageId & keyof Manifest["images"];
+                sharedRun?: boolean;
+            }, mounts: Mounts<Manifest> | null, name: string, fn: (subContainer: SubContainer<Manifest>) => Promise<T>): Promise<T>;
         };
+        List: typeof List;
+        Value: typeof Value;
+        Variants: typeof Variants;
         restart: (effects: Effects) => Promise<null>;
         shutdown: (effects: Effects) => Promise<null>;
         getStatus: (effects: Effects, options: {
@@ -991,19 +543,9 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             dependencies: T.Dependencies;
         }) => Promise<null>;
         getDependencies: (effects: Effects) => Promise<T.DependencyRequirement[]>;
-        mount: (effects: Effects, options: {
-            location: string;
-            target: {
-                packageId: string;
-                volumeId: string;
-                subpath: string | null;
-                readonly: boolean;
-            };
-        }) => Promise<string>;
+        mount: (effects: Effects, options: T.MountParams) => Promise<string>;
         getInstalledPackages: (effects: Effects) => Promise<string[]>;
-        exposeForDependents: (effects: Effects, options: {
-            paths: string[];
-        }) => Promise<null>;
+        setHealth: (effects: Effects, o: T.SetHealth) => Promise<null>;
         getServicePortForward: (effects: Effects, options: {
             packageId?: PackageId;
             hostId: T.HostId;
@@ -1020,10 +562,6 @@ export declare class StartSdk<Manifest extends T.SDKManifest, Store> {
             hostnames: string[];
             algorithm?: "ecdsa" | "ed25519";
         }) => Promise<string>;
-        setDataVersion: (effects: Effects, options: {
-            version: string;
-        }) => Promise<null>;
-        getDataVersion: (effects: Effects) => Promise<string | null>;
         manifest: Manifest;
     };
 }
@@ -1031,7 +569,7 @@ export declare function runCommand<Manifest extends T.SDKManifest>(effects: Effe
     imageId: keyof Manifest["images"] & T.ImageId;
     sharedRun?: boolean;
 }, command: T.CommandType, options: CommandOptions & {
-    mounts: Mounts<Manifest>;
+    mounts: Mounts<Manifest> | null;
 }, name?: string): Promise<{
     stdout: string | Buffer;
     stderr: string | Buffer;