tungsten 0.7.2 → 0.8.0

package/dist-ti/standardSchema.d.ts

@@ -0,0 +1,38 @@
+// @tightscript-object-permissions
+export type StandardSchemaPathSegment = {
+    readonly key: PropertyKey;
+};
+export type StandardSchemaIssue = {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | StandardSchemaPathSegment)[] | undefined;
+};
+export type StandardSchemaResult<Output extends object> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardSchemaIssue[];
+};
+export type StandardSchema<Output extends object> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: unknown;
+            readonly output: Output;
+        } | undefined;
+    };
+};
+type Validation<Output extends object> = {
+    success: true;
+    value: Output;
+} | {
+    success: false;
+    problems: string;
+};
+export declare function validate: exact (<Output extends object>(schema: StandardSchema<Output>, value: unknown) => Promise<Validation<Output>>);
+export declare function formatIssues: exact ((issues: readonly StandardSchemaIssue[]) => string);
+export declare function checkIsObject: exact ((location: string, name: string, value: unknown) => void);
+export declare function checkIsStandardSchema: exact ((location: string, name: string, schema: unknown) => void);
+export {};
+//# sourceMappingURL=standardSchema.d.ts.map

package/dist-ti/standardizeWebPath.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function standardizeWebPath: exact ((path: string) => string);
+//# sourceMappingURL=standardizeWebPath.d.ts.map

package/dist-ti/startDevServer.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=startDevServer.d.ts.map

package/dist-ti/stateTracking.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A monotonic clock for state writes, so a component can ask "has anything inside this
+ * object changed since I last rendered?".
+ *
+ * Needed because deep state is mutated in place: when a child's prop is the same array
+ * the parent already had, comparing before against after tells you nothing -- both sides
+ * are the one mutated object. Each proxy stamps the object it mutated with the current
+ * tick, and the props comparison walks down looking for a stamp newer than the child's
+ * last render.
+ *
+ * The stamp is stored under $changed on the object itself rather than in a side table
+ * keyed by identity, so it can be read straight back through the proxy -- the raw target
+ * is not always the object a caller holds, since adoption copies state shallowly.
+ * Symbols are invisible to Object.keys and JSON, so the stamp does not leak into user data.
+ *
+ * Stamps are deliberately not propagated to ancestors: a write would then have to touch
+ * every object above it. The cost is moved to update time, where the walk can stop at the
+ * first changed node it finds.
+ *
+ * No imports here on purpose -- the proxy handlers depend on this, so it must stay a leaf.
+ */
+// @tightscript-object-permissions
+export declare const $changed: unique symbol;
+/**
+ * Re-reads the global. Called once per update rather than per node: the global lookup is
+ * cheap in isolation but showed up as 12% of a 50k-row update when it ran for every dom
+ * node, which is the instrumentation distorting what it measures. Toggling __TW_TRACE from
+ * a console therefore takes effect on the next update rather than immediately.
+ */
+export declare function refreshTracing: exact (() => boolean);
+export declare function tracing: exact (() => boolean);
+/**
+ * Each line carries the time since page load and the time since the previous traced event,
+ * so a stall shows up as a large `+delta` on the line that follows it -- no need to diff
+ * timestamps by hand. The delta is reset whenever tracing is switched back on.
+ */
+export declare function trace: exact ((...args: unknown[]) => void);
+/** current tick; read when recording a render */
+export declare function stateClock: exact (() => number);
+/** called by the state proxies whenever the given object is mutated */
+export declare function markChanged: exact ((target: object) => void);
+/** tick at which this object was last mutated; 0 means never */
+export declare function changedAt: exact ((value: object) => number);
+/** record that a component has rendered with the state as it currently stands */
+export declare function markRendered: exact ((element: object) => void);
+/** tick at which this component last rendered, or undefined if it never has */
+export declare function renderedAt: exact ((element: object) => number | undefined);
+//# sourceMappingURL=stateTracking.d.ts.map

