tungsten 0.7.1 → 0.8.0

package/dist-ti/ReqRes.d.ts

@@ -0,0 +1,170 @@
+// @tightscript-object-permissions
+declare global {
+    namespace Express {
+        interface Request {
+        }
+        interface Response {
+        }
+    }
+}
+export interface IncomingHeaders {
+    'set-cookie'?: string[] | undefined;
+    [name: string]: string | string[] | undefined;
+}
+export interface OutgoingHeaders {
+    [name: string]: number | string | string[] | undefined;
+}
+export interface ParsedQuery {
+    [key: string]: undefined | string | ParsedQuery | (string | ParsedQuery)[];
+}
+export interface MediaType {
+    value: string;
+    quality: number;
+    type: string;
+    subtype: string;
+}
+export interface CookieOptions {
+    maxAge?: number | undefined;
+    signed?: boolean | undefined;
+    expires?: Date | undefined;
+    httpOnly?: boolean | undefined;
+    path?: string | undefined;
+    domain?: string | undefined;
+    secure?: boolean | undefined;
+    encode?: ((val: string) => string) | undefined;
+    sameSite?: boolean | 'lax' | 'strict' | 'none' | undefined;
+    priority?: 'low' | 'medium' | 'high';
+    partitioned?: boolean | undefined;
+}
+export interface RangeParserRange {
+    start: number;
+    end: number;
+}
+export interface RangeParserRanges extends Array<RangeParserRange> {
+    type: string;
+}
+export type RangeParserResult = -1 | -2;
+export type Errback = (err?: Error) => void;
+export type NextFunction = (err?: any) => void;
+export interface Request extends Express.Request {
+    get(name: 'set-cookie'): string[] | undefined;
+    get(name: string): string | undefined;
+    header(name: 'set-cookie'): string[] | undefined;
+    header(name: string): string | undefined;
+    accepts(): string[];
+    accepts(type: string): string | false;
+    accepts(type: string[]): string | false;
+    accepts(...type: string[]): string | false;
+    acceptsCharsets(): string[];
+    acceptsCharsets(charset: string): string | false;
+    acceptsCharsets(charset: string[]): string | false;
+    acceptsCharsets(...charset: string[]): string | false;
+    acceptsEncodings(): string[];
+    acceptsEncodings(encoding: string): string | false;
+    acceptsEncodings(encoding: string[]): string | false;
+    acceptsEncodings(...encoding: string[]): string | false;
+    acceptsLanguages(): string[];
+    acceptsLanguages(lang: string): string | false;
+    acceptsLanguages(lang: string[]): string | false;
+    acceptsLanguages(...lang: string[]): string | false;
+    range(size: number, options?: {
+        combine?: boolean | undefined;
+    }): RangeParserRanges | RangeParserResult | undefined;
+    is(type: string | string[]): string | false | null;
+    accepted: MediaType[];
+    body: any;
+    cookies: any;
+    signedCookies: any;
+    params: Record<string, string | string[]>;
+    query: ParsedQuery;
+    readonly protocol: string;
+    readonly secure: boolean;
+    readonly ip: string | undefined;
+    readonly ips: string[];
+    readonly subdomains: string[];
+    readonly path: string;
+    readonly hostname: string;
+    readonly host: string;
+    readonly fresh: boolean;
+    readonly stale: boolean;
+    readonly xhr: boolean;
+    originalUrl: string;
+    baseUrl: string;
+    app: unknown;
+    route: any;
+    res?: Response | undefined;
+    next?: NextFunction | undefined;
+    headers: IncomingHeaders;
+    rawHeaders: string[];
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    trailers: Record<string, string | undefined>;
+    rawTrailers: string[];
+    method: string;
+    url: string;
+    complete: boolean;
+    socket: unknown;
+    destroy(error?: Error): void;
+    setEncoding(encoding: string): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+}
+export interface Response extends Express.Response {
+    status(code: number): this;
+    sendStatus(code: number): this;
+    links(links: any): this;
+    send(body?: any): this;
+    json(body?: any): this;
+    jsonp(body?: any): this;
+    sendFile(path: string, fn?: Errback): void;
+    sendFile(path: string, options: any, fn?: Errback): void;
+    download(path: string, fn?: Errback): void;
+    download(path: string, filename: string, fn?: Errback): void;
+    contentType(type: string): this;
+    type(type: string): this;
+    format(obj: any): this;
+    attachment(filename?: string): this;
+    set(field: any): this;
+    set(field: string, value?: string | string[]): this;
+    header(field: any): this;
+    header(field: string, value?: string | string[]): this;
+    get(field: string): string | undefined;
+    clearCookie(name: string, options?: CookieOptions): this;
+    cookie(name: string, val: any, options?: CookieOptions): this;
+    location(url: string): this;
+    redirect(url: string): void;
+    redirect(status: number, url: string): void;
+    render(view: string, options?: object, callback?: (err: Error, html: string) => void): void;
+    render(view: string, callback?: (err: Error, html: string) => void): void;
+    vary(field: string): this;
+    append(field: string, value?: string[] | string): this;
+    locals: Record<string, any>;
+    charset: string;
+    app: unknown;
+    req: Request;
+    statusCode: number;
+    statusMessage: string;
+    headersSent: boolean;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+    getHeader(name: string): number | string | string[] | undefined;
+    getHeaders(): OutgoingHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+    end(chunk?: any, callback?: () => void): this;
+    writeHead(statusCode: number, headers?: OutgoingHeaders | (number | string | string[])[]): this;
+    flushHeaders(): void;
+    socket: unknown;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+}
+export type ReqRes = {
+    req: Request;
+    res: Response;
+};
+export type ReqResOrNull = ReqRes | null;
+//# sourceMappingURL=ReqRes.d.ts.map

