tungsten 0.7.2 → 0.8.0

package/dist-ti/pipeline/pipelineDefinition.d.ts

@@ -0,0 +1,87 @@
+// @tightscript-object-permissions
+import type { AnyComponentType } from '../AnyComponentType.js';
+import type { RouteCacheControl } from '../cacheControl.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { RouteKey } from '../routing/RouteTypes.js';
+export type ServerRequests = {
+    express: ReqRes;
+    hono: unknown;
+};
+export type ServerKind = keyof ServerRequests;
+export type StageContext = object;
+export type MaybePromise<T> = T | Promise<T>;
+export type AllRoutesDataConstraint = object | undefined;
+export type RegisteredStage = (reqRes: unknown, previous: StageContext | undefined, allRoutesData?: AllRoutesDataConstraint) => MaybePromise<StageContext | undefined>;
+export type SplitResult = {
+    context?: object;
+    networked?: object;
+};
+export type RegisteredServerInit = (reqRes: unknown) => MaybePromise<SplitResult | undefined>;
+export type RegisteredServerPost = (reqRes: unknown, init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type RegisteredClientInit = (networked: object) => MaybePromise<SplitResult | undefined>;
+export type RegisteredClientAllRoutesData = (init: SplitResult | undefined, location: string) => MaybePromise<object>;
+export type RegisteredClientPost = (init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type ClientRoute = {
+    key: RouteKey | null;
+    params: Record<string, string>;
+    data: unknown;
+    location: string;
+};
+export declare const clientRoute: (matched: MatchedRouteInfo, location: string) => ClientRoute;
+export type RegisteredClientAfterRouting = (context: object, route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type ClientRun = (app: PipelineApp, fromPage: unknown) => Promise<ClientStarted>;
+export type ClientStarted = {
+    init: StageContext | undefined;
+    routingContext: object;
+    routingNetworkedData: object;
+    allRoutesData: ((location: string) => MaybePromise<object>) | undefined;
+    allRoutesDataFallback: ((location: string, error: unknown) => Promise<object>) | undefined;
+    networked: object;
+    post: (allRoutesData: AllRoutesDataConstraint) => Promise<ClientPosted>;
+};
+export type ClientPosted = {
+    context: object;
+    afterRouting: ((route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => Promise<object>) | undefined;
+};
+export type RegisteredRoutes = (reqRes: unknown, init: StageContext | undefined) => unknown;
+export type RegisteredAllRoutesData = (reqRes: unknown, init: StageContext | undefined, location: string) => MaybePromise<object>;
+export type RegisteredAllRoutesDataFallback = object | ((reqRes: unknown, init: StageContext | undefined, location: string, error: unknown) => MaybePromise<object>);
+export type RegisteredClientAllRoutesDataFallback = object | ((init: SplitResult | undefined, location: string, error: unknown) => MaybePromise<object>);
+export declare const isFallbackFunction: <F extends object>(fallback: F) => fallback is Extract<F, (...args: never[]) => unknown>;
+export type RoutesOptions = {
+    cacheControl?: RouteCacheControl;
+};
+export type PipelineDefinition = exact {
+    server: ServerKind;
+    split?: true;
+    client: ClientRun;
+    init?: RegisteredStage;
+    allRoutesData?: RegisteredAllRoutesData;
+    allRoutesDataFallback?: RegisteredAllRoutesDataFallback | undefined;
+    post?: RegisteredStage;
+    serverInit?: RegisteredServerInit;
+    serverPost?: RegisteredServerPost;
+    clientInit?: RegisteredClientInit;
+    clientAllRoutesData?: RegisteredClientAllRoutesData;
+    clientAllRoutesDataFallback?: RegisteredClientAllRoutesDataFallback | undefined;
+    clientPost?: RegisteredClientPost;
+    clientAfterRouting?: RegisteredClientAfterRouting;
+    errorPage?: AnyComponentType;
+};
+export declare const $pipelineApp: unique symbol;
+declare const $appTypes: unique symbol;
+export type PipelineApp<R = unknown, Ctx = unknown, N = unknown, G = unknown> = -exact PipelineDefinition & {
+    readonly [$pipelineApp]: true;
+    readonly routes: R;
+    readonly routesOptions: RoutesOptions;
+    readonly [$appTypes]?: {
+        context: Ctx;
+        networked: N;
+        allRoutesData: G;
+    };
+};
+export declare const isPipelineApp: (value: unknown) => value is PipelineApp;
+export declare const appRoutesFunction: (app: PipelineApp) => RegisteredRoutes;
+export {};
+//# sourceMappingURL=pipelineDefinition.d.ts.map

package/dist-ti/pipeline/runPipeline.d.ts

@@ -0,0 +1,40 @@
+// @tightscript-object-permissions
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { RoutesWithSettings } from '../routing/Routes.js';
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import type { InstancePipeline } from '../Instance/Instance.js';
+import type { AllRoutesDataConstraint, ClientPosted, ClientStarted, PipelineApp, RegisteredAllRoutesDataFallback, StageContext } from './pipelineDefinition.js';
+export type PipelineRouted = {
+    init: StageContext | undefined;
+    routes: RoutesWithSettings<any>;
+    allRoutesData: AllRoutesDataConstraint;
+    matchedRouteInfo: MatchedRouteInfo;
+    recoveredFrom?: unknown;
+};
+export type RequestProgress = rw {
+    init?: {
+        value: StageContext | undefined;
+    };
+    allRoutesData?: unknown;
+    failedSteps?: rw string[];
+};
+export type ServerRunner = {
+    route: (app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: rw ServerDataLoading | null, dev: boolean, progress?: RequestProgress) => Promise<PipelineRouted>;
+    post: (app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: AllRoutesDataConstraint) => Promise<StageContext | undefined>;
+    context: (init: StageContext | undefined, post: StageContext | undefined) => object;
+    networked: (init: StageContext | undefined, post: StageContext | undefined) => object | undefined;
+};
+export declare function runStep: exact (<T>(progress: RequestProgress, step: string, run: () => T | Promise<T>) => Promise<T>);
+export declare function pipelineRoutes: exact ((app: PipelineApp, reqRes: unknown, init: StageContext | undefined, dev: boolean) => RoutesWithSettings<any>);
+export declare const routingContext: (context: object | undefined) => BrandedContext;
+export declare const routingNetworkedData: (networked: object | undefined) => BrandedNetworkedData;
+export declare function routeWithPipeline: exact ((app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: rw ServerDataLoading | null, dev: boolean, progress?: RequestProgress) => Promise<PipelineRouted>);
+export declare function routeAfterInit: exact ((app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: rw ServerDataLoading | null, dev: boolean, init: StageContext | undefined, context: object | undefined, networked: object | undefined, progress?: RequestProgress) => Promise<PipelineRouted>);
+export declare function fromFallback: exact ((fallback: RegisteredAllRoutesDataFallback, reqRes: unknown, init: StageContext | undefined, location: string, error: unknown) => Promise<object>);
+export declare function runPost: exact ((app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: AllRoutesDataConstraint) => Promise<StageContext | undefined>);
+export declare const pipelineContext: (init: StageContext | undefined, post: StageContext | undefined) => r object;
+export declare const symmetricServer: ServerRunner;
+export declare function runClientPipeline: exact ((app: PipelineApp) => Promise<ClientStarted>);
+export declare const afterRoutingFor: (run: ClientPosted['afterRouting']) => InstancePipeline['afterRouting'];
+//# sourceMappingURL=runPipeline.d.ts.map

package/dist-ti/pipeline/runSplitPipeline.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import type { AllRoutesDataConstraint, ClientStarted, PipelineApp, SplitResult } from './pipelineDefinition.js';
+import type { PipelineRouted, RequestProgress, ServerRunner } from './runPipeline.js';
+export declare function routeWithSplitPipeline: exact ((app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: rw ServerDataLoading | null, dev: boolean, progress?: RequestProgress) => Promise<PipelineRouted>);
+export declare function runServerPost: exact ((app: PipelineApp, reqRes: unknown, init: object | undefined, allRoutesData: AllRoutesDataConstraint) => Promise<SplitResult | undefined>);
+export declare const splitContext: (init: object | undefined, post: object | undefined) => r object;
+export declare const splitNetworked: (init: object | undefined, post: object | undefined) => r object | undefined;
+export declare const splitServer: ServerRunner;
+export declare function runSplitClient: exact ((app: PipelineApp, fromPage: unknown) => Promise<ClientStarted>);
+//# sourceMappingURL=runSplitPipeline.d.ts.map

package/dist-ti/pipeline/settleRouting.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { Routes } from '../routing/Routes.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+export type Settled = {
+    allRoutesData: unknown;
+    matchedRouteInfo: MatchedRouteInfo;
+    recoveredFrom?: unknown;
+};
+export declare function settleRouting: exact ((routes: Routes<any>, route: () => Promise<MatchedRouteInfo>, loadData: (() => Promise<unknown>) | undefined, fallback: ((error: unknown) => Promise<unknown>) | undefined, errorInfo: (error: unknown) => TungstenErrorInfo) => Promise<Settled>);
+//# sourceMappingURL=settleRouting.d.ts.map

package/dist-ti/pipeline/splitPipeline.d.ts

@@ -0,0 +1,66 @@
+// @tightscript-object-permissions
+import type { JsonValue } from 'sxy-types';
+import type { Serializable } from '../routing/Serializable.js';
+import type { TrueStore } from '../Store/makeStore.js';
+import type { DataRedirect } from '../routing/DataRedirect.js';
+import type { Nothing, PostStage, SerializableData, StageMark } from './pipeline.js';
+import type { ClientRoute, MaybePromise, ServerKind, ServerRequests } from './pipelineDefinition.js';
+type ContextOf<X> = X extends {
+    context: infer C;
+} ? C : Nothing;
+type NetworkedOf<X> = X extends {
+    networked: infer N;
+} ? N : Nothing;
+type SerializableNetworked<N> = {
+    [K in keyof N]: K extends symbol ? never : N[K] extends TrueStore<infer S> ? ([S] extends [Serializable<S>] ? N[K] : never) : N[K] extends JsonValue ? N[K] : JsonValue;
+};
+type SplitKey<K, V> = K extends 'context' ? V & object : K extends 'networked' ? SerializableNetworked<V> & object : never;
+type SerializableSplit<X> = X extends object ? {
+    [K in keyof X]: SplitKey<K, X[K]>;
+} : X;
+type ClientSplit<X> = X extends object ? {
+    [K in keyof X]: K extends 'context' | 'networked' ? X[K] & object : never;
+} : X;
+type ClientPostSplit<X> = X extends object ? {
+    [K in keyof X]: K extends 'context' ? X[K] & object : never;
+} : X;
+type ServerInitProcess<Req, SI> = (reqRes: Req) => MaybePromise<SI & SerializableSplit<NoInfer<SI>>>;
+type ServerAllRoutesDataProcess<Req, SI, G> = (reqRes: Req, init: SI, location: string) => MaybePromise<(G & SerializableData<NoInfer<G>>) | DataRedirect>;
+type ServerAllRoutesDataFallback<Req, SI, G> = NoInfer<G> | ((reqRes: Req, init: SI, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
+type ServerPostProcess<Req, SI, SP, G> = (reqRes: Req, init: SI, allRoutesData: G) => MaybePromise<SP & SerializableSplit<NoInfer<SP>>>;
+type ClientInitProcess<N, CI> = (networked: N) => MaybePromise<CI & ClientSplit<NoInfer<CI>>>;
+type ClientAllRoutesDataProcess<CI, G> = (init: CI, location: string) => MaybePromise<G | DataRedirect>;
+type ClientAllRoutesDataFallback<CI, G> = NoInfer<G> | ((init: CI, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
+type ClientPostProcess<CI, CP, G> = (init: CI, allRoutesData: G) => MaybePromise<CP & ClientPostSplit<NoInfer<CP>>>;
+type ClientAfterRoutingProcess<PC, CA, G> = (context: PC, route: ClientRoute, allRoutesData: G) => MaybePromise<CA & ClientPostSplit<NoInfer<CA>>>;
+export type SplitFinalStage<Req, SI, CI, G extends object | undefined, ServerCtx, N, PC> = PostStage<Req, SI | CI, ServerCtx | PC, N, G, ContextOf<SI> | ContextOf<CI>, NetworkedOf<SI>> & {
+    clientAfterRouting: <CA extends object, This>(this: This, process: ClientAfterRoutingProcess<PC, CA, G>) => PostStage<Req, SI | CI, ServerCtx | ContextOf<CA>, N, G, ContextOf<SI> | ContextOf<CI>, NetworkedOf<SI>> & StageMark<This, 'clientAfterRouting', CA, ContextOf<CA>>;
+};
+export type ClientDataStage<Req, SI, CI, G extends object | undefined, ServerCtx, N, PC> = {
+    clientAllRoutesData: <This>(this: This, process: ClientAllRoutesDataProcess<CI, G>, fallback?: ClientAllRoutesDataFallback<CI, G>) => SplitFinalStage<Req, SI, CI, G, ServerCtx, N, PC> & StageMark<This, 'clientAllRoutesData', G, PC>;
+};
+type AfterClientPost<Req, SI, CI, G extends object | undefined, D extends boolean, ServerCtx, N, PC> = D extends true ? ClientDataStage<Req, SI, CI, G, ServerCtx, N, PC> : SplitFinalStage<Req, SI, CI, G, ServerCtx, N, PC>;
+export type ClientPostStage<Req, SI, CI, G extends object | undefined, D extends boolean, ServerCtx, N> = AfterClientPost<Req, SI, CI, G, D, ServerCtx, N, ContextOf<CI>> & {
+    clientPost: <CP extends object, This>(this: This, process: ClientPostProcess<CI, CP, G>) => AfterClientPost<Req, SI, CI, G, D, ServerCtx, N, ContextOf<CP>> & StageMark<This, 'clientPost', CP, ContextOf<CP>>;
+};
+export type ClientInitStage<Req, SI, G extends object | undefined, D extends boolean, N, ServerCtx> = {
+    clientInit: <CI extends object | undefined, This>(this: This, process: ClientInitProcess<N, CI>) => ClientPostStage<Req, SI, CI, G, D, ServerCtx, N> & StageMark<This, 'clientInit', CI, ContextOf<CI>>;
+};
+export type SplitDataStage<Req, SI, G extends object | undefined, D extends boolean> = ClientInitStage<Req, SI, G, D, NetworkedOf<SI>, ContextOf<SI>> & {
+    serverPost: <SP extends object, This>(this: This, process: ServerPostProcess<Req, SI, SP, G>) => ClientInitStage<Req, SI, G, D, NetworkedOf<SP>, ContextOf<SP>> & StageMark<This, 'serverPost', SP, ContextOf<SP>>;
+};
+export type PipelineServerAllRoutesData<X extends {
+    serverPost: (process: never) => unknown;
+}> = Parameters<Parameters<X['serverPost']>[0]>[2];
+export type SplitInitStage<Req, SI> = SplitDataStage<Req, SI, undefined, false> & {
+    serverAllRoutesData: <G extends object, This>(this: This, process: ServerAllRoutesDataProcess<Req, SI, G>, fallback?: ServerAllRoutesDataFallback<Req, SI, G>) => SplitDataStage<Req, SI, G, true> & StageMark<This, 'serverAllRoutesData', G, ContextOf<SI>>;
+};
+export type SplitServerStage<Req> = {
+    serverInit: <SI extends object | undefined, This>(this: This, process: ServerInitProcess<Req, SI>) => SplitInitStage<Req, SI> & StageMark<This, 'serverInit', SI, ContextOf<SI>>;
+};
+export type SplitPipelineBuilder = {
+    server: <Kind extends ServerKind>(kind: Kind) => SplitServerStage<ServerRequests[Kind]>;
+};
+export declare const splitPipeline: SplitPipelineBuilder;
+export {};
+//# sourceMappingURL=splitPipeline.d.ts.map

package/dist-ti/pop.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { Instance } from './Instance/Instance.js';
+export declare function registerPopInstance: exact ((newInstance: Instance) => void);
+export declare function dismissPop: exact ((id: number) => void);
+export declare function pop: exact ((text: string) => void);
+type PopFunction = typeof pop;
+declare global {
+    var pop: PopFunction;
+}
+export {};
+//# sourceMappingURL=pop.d.ts.map

package/dist-ti/possibleEnvFiles.d.ts

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

package/dist-ti/postcssPlugins/TransformCssNames.d.ts

@@ -0,0 +1,16 @@
+// @tightscript-object-permissions
+import type { Root } from 'postcss';
+import type { CssNames } from '../CssNames.js';
+type Opts = {
+    moduleName: string;
+    outNames: rw CssNames;
+};
+export declare function TransformCssNames(opts: Opts): exact rw {
+    postcssPlugin: string;
+    Once(root: Root): void;
+};
+export declare namespace TransformCssNames {
+    var postcss: boolean;
+}
+export {};
+//# sourceMappingURL=TransformCssNames.d.ts.map

package/dist-ti/postcssPlugins/parseSelectors.d.ts

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

package/dist-ti/postcssPlugins/parseSelectorsRich.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+export type SelectorKind = 'none' | 'whitespace' | 'grammar' | 'tag' | 'id' | 'class' | 'pseudo-class' | 'pseudo-element' | 'attribute';
+export type Selector = {
+    type: SelectorKind;
+    content: string;
+    valid: boolean;
+};
+export declare function parseSelectorsRich: exact ((selectorGroup: string) => rw (r Selector)[]);
+//# sourceMappingURL=parseSelectorsRich.d.ts.map

package/dist-ti/postcssPlugins/scopeAnimationValue.d.ts

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

package/dist-ti/postcssPlugins/splitCssValue.d.ts

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

package/dist-ti/postcssPlugins/unwrapIgnoreMarker.d.ts

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

package/dist-ti/promise.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function promise: exact (<T>(func: (resolve: (reason?: any) => void, reject: (reason?: any) => void) => T) => Promise<T>);
+//# sourceMappingURL=promise.d.ts.map

package/dist-ti/propsAreEqual.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+/**
+ * `since` is the tick at which the receiving component last rendered. It is only consulted
+ * when the two sides are the same object, which is where a structural comparison cannot
+ * help: deep state is mutated in place, so both sides are the already-mutated object.
+ */
+export declare function valuesAreEqual: exact ((a: unknown, b: unknown, since?: number) => boolean);
+export declare function propsAreEqual: exact ((previous: unknown, next: unknown, since?: number) => boolean);
+//# sourceMappingURL=propsAreEqual.d.ts.map

package/dist-ti/rawHtml/HtmlAllowList.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+/**
+ * What raw markup is permitted to contain.
+ *
+ * Anything outside the list is dropped. A disallowed *element* is unwrapped
+ * rather than deleted — its children take its place — so filtering never
+ * silently loses someone's words. The exception is elements whose content is
+ * program text rather than prose (`script`, `style`), which go entirely.
+ */
+export type HtmlAllowList = {
+    /** Tag names that may be rendered. */
+    tags: readonly string[];
+    /** Attributes allowed on any allowed tag. */
+    attributes: readonly string[];
+    /** Further attributes allowed only on the named tags. */
+    tagAttributes?: Readonly<Record<string, readonly string[]>> | undefined;
+};
+//# sourceMappingURL=HtmlAllowList.d.ts.map

package/dist-ti/rawHtml/decodeHtmlEntities.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+/**
+ * Decodes HTML character references in text taken from raw markup.
+ *
+ * Never throws. An entity this does not recognise is left as written rather
+ * than dropped, so no content is ever silently lost.
+ */
+export declare function decodeHtmlEntities: exact ((text: string) => string);
+//# sourceMappingURL=decodeHtmlEntities.d.ts.map

package/dist-ti/rawHtml/filterContentNode.d.ts

@@ -0,0 +1,21 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+import type { HtmlAllowList } from './HtmlAllowList.js';
+/**
+ * Applies an allow list to a content tree that already exists, rather than
+ * one being built - the same decisions `parseHtml(html, { allowList })` makes
+ * while parsing, for a tree that did not come from parsing HTML at all (one
+ * rebuilt from storage, for instance) and so never had the chance to.
+ *
+ * A disallowed element is unwrapped, keeping its children in its place, so
+ * filtering a tag never costs the reader the words inside it - the same rule
+ * `parseHtml` applies. An element holding program text rather than prose
+ * (`<script>`, and anything on the same footing as `<script>` even under a
+ * permissive allow list) is dropped whole instead. `on*` props, `ref`, and
+ * `dangerouslySetInnerHTML` are always stripped - the tree-shape equivalent
+ * of what `parseHtml` refuses to produce in the first place - and a `href`/
+ * `src`/... value using an executable scheme (`javascript:`, `vbscript:`) or,
+ * on a navigating attribute, `data:` is dropped the same way.
+ */
+export declare function filterContentNode: exact ((node: ContentNode, allowList: HtmlAllowList) => ContentNode);
+//# sourceMappingURL=filterContentNode.d.ts.map

package/dist-ti/rawHtml/htmlParsingTags.d.ts

@@ -0,0 +1,24 @@
+// @tightscript-object-permissions
+/**
+ * Elements whose content is text, not markup, up to their closing tag.
+ *
+ * `escapable` ones hold ordinary text, so their character references are
+ * decoded; `literal` ones hold program text, which is taken exactly as written.
+ */
+export declare const htmlRawTextTags: Record<string, 'literal' | 'escapable'>;
+/**
+ * Table-structural elements, which may not hold text directly.
+ *
+ * A browser moves text out of these to just before the table it is in — the
+ * spec calls it foster parenting — so the parser has to do the same, or the
+ * tree and the DOM built from the rendered markup disagree. Whitespace alone
+ * is left where it is, which is also what a browser does.
+ *
+ * Only tables behave this way. `ul`, `ol`, `dl` and `select` keep stray text
+ * exactly where it was written.
+ */
+export declare const htmlTableStructureTags: Record<string, true>;
+export declare const htmlImpliedEndTags: Record<string, string[]>;
+/** Whether an open `openTag` is implicitly closed by a start tag `startTag`. */
+export declare function impliedEndTag: exact ((openTag: string, startTag: string) => boolean);
+//# sourceMappingURL=htmlParsingTags.d.ts.map

package/dist-ti/rawHtml/parseHtml.d.ts

@@ -0,0 +1,50 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+import type { HtmlAllowList } from './HtmlAllowList.js';
+export type ParseHtmlOptions = {
+    /**
+     * Drop `<script>` elements and `javascript:` URLs. On by default, because
+     * raw markup usually comes from outside the application.
+     *
+     * `on*` handler attributes are always dropped, sanitizing or not: Tungsten
+     * reads those props as event listeners, and a string where a function is
+     * expected breaks hydration.
+     */
+    sanitize?: boolean | undefined;
+    /**
+     * Keep only the tags and attributes on this list. Off by default — without
+     * one, everything parsed is kept, subject to `sanitize`.
+     *
+     * See `safeHtmlAllowList` for a ready-made list for authored rich text.
+     */
+    allowList?: HtmlAllowList | undefined;
+};
+export type AllowCheck = {
+    tag: (name: string) => boolean;
+    attribute: (tag: string, name: string) => boolean;
+};
+export declare function makeAllowCheck: exact ((allowList: HtmlAllowList | undefined) => AllowCheck);
+export declare const urlAttributes: Record<string, true>;
+export declare function blockedUrl: exact ((attributeName: string, value: string) => boolean);
+/**
+ * Whether an element survives, and if not, how it goes.
+ *
+ * Elements holding program text rather than prose are dropped whole — there is
+ * no reader's content inside them to preserve. Everything else is unwrapped.
+ */
+export declare function removalFor: exact ((name: string, sanitize: boolean, allow: AllowCheck) => 'drop' | 'unwrap' | undefined);
+/**
+ * Parses raw HTML into a Tungsten content tree.
+ *
+ * Never throws, whatever it is given. Unclosed tags are closed, stray end tags
+ * are ignored, and anything that is not markup is kept as text — the result is
+ * always a renderable tree.
+ *
+ * The point of parsing rather than injecting the markup is that the result is
+ * an ordinary tree: it renders, hydrates and reconciles like any other content,
+ * with no opaque region the framework cannot see into. That means the parser
+ * has to apply the browser's own nesting rules, or the tree it produces and the
+ * DOM the browser builds from the rendered markup would disagree.
+ */
+export declare function parseHtml: exact ((html: string, options?: ParseHtmlOptions) => ContentNode);
+//# sourceMappingURL=parseHtml.d.ts.map

package/dist-ti/rawHtml/safeHtmlAllowList.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+import type { HtmlAllowList } from './HtmlAllowList.js';
+/**
+ * A conservative allow list for authored rich text — the shape a CMS or WYSIWYG
+ * field produces: headings, paragraphs, lists, tables, links, images, emphasis.
+ *
+ * Reach for this via `<RawHtml safe />`, or import it and spread it into your
+ * own list where an application needs more.
+ *
+ * Deliberately absent:
+ *
+ * - `style`, on any element. Attacker-controlled CSS can reposition and
+ *   disguise page furniture, so it is a real vector even without script.
+ * - `script`, `iframe`, `object`, `embed`, `form`, `input`, `button`.
+ * - `target` without `rel`: `target="_blank"` hands the opener window to the
+ *   linked page, so `rel` is allowed alongside it to be set to `noopener`.
+ */
+export declare const safeHtmlAllowList: HtmlAllowList;
+//# sourceMappingURL=safeHtmlAllowList.d.ts.map

package/dist-ti/rawHtml/sanitizeHtml.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+import type { HtmlAllowList } from './HtmlAllowList.js';
+export type SanitizeHtmlOptions = {
+    /** Defaults to `safeHtmlAllowList`. Pass your own list to allow more or less. */
+    allowList?: HtmlAllowList;
+};
+/**
+ * Cleans untrusted HTML and returns it as a string, synchronously.
+ *
+ * `parseHtml()` already does the cleaning - this only adds the return trip,
+ * for a caller that needs the result as a string rather than a content tree:
+ * a paste handler cleaning a clipboard payload before it is inserted, or an
+ * editor cleaning its content before it is stored. Both happen at a rate
+ * `renderingNodeToHtml` (the async, component-aware server renderer) is the
+ * wrong shape for.
+ */
+export declare function sanitizeHtml: exact ((html: string, options?: SanitizeHtmlOptions) => string);
+//# sourceMappingURL=sanitizeHtml.d.ts.map

package/dist-ti/rawHtml/tokenizeHtml.d.ts

@@ -0,0 +1,26 @@
+// @tightscript-object-permissions
+export type HtmlAttributes = Record<string, string | true>;
+export type HtmlToken = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'open';
+    name: string;
+    attributes: HtmlAttributes;
+    selfClosing: boolean;
+} | {
+    kind: 'close';
+    name: string;
+};
+/**
+ * Splits raw markup into text, start and end tokens.
+ *
+ * Never throws. Anything that is not well-formed markup — a stray `<`, an
+ * unterminated tag, a comment that is never closed — is emitted as text or
+ * skipped, matching what a browser does with the same input.
+ *
+ * Comments and doctypes are dropped: Tungsten uses comment nodes as its own
+ * component markers, so carrying authored ones through would confuse hydration.
+ */
+export declare function tokenizeHtml: exact ((html: string) => HtmlToken[]);
+//# sourceMappingURL=tokenizeHtml.d.ts.map

package/dist-ti/reRouting/addRequireResolveHooks.d.ts

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

package/dist-ti/reRouting/importLoader.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+type Resolve = (specifier: string, context: Context, nextResolve?: Resolve) => unknown;
+type Context = {
+    parentURL: string;
+};
+export declare function resolve: exact ((specifier: string, context: Context, nextResolve: Resolve) => rw Promise<unknown>);
+export {};
+//# sourceMappingURL=importLoader.d.ts.map

package/dist-ti/ref.d.ts

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

package/dist-ti/regexEscape.d.ts

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

package/dist-ti/removeRecursive.d.ts

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

package/dist-ti/render/HeadData.d.ts

@@ -0,0 +1,22 @@
+// @tightscript-object-permissions
+import type { TungstenEnvOrUndefined } from '../env/types.js';
+import type { Instance } from '../Instance/Instance.js';
+import type { ImportAliases } from '../build/ImportAliases.js';
+import type { AssetVersions } from '../build/assetVersions.js';
+export type SiteBasePath = '' | `/${string}`;
+export type HeadData = rw {
+    found: boolean;
+    instance: Instance;
+    clientImportAliases: ImportAliases;
+    importAliases: ImportAliases;
+    compilationLocation: string;
+    frameworkCss?: string | undefined;
+    assetVersions?: AssetVersions | undefined;
+    dev: boolean;
+    tungstenPublicEnv: TungstenEnvOrUndefined;
+    siteBasePath: SiteBasePath;
+    hmr: boolean | 'reload';
+    csr: boolean;
+    docInitScript?: string | undefined;
+};
+//# sourceMappingURL=HeadData.d.ts.map

package/dist-ti/render/SxyFrameworkModule.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+export type SxyFrameworkModule = {
+    abs: string;
+    rel: string;
+};
+//# sourceMappingURL=SxyFrameworkModule.d.ts.map

package/dist-ti/render/SxyFrameworkModules.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { SxyFrameworkModule } from './SxyFrameworkModule.js';
+export type SxyFrameworkModules = SxyFrameworkModule[];
+//# sourceMappingURL=SxyFrameworkModules.d.ts.map

package/dist-ti/render/addImportMap.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { ContentNodeElementWithChildrenArray } from '../ContentNode.js';
+import type { ImportAliases } from '../build/ImportAliases.js';
+export declare function addImportMap: exact ((head: ContentNodeElementWithChildrenArray, importAliases: ImportAliases, clientImportAliases: ImportAliases) => void);
+//# sourceMappingURL=addImportMap.d.ts.map

package/dist-ti/render/classComponentNodeToRenderingTree.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { RenderingNodeComponent } from '../RenderingNode.js';
+import type { Instance } from '../Instance/Instance.js';
+import type { ContentNodeClassComponent } from '../ContentNode.js';
+import type { AnyComponent } from '../AnyComponent.js';
+export declare function classComponentNodeToRenderingTree: exact ((node: ContentNodeClassComponent, parentComponent: AnyComponent | null, instance: Instance, noEscape: boolean) => Promise<RenderingNodeComponent>);
+//# sourceMappingURL=classComponentNodeToRenderingTree.d.ts.map

package/dist-ti/render/componentNodeToRenderingTree.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { Instance } from '../Instance/Instance.js';
+import type { AnyComponent } from '../AnyComponent.js';
+import { type RenderingNodeComponent } from '../RenderingNode.js';
+import { type ContentNodeComponent } from '../ContentNode.js';
+export declare function componentNodeToRenderingTree: exact ((componentNode: ContentNodeComponent, parentComponent: AnyComponent | null, instance: Instance, noEscape: boolean) => Promise<RenderingNodeComponent>);
+//# sourceMappingURL=componentNodeToRenderingTree.d.ts.map

package/dist-ti/render/contentNodeToHtml.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+import type { ContentNode } from '../ContentNode.js';
+/**
+ * Serialises a content tree to HTML, synchronously.
+ *
+ * `renderingNodeToHtml` (the server's real renderer) covers the general case -
+ * components, async data, `<head>` - and is async and internal because of it.
+ * This covers the subset that never needs any of that: plain HTML elements,
+ * text and arrays, the exact shape `parseHtml()` produces. Given a component
+ * node it throws rather than silently rendering nothing, since a caller
+ * reaching for the synchronous path has nothing that could resolve one.
+ *
+ * Attribute values are escaped, unlike `renderingNodeToHtml`'s - that renderer
+ * trusts values from application-authored JSX; this one exists specifically to
+ * round-trip untrusted markup back out as a string, so a value carrying `"`
+ * must not be able to break out of its attribute.
+ */
+export declare function contentNodeToHtml: exact ((node: ContentNode) => string);
+//# sourceMappingURL=contentNodeToHtml.d.ts.map

package/dist-ti/render/contentToHtml.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+import type { TungstenEnvOrUndefined } from '../env/types.js';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+import type { ImportAliases } from '../build/ImportAliases.js';
+import type { SiteBasePath } from './HeadData.js';
+import type { ContentNode } from '../ContentNode.js';
+import type { Instance } from '../Instance/Instance.js';
+export declare function contentToHtml: exact ((compilationInfo: CompilationInfo, clientImportAliases: ImportAliases, content: ContentNode, instance: Instance, config: FrameworkConfigComplete, siteBasePathOverride: SiteBasePath, tungstenPublicEnv?: TungstenEnvOrUndefined, dev?: boolean) => Promise<string>);
+//# sourceMappingURL=contentToHtml.d.ts.map