package/dist-ti/staticGen/RouteDefinition.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { RouteKey } from '../routing/RouteTypes.js';
+import type { ContentNode } from '../ContentNode.js';
+export type RouteDefinition = {
+    path: RouteKey;
+    content: ContentNode | string;
+    [key: string]: any;
+};
+//# sourceMappingURL=RouteDefinition.d.ts.map

package/dist-ti/staticGen/getAppRoutes.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import type { AppRoutes } from '../routing/AppRoutes.js';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+export declare function getAppRoutes: exact ((compilationInfo: CompilationInfo, config: FrameworkConfigComplete, quiet?: boolean) => Promise<AppRoutes<any>>);
+//# sourceMappingURL=getAppRoutes.d.ts.map

package/dist-ti/staticGen/staticGen.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Framework } from '../Framework.js';
+export declare function staticGen: exact ((framework: Framework) => rw Promise<void>);
+//# sourceMappingURL=staticGen.d.ts.map

package/dist-ti/staticGen/staticGenFunctions.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { SiteBasePath as SiteBasePath } from '../render/HeadData.js';
+export declare function pathToFileName: exact ((path: string) => string);
+export declare function pathToLink: exact ((path: string, siteBasePath: SiteBasePath) => string);
+export declare function findLinks: exact ((content: string) => string[]);
+export declare function rewriteLinks: exact ((content: string, rewriteMap: Record<string, string>) => string);
+//# sourceMappingURL=staticGenFunctions.d.ts.map

package/dist-ti/style/jssToCss.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function jssToCss: exact ((jss: unknown) => string);
+//# sourceMappingURL=jssToCss.d.ts.map

package/dist-ti/style/styleContent.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import { styleContentSxy } from './styleContentSxy.js';
+export declare const styleContent: exact typeof styleContentSxy;
+//# sourceMappingURL=styleContent.d.ts.map

package/dist-ti/style/styleContentReact.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=styleContentReact.d.ts.map

package/dist-ti/style/styleContentReactClassOrClassname.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=styleContentReactClassOrClassname.d.ts.map

package/dist-ti/style/styleContentSxy.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { CssNames } from '../CssNames.js';
+import { type ContentNode } from '../ContentNode.js';
+export declare function styleContentSxy: exact ((content: ContentNode, styles: CssNames) => ContentNode);
+//# sourceMappingURL=styleContentSxy.d.ts.map

package/dist-ti/style/styleContentSxyClassOrClassname.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=styleContentSxyClassOrClassname.d.ts.map

package/dist-ti/style/styleElementContent.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=styleElementContent.d.ts.map

package/dist-ti/style/unusedStyles.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+import type { CssNames } from '../CssNames.js';
+export type StyleUsage = {
+    styles: CssNames;
+    usedTags: Set<string>;
+    usedClasses: Set<string>;
+};
+export declare function getStyleUsage: exact ((styles: CssNames) => r StyleUsage);
+export declare function reportUnusedStyles: exact (() => rw Promise<void>);
+//# sourceMappingURL=unusedStyles.d.ts.map

package/dist-ti/styleProcessors.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=styleProcessors.d.ts.map

package/dist-ti/symbols.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare const $contentNull: unique symbol;
+export type $ContentNull = typeof $contentNull;
+//# sourceMappingURL=symbols.d.ts.map

package/dist-ti/sync/index.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { ExportsVar, ModuleVar, RequireFunc } from '../CjsTypes.js';
+export declare const deps: exact rw never[];
+export default function cjsModule: exact ((module: ModuleVar, exports: ExportsVar, require: RequireFunc) => void);
+//# sourceMappingURL=index.d.ts.map

package/dist-ti/syncServer/preload.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=preload.d.ts.map

package/dist-ti/testing/contentToString.d.ts

@@ -0,0 +1,14 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+export type ContentToStringOptions = {
+    /** A resolved component's passed children in full, where otherwise children={...} */
+    children?: boolean;
+    /** Fragments as `<>`…`</>`, where otherwise their content stands in their place */
+    fragments?: boolean;
+};
+/**
+ * The tree as JSX. A component host() resolved has its output under it, marked ⤵, and the children
+ * it was passed as a prop; one unresolved holds its passed children, as written.
+ */
+export declare function contentToString: exact ((content: ContentNode, options?: ContentToStringOptions) => string);
+//# sourceMappingURL=contentToString.d.ts.map

