tungsten 0.7.1 → 0.8.0

package/dist-ti/routing/RoutesFunction.d.ts

@@ -0,0 +1,14 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { RoutesWithSettings } from './Routes.js';
+import type { RoutesArray } from './routesArray.js';
+import type { Context } from '../context/registerContext.js';
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+import type { NetworkedData } from './routingRegistry.js';
+export type RoutesFunction<G extends object = object> = {
+    routes(reqRes: ReqRes | null, context: Context, networkedData: NetworkedData): RoutesWithSettings<G>;
+}['routes'];
+export type BrandedRoutesFunction<G extends object = object> = {
+    routes(reqRes: ReqRes | null, context: BrandedContext, networkedData: BrandedNetworkedData): RoutesWithSettings<G> | RoutesArray<G>;
+}['routes'];
+//# sourceMappingURL=RoutesFunction.d.ts.map

package/dist-ti/routing/RoutesWithSafeParams.d.ts

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

package/dist-ti/routing/RoutingRedirect.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { RedirectCode } from './RedirectCode.js';
+import type { RouteKey } from './RouteTypes.js';
+export declare class RoutingRedirect {
+    to: RouteKey;
+    code: RedirectCode;
+    constructor(to: RouteKey, code?: RedirectCode);
+}
+//# sourceMappingURL=RoutingRedirect.d.ts.map

package/dist-ti/routing/Serializable.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import type { JsonValue } from 'sxy-types';
+export type Serializable<S> = {
+    [K in keyof S]: K extends symbol ? never : JsonValue;
+};
+//# sourceMappingURL=Serializable.d.ts.map

package/dist-ti/routing/TungstenErrorInfo.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+export type TungstenErrorInfo = {
+    error: unknown;
+    message: string;
+};
+export declare function makeTungstenErrorInfo: exact ((error: unknown) => TungstenErrorInfo);
+//# sourceMappingURL=TungstenErrorInfo.d.ts.map

package/dist-ti/routing/WebRedirect.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { RedirectCode } from './RedirectCode.js';
+export type WebUrl = `${string}://${string}` | string;
+export declare class WebRedirect {
+    to: WebUrl;
+    code: RedirectCode;
+    constructor(to: WebUrl, code?: RedirectCode);
+}
+//# sourceMappingURL=WebRedirect.d.ts.map

package/dist-ti/routing/builder.d.ts