package/dist-ti/Sass.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+export declare function Sass: exact ((styles: string) => exact rw {
+    classes: undefined;
+    elements: undefined;
+    styles: undefined;
+});
+//# sourceMappingURL=Sass.d.ts.map

package/dist-ti/Script.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import { TungstenSimpleComponent, type TungstenComponentPropsBase } from './Components.jsx';
+export interface ScriptProps extends TungstenComponentPropsBase {
+    children?: string;
+}
+export declare class Script extends TungstenSimpleComponent<ScriptProps> {
+    content: () => owned rw import("./ContentNode.js").ContentNodeClassComponent | owned rw import("./ContentNode.js").ContentNodeFragment | owned rw import("./ContentNode.js").ContentNodeFunctionComponent | owned rw import("./ContentNode.js").ContentNodeHtml;
+}
+//# sourceMappingURL=Script.d.ts.map

package/dist-ti/ServerRpcFunction.type.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export type ServerRpcFunction = (...args: any[]) => Promise<any>;
+//# sourceMappingURL=ServerRpcFunction.type.d.ts.map

package/dist-ti/Servers/DevServer.d.ts

@@ -0,0 +1,57 @@
+// @tightscript-object-permissions
+import type { Server } from 'http';
+import express from 'express';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+import type { ApiRoutes } from '../api/ApiRoutes.js';
+import type { Framework } from '../Framework.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
+import { type BrandedGlobalDataFunction } from '../routing/registerGlobalData.js';
+import { TungstenServer } from './TungstenServer.jsx';
+export declare class DevServer extends TungstenServer {
+    framework: Framework;
+    config: FrameworkConfigComplete;
+    compilationInfo: CompilationInfo;
+    requestedPort: number;
+    publicOrigin: string | null;
+    expectedHost: string | null;
+    initialProcessEnv: Record<string, string>;
+    app: express.Application;
+    apiRoutes?: ApiRoutes;
+    apiPath?: string;
+    server?: Server;
+    firstRender: boolean;
+    iterationCount: number;
+    serverIterationCount: number;
+    private liveReloadClients;
+    private unsubscribeReload;
+    private watchedMiddleware;
+    private bootId;
+    constructor(framework: Framework, config: FrameworkConfigComplete, compilationInfo: CompilationInfo, initialProcessEnv?: Record<string, string>);
+    private addServerMiddleware;
+    private addWatchedServerMiddleware;
+    private addPerRequestServerMiddleware;
+    private handleLiveReloadStream;
+    private reloadDebounceTimer;
+    private pendingReloadKind;
+    private pendingReloadFiles;
+    private static readonly reloadDebounceMs;
+    private broadcastReloadEvent;
+    private sourceFileToUrlPath;
+    private handleRequestApi;
+    private handleRequest;
+    private handleRequestPipeline;
+    private renderPipelinePage;
+    private tryRenderErrorRoute;
+    getGlobalData: (func: BrandedGlobalDataFunction, reqRes: ReqRes, context: BrandedContext, networkedData: BrandedNetworkedData, location: string) => Promise<BrandedGlobalData>;
+    printError: (error: unknown, errorSites?: string[]) => void;
+    errorPage: (error: unknown, errorSites: string[]) => string;
+    start: () => rw Promise<exact rw {
+        localOrigin: string;
+        publicOrigin: string;
+        port: number;
+    }>;
+    stop: () => void;
+}
+//# sourceMappingURL=DevServer.d.ts.map