package/dist-ti/testing/createTestApp.d.ts

@@ -0,0 +1,72 @@
+// @tightscript-object-permissions
+import type { ConstructPackage, TungstenBaseComponent, TungstenBaseComponentType, TungstenComponentPropsBase } from '../Components.jsx';
+import type { TrueStore } from '../Store/makeStore.js';
+import type { Endpoint, Path } from '../routing/RouteTypes.js';
+import type { ErrorRouteType } from '../routing/ErrorRouteType.js';
+import type { RoutesArray } from '../routing/routesArray.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { Context } from '../context/registerContext.js';
+import type { NetworkedData } from '../routing/routingRegistry.js';
+import { Instance } from '../Instance/Instance.js';
+import { type MountedTungstenRoot } from '../update/integrateUpdateVdom.js';
+import { UpdateScheduler } from '../update/UpdateScheduler.js';
+export type ComponentProps<ComponentType extends TungstenBaseComponentType<any, any>> = InstanceType<ComponentType>['props'];
+export type TestStoreRegistration<Schema extends object> = {
+    getStore: (stores: TrueStore<unknown>[]) => TrueStore<Schema>;
+};
+export type TestStore<Schema extends object> = TrueStore<Schema>;
+export type TestStoreOverride<Schema extends object = object> = {
+    registration: TestStoreRegistration<Schema>;
+    initialize: (store: TrueStore<Schema>) => void | Promise<void>;
+};
+export declare function testStore: exact (<Schema extends object>(registration: TestStoreRegistration<Schema>, initialize: (store: TestStore<Schema>) => void | Promise<void>) => TestStoreOverride<Schema>);
+export type TestAppOptions<Props extends object> = {
+    document?: Document;
+    props?: Props;
+    container?: rw HTMLElement;
+    location?: string;
+    routeParams?: Record<string, string>;
+    routeData?: unknown;
+    globalData?: Record<string, unknown>;
+    stores?: readonly TestStoreOverride<any>[];
+    routes?: TestRoutes | RoutesArray | TestRoutesFunction;
+    fileVersions?: Record<string, string>;
+    context?: Context;
+    networkedData?: NetworkedData;
+};
+type TestRoutesFunction = {
+    routes(reqRes: ReqRes | null, context: Context): TestRoutes | RoutesArray;
+}['routes'];
+export type TestRoutes = {
+    [key in Path]: Endpoint<any, any>;
+} & {
+    '404'?: Endpoint<any, any>;
+    'default'?: Endpoint<any, any>;
+    'error'?: ErrorRouteType;
+};
+export type TestApp<Component extends TungstenBaseComponent> = {
+    readonly document: Document;
+    readonly container: rw HTMLElement;
+    readonly component: rw Component;
+    resolved(): Promise<void>;
+    setProps(props: Component['props']): Promise<void>;
+    unmount(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export type CreateTestAppArgs<Props extends object> = object extends Props ? [options?: TestAppOptions<Props>] : keyof Props extends never ? [options?: TestAppOptions<Props>] : [options: TestAppOptions<Props> & {
+    props: Props;
+}];
+export declare class TestAppImplementation<Component extends TungstenBaseComponent> implements TestApp<Component> {
+    #private;
+    readonly document: Document;
+    readonly container: rw HTMLElement;
+    readonly component: rw Component;
+    constructor(document: Document, container: rw HTMLElement, component: rw Component, instance: Instance, scheduler: UpdateScheduler, root: MountedTungstenRoot<TungstenBaseComponentType<any, any>>, ownsContainer: boolean);
+    resolved: () => Promise<void>;
+    setProps: (props: Component['props']) => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    unmount: () => Promise<void>;
+}
+export declare function createTestApp: exact (<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: CreateTestAppArgs<Props>) => Promise<TestApp<Component>>);
+export {};
+//# sourceMappingURL=createTestApp.d.ts.map

package/dist-ti/testing/display.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function display: exact ((value: unknown, depth?: number) => string);
+//# sourceMappingURL=display.d.ts.map

package/dist-ti/testing/ensure.d.ts

@@ -0,0 +1,120 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+type Kind = 'text' | 'interruptedText' | ElementKind | 'fragment' | 'className' | 'id' | 'children' | `prop:${string}` | 'elements';
+type ElementKind = `html:${string}` | `component:${string}` | SelectKind;
+type SelectKind = `select:${string}`;
+type Test = (seen: unknown) => boolean;
+type Failure = {
+    actual: unknown;
+    expected: unknown;
+    saw: string;
+    showDiff: boolean;
+};
+type TrackFn = (match: boolean) => boolean | void;
+type DecideFn = (ofKind: number) => Failure | undefined;
+type Requirement = () => [track: TrackFn, decide: DecideFn];
+type Fact = [
+    Kind,
+    Test,
+    Requirement,
+    quantifier: string,
+    end: string,
+    spoken: string,
+    explain?: Explain | undefined
+];
+type Explain = (seen: unknown) => Outcome | undefined;
+type Outcome = 'not content' | {
+    misses: Miss[];
+    met: BuiltFact[];
+    score: number;
+};
+type Miss = {
+    fact: BuiltFact;
+    failure: Failure;
+    sightings: Sighting[];
+};
+export type EnsureOptions = {
+    readable?: boolean;
+    color?: boolean;
+};
+type Props = Record<string, unknown> & {
+    children?: ContentNode;
+};
+type WithFn = (props: Props) => boolean;
+declare const property: unique symbol;
+type PropertyFact = Fact & {
+    readonly [property]: true;
+};
+type Made<Scope extends Fact | undefined, Own extends Fact> = [Scope] extends [Fact] ? Scope : Own;
+type Quantifiers<E> = {
+    readonly no: E;
+    readonly none: E;
+    readonly one: E;
+    readonly two: E;
+    readonly three: E;
+    readonly count: (num: number) => E;
+    readonly a: E;
+    readonly an: E;
+    readonly some: E;
+    readonly all: E;
+};
+type StringEnd<F extends Fact> = ((text: string) => F) & {
+    contains: (substring: string) => F;
+    matches: (regex: RegExp) => F;
+};
+type ElementEnd<F extends Fact> = F & {
+    with: ((facts: PropertyFact[] | WithFn) => F) & Quantifiers<PropertyEnds<F>> & {
+        children: ((facts: Fact[]) => F) & Quantifiers<Ends<F>>;
+    };
+};
+type PropEnd<F extends Fact> = F & {
+    is: (value: unknown) => F;
+    contains: (substring: string) => F;
+    matches: (regex: RegExp) => F;
+    exact: (value: unknown) => F;
+    subset: (shape: unknown) => F;
+    duck: (shape: unknown) => F;
+    content: () => F & {
+        with: ((facts: Fact[]) => F) & Quantifiers<Ends<F>>;
+    };
+};
+type Ends<Scope extends Fact | undefined = undefined> = {
+    text: StringEnd<Made<Scope, Fact>>;
+    textCi: StringEnd<Made<Scope, Fact>>;
+    interruptedText: StringEnd<Made<Scope, PropertyFact>>;
+    html: (tag: string) => ElementEnd<Made<Scope, Fact>>;
+    component: (name: string) => ElementEnd<Made<Scope, Fact>>;
+    select: (selector: string) => ElementEnd<Made<Scope, Fact>>;
+    fragment: () => Made<Scope, Fact>;
+    className: (className?: string) => Made<Scope, PropertyFact>;
+    id: (id?: string) => Made<Scope, PropertyFact>;
+    prop: (prop: string) => PropEnd<Made<Scope, PropertyFact>>;
+};
+declare const propertyEnds: readonly ['interruptedText', 'className', 'id', 'prop'];
+type PropertyEnds<F extends Fact> = Pick<Ends<F>, typeof propertyEnds[number]>;
+declare const _ensure: typeof ensure & r Quantifiers<r Ends<undefined>>;
+export { _ensure as ensure };
+export declare const { no, none, one, two, three, a, an, some, all, count }: typeof ensure & r Quantifiers<r Ends<undefined>>;
+export declare class EnsureError extends Error {
+    actual: unknown;
+    expected: unknown;
+    operator: string;
+    showDiff: boolean;
+    name: string;
+    constructor(message: string, actual: unknown, expected: unknown, operator: string, showDiff: boolean);
+}
+declare function ensure: exact ((tree: ContentNode, facts: Fact[], options?: EnsureOptions) => void);
+export declare const children: ((facts: Fact[]) => PropertyFact) & r Quantifiers<r Ends<PropertyFact>>;
+type BuiltFact = {
+    kind: Kind;
+    test: Test;
+    track: TrackFn;
+    decide: DecideFn;
+    explain: Explain | undefined;
+    chained: string;
+    spoken: string;
+    operator: string;
+};
+type Sighting = ['text', string] | [Exclude<Kind, 'text'>, unknown];
+export declare const cssSelectBundle: string;
+//# sourceMappingURL=ensure.d.ts.map

package/dist-ti/testing/ensure.trial.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=ensure.trial.d.ts.map

package/dist-ti/testing/helpers/contentHtmlElements.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import { type ContentNode, type ContentNodeHtml } from '../../ContentNode.js';
+export declare const contentHtmlElements: (content: ContentNode) => ContentNodeHtml[];
+//# sourceMappingURL=contentHtmlElements.d.ts.map

package/dist-ti/testing/host.d.ts

@@ -0,0 +1,189 @@
+// @tightscript-object-permissions
+import type { ContentNode, ContentNodeElement } from '../ContentNode.js';
+import type { InternalStoreSchema } from '../Store/InternalStoreSchema.js';
+import type { TrueStore } from '../Store/makeStore.js';
+import type { Routes } from '../routing/Routes.js';
+import type { RoutesFunction } from '../routing/RoutesFunction.js';
+import type { Path, RouteKey } from '../routing/RouteTypes.js';
+import { type ComponentStore, type TungstenComponent, type TungstenComponentClass, type TungstenComponentPropsBase, type TungstenStatefulComponent, TungstenBaseComponent, TungstenSimpleComponent } from '../Components.jsx';
+type StateOf<Component> = Component extends {
+    state?: infer State;
+} ? State : never;
+type ContentOf<Component extends TungstenBaseComponent<any, any>> = NonNullable<Component['content']> extends (...args: any[]) => infer Result ? Result : ContentNode | Promise<ContentNode>;
+type FrameworkMember = keyof TungstenSimpleComponent<any, any> | keyof TungstenComponent<any, any, any> | keyof TungstenStatefulComponent<any, any, any>;
+type ReservedMember = keyof HostedCore<TungstenBaseComponent<any, any>>;
+export type ComponentApi<Component extends TungstenBaseComponent<any, any>> = {
+    [Key in keyof Component as Key extends FrameworkMember | ReservedMember ? never : NonNullable<Component[Key]> extends (...args: any[]) => any ? Key : never]: Component[Key];
+};
+export type Navigation = {
+    kind: 'goto' | 'redirect';
+    to: string;
+};
+export type StateSetter<Component extends TungstenBaseComponent<any, any>> = (state: StateOf<Component>) => StateOf<Component> | void;
+type HostedCore<Component extends TungstenBaseComponent<any, any>, Content = ContentOf<Component>> = {
+    readonly component: Component;
+    readonly props: Component['props'];
+    readonly state: StateOf<Component>;
+    readonly title: string | undefined;
+    readonly navigations: readonly Navigation[];
+    content: () => Content;
+    updateProps: (props: Component['props']) => Promise<Awaited<Content>>;
+    updateState: (setter: StateSetter<Component>) => Promise<Awaited<Content>>;
+};
+export type Hosted<Component extends TungstenBaseComponent<any, any>> = HostedCore<Component> & ComponentApi<Component>;
+export type HostedResolved<Component extends TungstenBaseComponent<any, any>> = HostedCore<Component, Promise<ContentNode>> & ComponentApi<Component>;
+type StoreSchemaOf<Component> = Component extends {
+    store: ComponentStore<infer Schema extends object>;
+} ? Schema : never;
+type StoreOf<Component> = [StoreSchemaOf<Component>] extends [never] ? never : [StoreSchemaOf<Component>] extends [InternalStoreSchema] ? never : StoreSchemaOf<Component>;
+export type HostedRoute = {
+    key: RouteKey | null;
+    params?: Record<string, string>;
+    data?: unknown;
+};
+export type RouteOptions = {
+    routing: true;
+    location: Path;
+    routes: Routes<any> | RoutesFunction<any>;
+    matchedRoute?: never;
+} | {
+    routing?: false;
+    location?: Path;
+    routes?: Routes<any>;
+    matchedRoute?: HostedRoute;
+};
+type NoStore = {
+    store?: never;
+    partialStore?: never;
+    storeData?: never;
+    partialStoreData?: never;
+};
+type StoreOptionsFor<Schema extends object> = {
+    /** A real store (makeStore), used as-is: its cells keep state, so one can be shared between hosts. */
+    store: TrueStore<Schema>;
+    partialStore?: never;
+    storeData?: never;
+    partialStoreData?: never;
+} | {
+    /** Some real cells. A key not given is missing, not defaulted: reading it throws, naming it. */
+    partialStore: Partial<TrueStore<Schema>>;
+    store?: never;
+    storeData?: never;
+    partialStoreData?: never;
+} | {
+    /** Values for every key, each wrapped in a cell of its own. */
+    storeData: Schema;
+    store?: never;
+    partialStore?: never;
+    partialStoreData?: never;
+} | {
+    /** Values for some keys. A key not given is missing, not defaulted: reading it throws, naming it. */
+    partialStoreData: Partial<Schema>;
+    store?: never;
+    partialStore?: never;
+    storeData?: never;
+};
+/**
+ * Resolve the content through every component in the tree (the default). false: the hosted
+ * component's own content alone, its child components unexpanded.
+ */
+export type ResolveOption = {
+    resolve?: boolean;
+};
+export type Resolve = {
+    resolve?: true;
+};
+export type DontResolve = {
+    resolve: false;
+};
+export type AppDataOptions = {
+    /** What this.tungsten.context reads. An empty object when not given. */
+    context?: object;
+    /** What this.tungsten.networkedData reads. An empty object when not given. */
+    networkedData?: object;
+    /** What this.tungsten.globalData reads. An empty object when not given. */
+    globalData?: object;
+};
+export type HostStoreOptions<Schema extends object, R extends ResolveOption = ResolveOption> = (RouteOptions & R & AppDataOptions & StoreOptionsFor<Schema>) extends infer Options ? Options extends unknown ? {
+    [K in keyof Options]: Options[K];
+} : never : never;
+export type HostOptions<Component, R extends ResolveOption = ResolveOption> = [StoreOf<Component>] extends [never] ? (RouteOptions & R & AppDataOptions & (NoStore | StoreOptionsFor<any>)) extends infer Options ? Options extends unknown ? {
+    [K in keyof Options]: Options[K];
+} : never : never : HostStoreOptions<StoreOf<Component>, R>;
+export type HostStoreResolveOptions<Schema extends object> = HostStoreOptions<Schema, Resolve>;
+export type HostStoreDontResolveOptions<Schema extends object> = HostStoreOptions<Schema, DontResolve>;
+export type HostResolveOptions<Component> = HostOptions<Component, Resolve>;
+export type HostDontResolveOptions<Component> = HostOptions<Component, DontResolve>;
+type HostArgs<Props, Component> = [StoreOf<Component>] extends [never] ? object extends Props ? [props?: Props, options?: HostOptions<Component> & Resolve] : [props: Props, options?: HostOptions<Component> & Resolve] : object extends Props ? [props: Props | undefined, options: HostOptions<Component> & Resolve] : [props: Props, options: HostOptions<Component> & Resolve];
+/**
+ * Constructs a component outside of any app and drives it the way the framework
+ * does - init, then the mount lifecycles - calling its content function with
+ * whatever arguments its flavour takes, so tests don't have to match the
+ * (props) / (props, state) signature themselves.
+ *
+ * No DOM: content is returned as a content node tree, unstyled, and never
+ * reconciled. createTestApp() is the harness for anything that needs a document
+ * or app state. Lifecycle failures are thrown rather than only reported, so a
+ * test can't pass over one.
+ *
+ * State is not proxied (the construct package is marked `hosted`), so nothing
+ * re-renders on its own: updateProps() and updateState() are the renders.
+ *
+ * Store components have a structural overload: Schema is its own parameter, inferred from
+ * the class, so a generic wrapper (`Component extends { store: ComponentStore<S> }`) can
+ * call through without a cast. HostArgs is a conditional on Component, and a conditional
+ * on a type parameter is deferred, so nothing is assignable to it inside such a wrapper.
+ */
+export declare function host<exact Props extends TungstenComponentPropsBase, Schema extends object, Component extends TungstenBaseComponent<any, any> & {
+    store: ComponentStore<Schema>;
+}>(ComponentType: TungstenComponentClass<Props, Component> & (new (...args: any) => {
+    store: ComponentStore<Schema>;
+}), props: Props, options: NoInfer<[
+    Schema
+] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & DontResolve>): Promise<Hosted<Component>>;
+export declare namespace host {
+    export { hostGeneric as generic };
+    export { hostJsx as jsx };
+}
+export declare function host<exact Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, props: Props | undefined, options: HostOptions<Component> & DontResolve): Promise<Hosted<Component>>;
+export declare function host<exact Props extends TungstenComponentPropsBase, Schema extends object, Component extends TungstenBaseComponent<any, any> & {
+    store: ComponentStore<Schema>;
+}>(ComponentType: TungstenComponentClass<Props, Component> & (new (...args: any) => {
+    store: ComponentStore<Schema>;
+}), props: Props, options: NoInfer<[
+    Schema
+] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & Resolve>): Promise<HostedResolved<Component>>;
+export declare function host<exact Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, ...[props, options]: HostArgs<Props, Component>): Promise<HostedResolved<Component>>;
+type HostGenericArgs<Component> = [StoreOf<Component>] extends [never] ? [options?: HostOptions<Component> & Resolve] : [options: HostOptions<Component> & Resolve];
+/**
+ * host() for a generic component class, whose type arguments it cannot infer: passed as an
+ * argument, the class's own parameters are erased to their constraints before the props are
+ * looked at, so `bind: [form, 'value']` widens to an array and the class stops fitting.
+ * Taking the class in a call of its own gets higher-order inference instead, so the props
+ * are checked against the component the way JSX checks them.
+ *
+ *     await hostGeneric(BoundValue)({ bind: [form, 'value'] })
+ *     await hostGeneric(BoundValue, { resolve: false })({ bind: [form, 'value'] })
+ *
+ * Options go on the first call because the returned signature has to stay a single plain
+ * one: give it type parameters of its own, or a second call signature, and the inference
+ * that makes this work is lost.
+ */
+export declare function hostGeneric<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, options: HostOptions<Component> & DontResolve): (props: Props) => Promise<Hosted<Component>>;
+export declare function hostGeneric<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, ...args: HostGenericArgs<Component>): (props: Props) => Promise<HostedResolved<Component>>;
+type AnyClassComponent = TungstenBaseComponent<any, any>;
+/**
+ * host(), given the element rather than the class and a props object:
+ * `await hostJsx(<DataTable head={head} rows={rows} columns={2} />)`. The options are host()'s,
+ * and everything else about it is the same - a class component, its init and mount lifecycles run.
+ *
+ * TypeScript types every JSX expression as `JSX.Element` (here `ContentNodeElement`), so the
+ * element does not carry the component it names: the wrapper comes back as the base component
+ * unless the call says which - `hostJsx<DataTable>(<DataTable … />)` - which is what gives back
+ * `props`, `state` and the component's own methods. host() itself infers all of that from the
+ * class, so a test that leans on the wrapper's api is better off with host().
+ */
+export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options: HostOptions<Component> & DontResolve): Promise<Hosted<Component>>;
+export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostOptions<Component> & Resolve): Promise<HostedResolved<Component>>;
+export {};
+//# sourceMappingURL=host.d.ts.map