@@ -0,0 +1,131 @@
+// @tightscript-object-permissions
+import type { Expand } from '../../types/helpers.js';
+import type { ContentNode } from '../ContentNode.js';
+import type { RouteContentFunction } from './RouteContentFunction.js';
+import type { Endpoint, Path, RouteKey } from './RouteTypes.js';
+import type { RouteDataFunction } from './RouteDataFunction.type.js';
+import type { ParamsFromPath } from './ParamsFromPath.js';
+import type { TungstenErrorInfo } from './TungstenErrorInfo.js';
+import type { ErrorRouteType } from './ErrorRouteType.js';
+export type FluentRoute = {
+    path: RouteKey;
+    content: ContentNode | RouteContentFunction<any, any>;
+};
+export type NormalFluentRoute = {
+    path: Path;
+    content: ContentNode | RouteContentFunction<any, any>;
+};
+export type FluentDefaultRoute = {
+    path: 'default';
+    content: ContentNode;
+};
+export type Fluent404Route = {
+    path: '404';
+    code?: number;
+    content: ContentNode;
+};
+export type FluentErrorRoute = {
+    path: 'error';
+    content: RouteContentFunction<object, TungstenErrorInfo>;
+};
+export type FluentRoutesToRoutes<T extends readonly FluentRoute[]> = {
+    [E in T[number] as E['path'] & string]: E;
+} & {};
+export declare function routes: exact (<const T extends readonly FluentRoute[]>(...frs: T) => owned FluentRoutesToRoutes<T>);
+export declare function routesWith: exact (<Rule extends object>() => <const T extends readonly (FluentRoute & Rule)[]>(...frs: T) => FluentRoutesToRoutes<T>);
+export declare function routesListWith: exact (<Rule extends object>() => <const exact T extends readonly (exact (r Endpoint<any, any, any> & r {
+    path: Path;
+} & Rule) | exact (r Endpoint<any, any, any> & r {
+    path: 'default';
+} & r Partial<Rule>) | exact (r ErrorRouteType & r {
+    path: 'error';
+} & r Partial<Rule>) | exact (r Endpoint<any, any, any> & r {
+    code?: number;
+} & r {
+    path: '404';
+} & r Partial<Rule>))[]>(routes: [...T]) => T);
+export declare function makeRouteWith: exact (<Rule extends object>() => exact {
+    <P extends RouteKey, D, M extends Meta = r FrameworkRouteFields>(r: exact ({
+        path: P;
+        data: RouteDataFunction<ParamsFromPath<P>, D>;
+        content: RouteContentFunction<ParamsFromPath<P>, D>;
+    } & Rule & M)): exact Expand<{
+        path: P;
+    } & Rule & M & {
+        data: RouteDataFunction<ParamsFromPath<P>, D>;
+        content: RouteContentFunction<ParamsFromPath<P>, D>;
+    }>;
+    <P extends RouteKey, const C extends ContentNode, M extends Meta = r FrameworkRouteFields>(r: exact ({
+        path: P;
+        data?: never;
+        content: C;
+    } & Rule & M)): exact Expand<{
+        path: P;
+    } & Rule & M & {
+        content: C;
+    }>;
+});
+type FrameworkRouteFields = Omit<Endpoint<any, any>, 'data' | 'content'>;
+type Meta = Record<string, unknown> & FrameworkRouteFields;
+declare const $invalidKeyError: unique symbol;
+type MustNotIncludePathDataContent<T extends Record<string, unknown>> = 'path' extends keyof T ? {
+    [$invalidKeyError]: 'meta may not contain key \'path\'';
+} : 'data' extends keyof T ? {
+    [$invalidKeyError]: 'meta may not contain key \'data\'';
+} : 'content' extends keyof T ? {
+    [$invalidKeyError]: 'meta may not contain key \'content\'';
+} : T;
+export declare function chainedRoute: exact (<P extends RouteKey, exact? M extends Meta = FrameworkRouteFields>(path: P, meta?: M & MustNotIncludePathDataContent<M>) => exact rw {
+    meta<M2 extends Meta>(meta: M2 & MustNotIncludePathDataContent<M2>): exact rw {
+        data<D>(dataFunc: RouteDataFunction<ParamsFromPath<P>, D>): exact rw {
+            content<C extends RouteContentFunction<ParamsFromPath<P>, D> | ContentNode>(content: C): Expand<{
+                path: P;
+            } & Omit<M, keyof M2> & M2 & {
+                data: RouteDataFunction<ParamsFromPath<P>, D>;
+                content: NoInfer<C>;
+            }>;
+        };
+        content<const C extends ContentNode>(content: C): Expand<{
+            path: P;
+        } & Omit<M, keyof M2> & M2 & {
+            content: C;
+        }>;
+    };
+    data<D>(dataFunc: RouteDataFunction<ParamsFromPath<P>, D>): exact rw {
+        content<C extends RouteContentFunction<ParamsFromPath<P>, D> | ContentNode>(content: C): exact Expand<{
+            path: P;
+        } & -exact M & {
+            data: RouteDataFunction<ParamsFromPath<P>, D>;
+            content: NoInfer<C>;
+        }>;
+    };
+    content<const C extends ContentNode>(content: C): exact Expand<{
+        path: P;
+    } & -exact M & {
+        content: C;
+    }>;
+});
+export declare function route<P extends RouteKey, D, exact M extends Meta = FrameworkRouteFields>(r: exact ({
+    path: P;
+    data: RouteDataFunction<ParamsFromPath<P>, D>;
+    content: RouteContentFunction<ParamsFromPath<P>, D>;
+} & M)): exact Expand<{
+    path: P;
+} & M & {
+    data: RouteDataFunction<ParamsFromPath<P>, D>;
+    content: RouteContentFunction<ParamsFromPath<P>, D>;
+}>;
+export declare function route<P extends RouteKey, const C extends ContentNode, exact M extends Meta = FrameworkRouteFields>(r: exact ({
+    path: P;
+    data?: never;
+    content: C;
+} & M)): exact Expand<{
+    path: P;
+} & M & {
+    content: C;
+}>;
+export declare function defaultRoute: exact (<const R extends exact FluentDefaultRoute>(r: R) => R);
+export declare function _404Route: exact (<const R extends exact Fluent404Route>(r: R) => R);
+export declare function errorRoute: exact (<const R extends exact FluentErrorRoute>(r: R) => R);
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist-ti/routing/builder.trial.d.ts

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