package/dist-ti/Servers/ProdServer.d.ts

@@ -0,0 +1,38 @@
+// @tightscript-object-permissions
+import type { Server } from 'http';
+import express from 'express';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+import type { ApiRoutes } from '../api/ApiRoutes.js';
+import type { Framework } from '../Framework.js';
+import type { AnyComponentType } from '../AnyComponentType.js';
+import type { AppRoutes } from '../routing/AppRoutes.js';
+import type { ServerMiddleware } from './ServerMiddleware.js';
+import type { PipelineApp } from '../pipeline/pipelineDefinition.js';
+import { TungstenServer } from './TungstenServer.jsx';
+export declare class ProdServer extends TungstenServer {
+    framework: Framework;
+    config: FrameworkConfigComplete;
+    compilationInfo: CompilationInfo;
+    appRoutes: AppRoutes<any>;
+    RootComponentOrNull: AnyComponentType | null;
+    publicOrigin: string | null;
+    expectedHost: string | null;
+    app: express.Application;
+    apiRoutesPromise?: Promise<ApiRoutes>;
+    apiRoutes?: ApiRoutes;
+    server?: Server;
+    private bootId;
+    constructor(framework: Framework, config: FrameworkConfigComplete, compilationInfo: CompilationInfo, appRoutes: AppRoutes<any>, RootComponentOrNull: AnyComponentType | null, serverMiddleware: ServerMiddleware | null, pipelineApp?: PipelineApp | null);
+    private readonly pipelineApp;
+    private handleRequestApi;
+    handleRequestPipeline: (req: express.Request, res: express.Response) => Promise<void>;
+    private renderPipelinePage;
+    handleRequest: (req: express.Request, res: express.Response) => Promise<void>;
+    private tryRenderErrorRoute;
+    private stubRoot;
+    errorPage: () => string;
+    start(portOverride?: number | null, mute?: boolean): Promise<string>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=ProdServer.d.ts.map

package/dist-ti/Servers/ServerMiddleware.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { RequestHandler } from 'express';
+export type ServerMiddleware = {
+    path: string;
+    middlewares: RequestHandler[];
+};
+//# sourceMappingURL=ServerMiddleware.d.ts.map

package/dist-ti/Servers/StaticSiteServer.d.ts

@@ -0,0 +1,15 @@
+// @tightscript-object-permissions
+import type { Server } from 'http';
+import express from 'express';
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+export declare class StaticSiteServer {
+    config: FrameworkConfigComplete;
+    location?: string;
+    app: express.Application;
+    server?: Server;
+    staticSiteLocation: string;
+    constructor(config: FrameworkConfigComplete);
+    start: () => Promise<string>;
+    stop: () => void;
+}
+//# sourceMappingURL=StaticSiteServer.d.ts.map

package/dist-ti/Servers/TungstenServer.d.ts

@@ -0,0 +1,43 @@
+// @tightscript-object-permissions
+import type { Response as ExpressResponse } from 'express';
+import type { AnyComponentType } from '../AnyComponentType.js';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { PipelineApp, StageContext } from '../pipeline/pipelineDefinition.js';
+import type { RequestProgress } from '../pipeline/runPipeline.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { AppRoutes } from '../routing/AppRoutes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { Routes } from '../routing/Routes.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import { Instance } from '../Instance/Instance.js';
+export type PipelinePage = {
+    location: string;
+    reqRes: ReqRes;
+    instanceConfig: InstanceConfig;
+    fileVersions: Record<string, string> | undefined;
+    appRoutes: AppRoutes<any>;
+    routes: Routes<any>;
+    matchedRouteInfo: MatchedRouteInfo;
+    serverDataLoading: ServerDataLoading;
+    allRoutesData: unknown;
+    context: object;
+    networked: object | undefined;
+};
+export type PipelineErrorPage = {
+    ErrorPage: AnyComponentType;
+    instance: Instance;
+    errorInfo: TungstenErrorInfo;
+};
+export declare class TungstenServer {
+    protected staticFileRegex: rw RegExp;
+    protected makeOrigin(proto: string, host: string, port: number): string;
+    protected arrivedAt(host: string, proto: string): string;
+    protected hostOfOrigin(origin: string): string | null;
+    protected handleRedirects(res: ExpressResponse, matchedRouteInfo: MatchedRouteInfo, config: Pick<InstanceConfig, 'siteBasePath' | 'staticSite'>, allRoutesData?: unknown): boolean;
+    protected pipelineInstance(page: PipelinePage): rw Instance;
+    protected pipelineErrorPage(app: PipelineApp | undefined, progress: RequestProgress, error: unknown, page: Pick<PipelinePage, 'location' | 'reqRes' | 'instanceConfig' | 'fileVersions'>, message?: string): PipelineErrorPage | undefined;
+}
+export declare const runnerOf: (app: PipelineApp) => r import("../pipeline/runPipeline.js").ServerRunner;
+export declare const appRoutesFor: (app: PipelineApp, init: StageContext | undefined, dev: boolean) => AppRoutes<any>;
+//# sourceMappingURL=TungstenServer.d.ts.map

package/dist-ti/Servers/cacheVersioned.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { RequestHandler } from 'express';
+export declare function cacheVersioned: exact ((root: string) => RequestHandler);
+//# sourceMappingURL=cacheVersioned.d.ts.map

package/dist-ti/Servers/devErrorPageAutoRetry.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+export declare const maxAutoRetryAttempts = 8;
+export declare function devErrorPageAutoRetryScript: exact ((error: unknown) => string);
+export declare const devErrorPageClearRetryScript = "try{sessionStorage.removeItem('tungstenDevErrorRetryCount')}catch(e){}";
+//# sourceMappingURL=devErrorPageAutoRetry.d.ts.map

package/dist-ti/Servers/initStores.d.ts

@@ -0,0 +1,17 @@
+// @tightscript-object-permissions
+import type { StoreSubscriptionsMap } from '../Store/StoreSubscriptions.types.js';
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
+import { InternalStoreSchema } from '../Store/InternalStoreSchema.js';
+import { type TrueStore } from '../Store/makeStore.js';
+type InitStoresResult = {
+    internalStore: TrueStore<InternalStoreSchema>;
+    stores: TrueStore<object>[];
+    storeSubscriptions: StoreSubscriptionsMap;
+};
+export declare function initStores(location: string, reqResOrNull: ReqRes, globalData: BrandedGlobalData, matchedRouteInfo: MatchedRouteInfo, serverDataLoading: ServerDataLoading, context: BrandedContext, networkedData: BrandedNetworkedData): InitStoresResult;
+export declare function initStores(location: string, reqResOrNull: null, globalData: BrandedGlobalData, matchedRouteInfo: MatchedRouteInfo, serverDataLoading: null, context: BrandedContext, networkedData: BrandedNetworkedData): InitStoresResult;
+export {};
+//# sourceMappingURL=initStores.d.ts.map

package/dist-ti/Servers/listenVerified.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import type { Server as HttpServer } from 'http';
+import type { Server as NetServer } from 'net';
+import type { Application } from 'express';
+export declare const bootProbePath = "/__tungsten_boot_probe__";
+export declare function newBootId: exact (() => string);
+export declare function registerBootProbe: exact ((app: Application, bootId: string) => void);
+export declare function verifyListening: exact ((server: NetServer, bootId: string, timeoutMs?: number) => Promise<number>);
+export declare function listenVerified: exact ((app: Application, port: number, bootId: string, timeoutMs?: number) => Promise<{
+    server: HttpServer;
+    port: number;
+}>);
+//# sourceMappingURL=listenVerified.d.ts.map

package/dist-ti/Servers/loadEnvsDev.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
+type ProcessEnv = {
+    [x: string]: string | undefined;
+};
+export declare function loadEnvsDev: exact ((config: FrameworkConfigComplete, iteration: number, initialProcessEnv: ProcessEnv, _firstLoad: boolean, useTestEnvFiles?: boolean, buildCodeFolder?: string) => rw Promise<void>);
+export {};
+//# sourceMappingURL=loadEnvsDev.d.ts.map

package/dist-ti/Servers/portError.d.ts

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

package/dist-ti/Servers/resetRegistrations.d.ts

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

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

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { Routes } from '../routing/Routes.js';
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+export declare function routing: exact ((location: string, routes: Routes, context: BrandedContext, networkedData: BrandedNetworkedData, serverDataLoading?: rw ServerDataLoading | null) => Promise<MatchedRouteInfo>);
+//# sourceMappingURL=routing.d.ts.map

package/dist-ti/Servers/serveStatic.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import express from 'express';
+type StaticOptions = NonNullable<Parameters<typeof express.static>[1]>;
+export declare function serveStatic: exact ((root: string, options?: StaticOptions) => ReturnType<typeof express.static>);
+export {};
+//# sourceMappingURL=serveStatic.d.ts.map

package/dist-ti/Servers/stubInstance.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { CacheControl } from '../cacheControl.js';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { AppRoutes } from '../routing/AppRoutes.js';
+import { Instance } from '../Instance/Instance.js';
+export declare function stubInstance: exact ((location: string, instanceConfig: InstanceConfig, reqRes: ReqRes, appRoutes: AppRoutes<any>) => Instance);
+export declare function sendStub: exact ((reqRes: ReqRes, cacheControl: CacheControl | undefined, html: string) => void);
+//# sourceMappingURL=stubInstance.d.ts.map

package/dist-ti/Servers/tungstenCorePrivateEnvSchema.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+import * as v from 'valibot';
+export declare const tungstenCorePrivateEnvSchema: r v.LooseObjectSchema<exact r {
+    readonly TUNGSTEN_SERVER_PORT: r v.OptionalSchema<v.SchemaWithPipe<readonly [r v.NumberSchema<undefined>, r v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly DEBUG: r v.OptionalSchema<r v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type TungstenCorePrivateEnv = ReadProperties<v.InferOutput<typeof tungstenCorePrivateEnvSchema>>;
+//# sourceMappingURL=tungstenCorePrivateEnvSchema.d.ts.map

package/dist-ti/Servers/tungstenCorePublicEnvSchema.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import * as v from 'valibot';
+export declare const tungstenCorePublicEnvSchema: r v.LooseObjectSchema<exact r {
+    readonly FRONTEND_PROTO: r v.OptionalSchema<r v.PicklistSchema<r ["http", "https"], undefined>, undefined>;
+    readonly FRONTEND_HOSTNAME: r v.OptionalSchema<r v.StringSchema<undefined>, undefined>;
+    readonly FRONTEND_PORT: r v.OptionalSchema<v.SchemaWithPipe<readonly [r v.NumberSchema<undefined>, r v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;
+export type TungstenCorePublicEnv = ReadProperties<v.InferOutput<typeof tungstenCorePublicEnvSchema>>;
+//# sourceMappingURL=tungstenCorePublicEnvSchema.d.ts.map

package/dist-ti/Servers/watchedServerMiddleware.d.ts

@@ -0,0 +1,11 @@
+// @tightscript-object-permissions
+import { type RequestHandler } from 'express';
+import type { ModuleNamespace } from '../importModule.js';
+export type WatchedServerMiddleware = {
+    handler: RequestHandler;
+    ready: Promise<void>;
+    close: () => Promise<void>;
+};
+export declare function watchedServerMiddleware: exact ((load: () => Promise<readonly RequestHandler[]>, watched: string, ignored: string[]) => WatchedServerMiddleware);
+export declare function middlewaresExport: exact ((module: ModuleNamespace, exportName: string, file: string) => readonly RequestHandler[]);
+//# sourceMappingURL=watchedServerMiddleware.d.ts.map

package/dist-ti/Store/BaseStoreSchema.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare abstract class BaseStoreSchema {
+}
+//# sourceMappingURL=BaseStoreSchema.d.ts.map

package/dist-ti/Store/InternalStoreSchema.d.ts

@@ -0,0 +1,22 @@
+// @tightscript-object-permissions
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { PopMessage } from '../PopMessage.type.js';
+import type { ComponentStoreValue } from '../Components.jsx';
+import type { ReadonlyTrueStoreValue, StoreValue } from './makeStore.js';
+export declare class InternalStoreSchema {
+    location: string;
+    navigationIndex: number;
+    navigating: boolean;
+    matchedRouteInfo: MatchedRouteInfo;
+    popMessages: PopMessage[];
+    constructor(location: string, matchedRouteInfo: MatchedRouteInfo);
+}
+export type FrameworkOwnedInternalKeys = 'navigating' | 'navigationIndex';
+export type InternalStore = {
+    [Key in keyof InternalStoreSchema]: Key extends FrameworkOwnedInternalKeys ? ReadonlyTrueStoreValue<InternalStoreSchema[Key]> : StoreValue<InternalStoreSchema[Key]>;
+};
+export type InternalComponentStore = {
+    [Key in keyof InternalStoreSchema]: Key extends FrameworkOwnedInternalKeys ? Omit<ComponentStoreValue<InternalStoreSchema[Key]>, 'set'> : ComponentStoreValue<InternalStoreSchema[Key]>;
+};
+export type PartialInternalStoreSchema = Pick<InternalStoreSchema, 'popMessages'> & Partial<Omit<InternalStoreSchema, 'popMessages' | FrameworkOwnedInternalKeys>>;
+//# sourceMappingURL=InternalStoreSchema.d.ts.map

package/dist-ti/Store/ServerDataLoading.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+export type ServerDataLoading = {
+    value: boolean;
+};
+//# sourceMappingURL=ServerDataLoading.d.ts.map

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

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

package/dist-ti/Store/StoreProxyInterface.d.ts

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

package/dist-ti/Store/StoreSchemaClass.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { GlobalData } from '../routing/registerGlobalData.js';
+import type { NetworkedData } from '../routing/routingRegistry.js';
+import type { Context } from '../context/registerContext.js';
+import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
+export type StoreSchemaClass<StoreSchema> = new (reqRes: ReqRes | null, context: Context, networkedData: NetworkedData, globalData: GlobalData, matchedRouteInfo: MatchedRouteInfo) => StoreSchema;
+export type BrandedStoreSchemaClass<StoreSchema> = new (reqRes: ReqRes | null, context: BrandedContext, networkedData: BrandedNetworkedData, globalData: BrandedGlobalData, matchedRouteInfo: MatchedRouteInfo) => StoreSchema;
+//# sourceMappingURL=StoreSchemaClass.d.ts.map

package/dist-ti/Store/StoreSubscriptions.types.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { TungstenBaseComponent } from '../Components.jsx';
+import type { ReadonlyTrueStore } from './makeStore.js';
+import type { Key } from '../Key.js';
+export type SubscribedElements = Map<TungstenBaseComponent<any, any>, Set<Key>>;
+export type StoreSubscriptionsMap = Map<ReadonlyTrueStore<object>, SubscribedElements>;
+//# sourceMappingURL=StoreSubscriptions.types.d.ts.map

package/dist-ti/Store/TypeSafeStore.d.ts

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

package/dist-ti/Store/createStores.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+import type { ServerDataLoading } from './ServerDataLoading.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { StoreSubscriptionsMap } from './StoreSubscriptions.types.js';
+import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
+import { type TrueStore } from './makeStore.js';
+export declare function createStores: exact ((reqRes: ReqRes | null, matchedRouteInfo: MatchedRouteInfo, globalData: BrandedGlobalData, storeSubscriptionsMap: StoreSubscriptionsMap, serverDataLoading: ServerDataLoading | null, context: BrandedContext, networkedData: BrandedNetworkedData) => TrueStore<unknown>[]);
+//# sourceMappingURL=createStores.d.ts.map

package/dist-ti/Store/exportStore.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { TrueStore } from './makeStore.js';
+export declare function exportStore: exact (<Schema extends object>(store: TrueStore<Schema>) => rw Record<string, unknown>);
+//# sourceMappingURL=exportStore.d.ts.map

package/dist-ti/Store/getInternalStore.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { TungstenBaseStoreComponentAny } from '../Components.jsx';
+import type { InternalComponentStore } from './InternalStoreSchema.js';
+export declare function getInternalStore: exact ((element: TungstenBaseStoreComponentAny) => InternalComponentStore);
+//# sourceMappingURL=getInternalStore.d.ts.map

package/dist-ti/Store/getStore.d.ts

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