package/dist-ti/routing/compareRequestToRegex.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+type CompareResult = {
+    success: boolean;
+    params: {
+        [key: string]: string;
+    };
+};
+export declare function compareRequestToRegex: exact ((request: string, regex: RegExp, keys: string[]) => CompareResult);
+export {};
+//# sourceMappingURL=compareRequestToRegex.d.ts.map

package/dist-ti/routing/debug.d.ts

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

package/dist-ti/routing/defineRoutes.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { Endpoint } from './RouteTypes.js';
+import type { CustomRoutes } from './Routes.js';
+type AnyRoutes = CustomRoutes<Endpoint<any, any>>;
+export declare function defineRoutes<const R extends AnyRoutes>(routes: R): R;
+export declare function defineRoutes<const R extends AnyRoutes>(routes: (reqRes: ReqRes | null) => R): (reqRes: ReqRes | null) => R;
+export {};
+//# sourceMappingURL=defineRoutes.d.ts.map

package/dist-ti/routing/getPathPriority.d.ts

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

package/dist-ti/routing/matchPath.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Match } from './Match.type.js';
+export declare function matchPath: exact ((pattern: `/${string}`, request: string) => Match | null);
+//# sourceMappingURL=matchPath.d.ts.map

package/dist-ti/routing/patternToRegex.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+export declare function patternToRegex: exact ((pattern: string) => {
+    regex: RegExp;
+    keys: string[];
+});
+//# sourceMappingURL=patternToRegex.d.ts.map

package/dist-ti/routing/pyramidRouting.d.ts

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

package/dist-ti/routing/redirectOf.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import type { MatchedRouteInfo } from './MatchedRouteInfo.js';
+import type { RedirectCode } from './RedirectCode.js';
+import type { RouteKey } from './RouteTypes.js';
+export type Redirection = {
+    route: RouteKey;
+    code?: RedirectCode | undefined;
+} | {
+    url: string;
+    code?: RedirectCode | undefined;
+};
+export declare function redirectOf: exact ((matched: MatchedRouteInfo, allRoutesData?: unknown) => Redirection | undefined);
+//# sourceMappingURL=redirectOf.d.ts.map

package/dist-ti/routing/registerGlobalData.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { Context } from '../context/registerContext.js';
+import type { DataRedirect } from './DataRedirect.js';
+import type { NetworkedData } from './routingRegistry.js';
+import type { Serializable } from './Serializable.js';
+import type { Fixed } from './registrationTypes.js';
+export interface GlobalData {
+}
+export type GlobalDataFunction<C = Context, NS = NetworkedData, G extends object = GlobalData> = (reqRes: ReqRes | null, context: C, networkedStore: NS, location: string) => Promise<G | DataRedirect>;
+export type BrandedGlobalDataFunction = (reqRes: ReqRes | null, context: BrandedContext, networkedStore: BrandedNetworkedData, location: string) => Promise<BrandedGlobalData>;
+export declare const globalDataFunc: rw {
+    value: BrandedGlobalDataFunction | undefined;
+};
+export declare function registerGlobalData: exact (<G extends object>(func: GlobalDataFunction<Context, NetworkedData, G> & ((reqRes: ReqRes | null, context: Context, networkedData: NetworkedData, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>)) => Fixed<{
+    globalData: G;
+}>);
+//# sourceMappingURL=registerGlobalData.d.ts.map

package/dist-ti/routing/registerRoutes.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { Context } from '../context/registerContext.js';
+import type { GlobalData } from './registerGlobalData.js';
+import type { RoutesWithSettings } from './Routes.js';
+import type { NetworkedData } from './routingRegistry.js';
+type GlobalRoutes = RoutesWithSettings<GlobalData>;
+type GlobalRoutesFunction = (reqRes: ReqRes | null, context: Context, networkedData: NetworkedData) => GlobalRoutes;
+export declare function registerRoutes: exact (<R extends GlobalRoutes | GlobalRoutesFunction>(routes: R) => R);
+export {};
+//# sourceMappingURL=registerRoutes.d.ts.map

package/dist-ti/routing/registerRouting.d.ts

@@ -0,0 +1,38 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { ExactRoutesWithSettings } from './Routes.js';
+import type { GlobalDataFunction } from './registerGlobalData.js';
+import type { DataRedirect } from './DataRedirect.js';
+import type { AppPath } from '../components/makeTypedLink.js';
+import type { Serializable } from './Serializable.js';
+import type { KeyedRoutes } from './routesArray.js';
+import type { PipelineApp } from '../pipeline/pipelineDefinition.js';
+import type { $routing, ContextInitializer, Fixed, NetworkedStoreInitializer, RoutesFunctionGeneric } from './registrationTypes.js';
+export type { Serializable } from './Serializable.js';
+export type { ContextInitializer, NetworkedStoreInitializer, RoutesFunctionGeneric, } from './registrationTypes.js';
+type SerializableStore<S> = new (reqRes: ReqRes | null) => Serializable<S>;
+export type Routing<Rs, G, C, NS> = Fixed<{
+    routes: Rs;
+    globalData: G;
+    context: C;
+    networkedStore: NS;
+}>;
+type RoutesOf<R> = R extends Fixed<{
+    routes: infer Rs;
+}> ? Rs : R extends PipelineApp<infer F> ? RoutesOf<F> : R extends (...args: never[]) => infer Rs ? Rs : R;
+export type RoutesType<R extends object> = RoutesProper<KeyedRoutes<RoutesOf<R>>>;
+type RoutesProper<Rs> = {
+    [K in keyof Rs as K extends symbol ? never : K]: Rs[K];
+};
+export type PathsType<R extends object> = AppPath<RoutesType<R>>;
+export type GlobalDataType<R extends Fixed<{
+    globalData: unknown;
+}>> = R[typeof $routing]['globalData'];
+export type ContextType<R extends Fixed<{
+    context: unknown;
+}>> = R[typeof $routing]['context'];
+export type NetworkedDataType<R extends Fixed<{
+    networkedStore: unknown;
+}>> = R[typeof $routing]['networkedStore'];
+export declare function registerRouting: exact (<const exact RsS extends ExactRoutesWithSettings<G>, G extends object = object, ContextSchema extends object | undefined = undefined, NetworkedStoreSchema extends object | undefined = undefined>(routesFunction: RoutesFunctionGeneric<G, ContextSchema, NetworkedStoreSchema, RsS>, globalDataFunction: GlobalDataFunction<NoInfer<ContextSchema>, NoInfer<NetworkedStoreSchema>, G> & ((reqRes: ReqRes | null, context: NoInfer<ContextSchema>, store: NoInfer<NetworkedStoreSchema>, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>), context?: ContextInitializer<ContextSchema>, networkedStoreSchema?: NetworkedStoreInitializer<NetworkedStoreSchema> & SerializableStore<NoInfer<NetworkedStoreSchema>>) => Routing<RsS, G, ContextSchema, NetworkedStoreSchema>);
+//# sourceMappingURL=registerRouting.d.ts.map

package/dist-ti/routing/registrationTypes.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { RoutesWithSettings } from './Routes.js';
+import type { RoutesArray } from './routesArray.js';
+export declare const $routing: unique symbol;
+export type Fixed<T> = {
+    [$routing]: T;
+};
+export type RoutesFunctionGeneric<G extends object, C, NS, Rs extends RoutesWithSettings<G> | RoutesArray<G>> = (reqRes: ReqRes | null, context: C, networkedData: NS) => Rs;
+export type ContextInitializer<ContextSchema> = new (reqRes: ReqRes | null) => ContextSchema;
+export type NetworkedStoreInitializer<StoreSchema> = new (reqRes: ReqRes | null, context?: unknown) => StoreSchema;
+//# sourceMappingURL=registrationTypes.d.ts.map

package/dist-ti/routing/resolveAppRoutes.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import type { Mode } from '../Mode.js';
+import type { RoutesLocation } from '../FrameworkConfig.js';
+import type { AppRoutes } from './AppRoutes.js';
+export declare function resolveAppRoutes: exact ((module: Record<string, unknown>, routesLocation: RoutesLocation, mode: Mode) => AppRoutes<any>);
+//# sourceMappingURL=resolveAppRoutes.d.ts.map

package/dist-ti/routing/routeSymbols.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+export declare const $notFound: unique symbol;
+export type $NotFound = typeof $notFound;
+export declare const $404: unique symbol;
+export type $404 = typeof $404;
+export declare const $default: unique symbol;
+export type $Default = typeof $default;
+export declare const $error: unique symbol;
+export type $Error = typeof $error;
+//# sourceMappingURL=routeSymbols.d.ts.map

package/dist-ti/routing/routeUrl.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { SiteBasePath } from '../render/HeadData.js';
+export declare function routeKeyToUrl: exact ((routeKey: string, siteBasePath: SiteBasePath, staticFiles: boolean) => string);
+export declare function urlToRouteKey: exact ((pathname: string, siteBasePath: SiteBasePath, staticFiles: boolean) => string);
+export declare function urlToLocation: exact ((url: {
+    pathname: string;
+    search: string;
+}, siteBasePath: SiteBasePath, staticFiles: boolean) => string);
+//# sourceMappingURL=routeUrl.d.ts.map

package/dist-ti/routing/routesArray.d.ts

@@ -0,0 +1,31 @@
+// @tightscript-object-permissions
+import type { ErrorRouteType } from './ErrorRouteType.js';
+import type { Routes, RoutesWithSettings } from './Routes.js';
+import type { Endpoint, Path } from './RouteTypes.js';
+import type { Mutual } from '../../types/helpers.js';
+export type RouteEntry<G extends object | undefined = object> = exact (Endpoint<any, any, G> & {
+    path: Path | 'default' | '404';
+} & RouteMeta) | exact (ErrorRouteType & {
+    path: 'error';
+} & RouteMeta);
+type RouteMeta = {
+    [key: string]: unknown;
+};
+export type RoutesArray<G extends object | undefined = object> = readonly RouteEntry<G>[];
+export declare function routesFromArray: exact ((entries: RoutesArray<any>, dev: boolean) => Routes<any>);
+export declare const toRoutes: <Rs extends object>(routes: Rs | RoutesArray<any>, dev: boolean) => Rs | RoutesWithSettings<any>;
+export type KeyedRoutes<Rs> = Rs extends RoutesArray<any> ? exact {
+    [Entry in Rs[number] as Entry['path']]: WithoutPath<Entry>;
+} : Rs;
+type WithoutPath<E> = {
+    [K in keyof E as K extends 'path' ? never : K]: E[K];
+};
+type Found<P, Seen> = distribute Seen as Mutual<P, Seen> extends true ? P : never;
+type DuplicatePath<T, Seen = never> = T extends readonly [infer H, ...infer Rest] ? H extends {
+    path: infer P extends PropertyKey;
+} ? [Found<P, Seen>] extends [never] ? DuplicatePath<Rest, Seen | P> : P : DuplicatePath<Rest, Seen> : never;
+type ReturnedRoutes<R> = R extends (...args: never[]) => infer Rs ? Rs : R;
+type GivenTwice<P extends string> = `The routes give the path '${P}' twice. Each path can have one route.`;
+export type NoDuplicatePaths<R> = [DuplicatePath<ReturnedRoutes<R>>] extends [never] ? unknown : GivenTwice<DuplicatePath<ReturnedRoutes<R>> & string>;
+export {};
+//# sourceMappingURL=routesArray.d.ts.map

package/dist-ti/routing/routingBuilder.d.ts

@@ -0,0 +1,36 @@
+// @tightscript-object-permissions
+import type { ReqRes, ReqResOrNull } from '../ReqRes.js';
+import type { ExactRoutesWithSettings } from './Routes.js';
+import type { ContextClasses } from '../context/registerContext.js';
+import type { DataRedirect } from './DataRedirect.js';
+import type { Routing, RoutesFunctionGeneric, Serializable } from './registerRouting.js';
+import type { Fixed } from './registrationTypes.js';
+type NetworkedStoreClass<C, ND> = (new (reqRes: ReqResOrNull, context: C) => ND) & (new (reqRes: ReqResOrNull, context: C) => Serializable<NoInfer<ND>>);
+type GetGlobalData<C, ND, G extends object> = ((reqRes: ReqRes | null, context: C, networkedData: ND, location: string) => Promise<G | DataRedirect>) & ((reqRes: ReqRes | null, context: C, networkedData: ND, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>);
+type RoutesMethod<C, ND, G extends object> = {
+    routes: <const exact Rs extends ExactRoutesWithSettings<G>>(getRoutes: RoutesFunctionGeneric<G, C, ND, Rs>) => Routing<Rs, G, C, ND>;
+};
+type GlobalDataMethod<C, ND> = {
+    globalData: <G extends object>(getGlobalData: GetGlobalData<C, ND, G>) => RoutesStage<C, ND, G>;
+};
+type NetworkedDataMethod<C> = {
+    networkedData: <ND extends object>(networkedDataInitializer: NetworkedStoreClass<C, ND>) => GlobalDataStage<C, ND>;
+};
+type RoutesStage<C, ND, G extends object> = RoutesMethod<C, ND, G> & Fixed<{
+    context: C;
+    networkedStore: ND;
+    globalData: G;
+}>;
+type GlobalDataStage<C, ND> = RoutesMethod<C, ND, object> & GlobalDataMethod<C, ND> & Fixed<{
+    context: C;
+    networkedStore: ND;
+}>;
+type NetworkedDataStage<C> = RoutesMethod<C, undefined, object> & GlobalDataMethod<C, undefined> & NetworkedDataMethod<C> & Fixed<{
+    context: C;
+}>;
+type ContextStage = RoutesMethod<undefined, undefined, object> & GlobalDataMethod<undefined, undefined> & NetworkedDataMethod<undefined> & {
+    context: <C extends object>(contextInitializer: (new (reqRes: ReqResOrNull) => C) | ContextClasses) => NetworkedDataStage<C>;
+};
+export declare const register: ContextStage;
+export {};
+//# sourceMappingURL=routingBuilder.d.ts.map

package/dist-ti/routing/routingRegistry.d.ts

@@ -0,0 +1,20 @@
+// @tightscript-object-permissions
+import type { AppRoutes } from './AppRoutes.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+import type { Context } from '../context/registerContext.js';
+import type { Serializable } from './Serializable.js';
+import type { Fixed } from './registrationTypes.js';
+export interface NetworkedData {
+}
+export declare const registeredRouting: rw {
+    value: AppRoutes<any> | undefined;
+};
+export declare const registeredNetworkedStore: rw {
+    value: (new (reqRes: ReqRes | null, context: BrandedContext) => object) | undefined;
+};
+export declare function registerNetworkedData: exact (<ND extends object>(store: (new (reqRes: ReqRes | null, context: Context) => ND) & (new (reqRes: ReqRes | null, context: Context) => Serializable<NoInfer<ND>>)) => Fixed<{
+    networkedStore: ND;
+}>);
+export declare function createNetworkedData: exact ((reqRes: ReqRes | null, context: BrandedContext) => BrandedNetworkedData);
+//# sourceMappingURL=routingRegistry.d.ts.map

package/dist-ti/routing/runContentFunction.d.ts

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

package/dist-ti/routing/splitRequest.d.ts

@@ -0,0 +1,18 @@
+// @tightscript-object-permissions
+export type SplitRequest = {
+    pathname: string;
+    query: {
+        [key: string]: string;
+    };
+    hash: string;
+};
+/**
+ * Split an incoming request string into its path, query, and hash parts, the
+ * way a URL is structured: `/path?query#hash`. Only `pathname` should be used
+ * for route matching (query and hash are not part of the path).
+ *
+ * The hash is separated first because a URL's fragment can itself contain a
+ * '?' that is not a query delimiter (e.g. '/foo#a?b').
+ */
+export declare function splitRequest: exact ((request: string) => SplitRequest);
+//# sourceMappingURL=splitRequest.d.ts.map

package/dist-ti/run.d.ts

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

package/dist-ti/server.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+export * from './auth/index.js';
+export * from './cliOutput.js';
+export * from './spawnShellCommand.js';
+//# sourceMappingURL=server.d.ts.map

package/dist-ti/serverModuleLocation.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Mode } from './Mode.js';
+export declare function serverModuleLocation: exact ((projectDir: string, mode: Mode, codeLocation: string, relFile: string) => string);
+//# sourceMappingURL=serverModuleLocation.d.ts.map

package/dist-ti/serverRpc.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function serverRpc: exact ((parent: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor);
+//# sourceMappingURL=serverRpc.d.ts.map

package/dist-ti/serverRpcs.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { ServerRpcFunction } from './ServerRpcFunction.type.js';
+export declare const serverRpcs: Record<string, ServerRpcFunction>;
+//# sourceMappingURL=serverRpcs.d.ts.map

package/dist-ti/settings.d.ts

@@ -0,0 +1,34 @@
+// @tightscript-object-permissions
+export declare const buildFolder = ".tungsten";
+export declare const buildCodeSubPath = "code";
+export declare const devBuildOuterFolder = ".tungsten/dev";
+export declare const devBuildFolder = ".tungsten/dev/code";
+export declare const prodBuildFolder = ".tungsten/prod";
+export declare const prodBuildCodeFolder = ".tungsten/prod/code";
+export declare const devRawBuildFolder = ".tungsten/dev-raw";
+export declare const prodRawBuildFolder = ".tungsten/prod-raw";
+export declare const bundleFolder = ".tungsten/prod/.bundle";
+export declare const staticSiteFolder = ".tungsten/staticSite";
+export declare const packagesCacheFolder = ".tungsten/packagesCache";
+export declare const packagesCacheInfoName = "info.json";
+export declare const stylesCacheFolder = ".tungsten/stylesCache";
+export declare const serverFolder = "server";
+export declare const clientFolder = ".client";
+export declare const staticFolder = ".static";
+export declare const publicFolder = ".public";
+export declare const assetsFolder = ".assets";
+export declare const componentCssFolder = ".componentCss";
+export declare const componentCssFile = "ccss.css";
+export declare const frameworkCssFolder = ".tungstenCss";
+export declare const frameworkCssFile = "tungsten.css";
+export declare const packagesFolder = ".packages";
+export declare const docInitFile = "docInit.js";
+export declare const docInitWindowKey = "__t_docInit";
+export declare const docInitErrorsWindowKey = "__t_docInitErrors";
+export declare const unusedStyleReporting: boolean;
+export declare const defaultBrowserTargets = "since 2020";
+export declare const packageName = "tungsten";
+export declare const packageNameCapitalized = "Tungsten";
+export declare const frameworkClientFolder = "_client";
+export declare const frameworkDistFolder = "dist";
+//# sourceMappingURL=settings.d.ts.map

package/dist-ti/signals/tracking.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Dependency tracking for signals components.
+ *
+ * Dependencies are keyed by (object identity, key) in a side table rather than by path, so a
+ * consumer is connected to whatever object it actually read, wherever that object sits in a
+ * state tree -- a child reading `props.item.name` subscribes to (item, 'name') directly.
+ * The state proxies call track() from their get traps and notify() from their write paths;
+ * an effect collects its dependencies while it runs and drops them all before each re-run.
+ *
+ * Only synchronous reads are tracked: the active effect is restored as soon as fn() returns,
+ * so reads after an `await` inside an async content() are not seen.
+ *
+ * No imports here on purpose -- the proxy handlers depend on this, so it must stay a leaf.
+ */
+// @tightscript-object-permissions
+export type Effect = {
+    deps: Set<Set<Effect>>;
+    trigger: () => void;
+};
+export declare const ITERATE: unique symbol;
+export declare function createEffect: exact ((trigger: () => void) => Effect);
+export declare function isTracking: exact (() => boolean);
+/** called by the proxies on every read; a no-op unless an effect is running */
+export declare function track: exact ((target: object, key: unknown) => void);
+/** wake every effect subscribed to any of the given keys, each at most once */
+export declare function notify: exact ((target: object, ...keys: unknown[]) => void);
+/** wake every effect subscribed to anything on the target; for bulk mutations like splice */
+export declare function notifyAll: exact ((target: object) => void);
+/** run fn with reads subscribing the effect; previous deps are dropped so they are re-collected */
+export declare function runEffect: exact (<T>(effect: Effect, fn: () => T) => T);
+/** run fn without subscribing the current effect to anything it reads */
+export declare function untracked: exact (<T>(fn: () => T) => T);
+export declare function disposeEffect: exact ((effect: Effect) => void);
+//# sourceMappingURL=tracking.d.ts.map

package/dist-ti/slash.d.ts

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

package/dist-ti/spawnShellCommand.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import { type SpawnOptionsWithoutStdio } from 'child_process';
+export declare function spawnShellCommand: exact ((command: string, extras: SpawnOptionsWithoutStdio) => r import("child_process").ChildProcessWithoutNullStreams);
+//# sourceMappingURL=spawnShellCommand.d.ts.map