@authup/server-core 1.0.0-beta.58 → 1.0.0-beta.59

package/dist/adapters/http/ui/theme/apply.mjs

@@ -0,0 +1,29 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { injectHeadContent, stampDocumentTitle } from "../shared/html.mjs";
+import "../shared/index.mjs";
+import { escapeHtml } from "./contract/head.mjs";
+import "./contract/index.mjs";
+//#region src/adapters/http/ui/theme/apply.ts
+/**
+* Apply the operator theme to a rendered console shell. A no-op when
+* theming is off or the directory carries no manifest, so both console
+* serve paths can call it unconditionally.
+*
+* Lives outside contract/ because it takes a provider (filesystem-backed)
+* and splices into a served document: contract/ stays a pure description
+* of what a theme IS.
+*/ async function applyTheme(html, provider, basePath) {
+	if (!provider) return html;
+	let body = html;
+	const manifest = await provider.getManifest();
+	if (manifest?.title) body = stampDocumentTitle(body, escapeHtml(manifest.title));
+	const head = await provider.getHead(basePath);
+	if (head) body = injectHeadContent(body, head);
+	return body;
+}
+//#endregion
+export { applyTheme };
+
+//# sourceMappingURL=apply.mjs.map

package/dist/adapters/http/ui/theme/apply.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.mjs","names":["injectHeadContent","stampDocumentTitle","escapeHtml","applyTheme","html","provider","basePath","body","manifest","getManifest","title","head","getHead"],"sources":["../../../../../src/adapters/http/ui/theme/apply.ts"],"sourcesContent":["/*\n * Copyright (c) 2026.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport { injectHeadContent, stampDocumentTitle } from '../shared/index.ts';\nimport { escapeHtml } from './contract/index.ts';\nimport type { IThemeProvider } from './types.ts';\n\n/**\n * Apply the operator theme to a rendered console shell. A no-op when\n * theming is off or the directory carries no manifest, so both console\n * serve paths can call it unconditionally.\n *\n * Lives outside contract/ because it takes a provider (filesystem-backed)\n * and splices into a served document: contract/ stays a pure description\n * of what a theme IS.\n */\nexport async function applyTheme(\n    html: string,\n    provider: IThemeProvider | undefined,\n    basePath: string,\n) : Promise<string> {\n    if (!provider) {\n        return html;\n    }\n\n    let body = html;\n\n    // A directory may carry only a fragment, or only a stylesheet, so the\n    // manifest is not a precondition for applying the theme.\n    const manifest = await provider.getManifest();\n    if (manifest?.title) {\n        body = stampDocumentTitle(body, escapeHtml(manifest.title));\n    }\n\n    const head = await provider.getHead(basePath);\n    if (head) {\n        body = injectHeadContent(body, head);\n    }\n\n    return body;\n}\n"],"mappings":";;;;;;;;;;;;;;;;GAoBA,eAAsBG,WAClBC,MACAC,UACAC,UAAgB;CAEhB,IAAI,CAACD,UACD,OAAOD;CAGX,IAAIG,OAAOH;CAIX,MAAMI,WAAW,MAAMH,SAASI,YAAW;CAC3C,IAAID,UAAUE,OACVH,OAAON,mBAAmBM,MAAML,WAAWM,SAASE,KAAK,CAAA;CAG7D,MAAMC,OAAO,MAAMN,SAASO,QAAQN,QAAAA;CACpC,IAAIK,MACAJ,OAAOP,kBAAkBO,MAAMI,IAAAA;CAGnC,OAAOJ;AACX"}

package/dist/adapters/http/ui/theme/assets.d.ts

@@ -0,0 +1,20 @@
+import type { Handler } from 'routup';
+import type { IThemeProvider } from './types.ts';
+/**
+ * Serves the operator theme's `assets/` directory.
+ *
+ * Deliberately NOT `@routup/assets`' createHandler, for three reasons that
+ * matter for an operator-supplied root:
+ * - its lookup walks PATH SUFFIXES, so `/theme/anything/logo.svg` would
+ *   serve `/logo.svg`; the same file becomes reachable at unbounded
+ *   distinct URLs.
+ * - it probes `.html` / `index.html` by default, which would make a stray
+ *   index.html a servable document on the IdP origin.
+ * - it performs no realpath containment check, so a symlink inside the
+ *   mounted directory pointing outside it is served with a 200. A
+ *   read-only mount does not prevent that, and refusing symlinks outright
+ *   is not an option: a Kubernetes ConfigMap volume IS a symlink farm
+ *   (`key -> ..data/key`).
+ */
+export declare function createThemeAssetsHandler(provider: IThemeProvider): Handler;
+//# sourceMappingURL=assets.d.ts.map

package/dist/adapters/http/ui/theme/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/http/ui/theme/assets.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAQtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,cAAc,GAAI,OAAO,CAqG3E"}

package/dist/adapters/http/ui/theme/assets.mjs

@@ -0,0 +1,86 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { THEME_ASSET_CONTENT_TYPES, THEME_ASSET_EXTENSIONS } from "./contract/constants.mjs";
+import { themeAssetExtension } from "./contract/utils.mjs";
+import "./contract/index.mjs";
+import { THEME_ASSET_CSP } from "./constants.mjs";
+import path from "node:path";
+import { HeaderName, defineCoreHandler, sendFile } from "routup";
+import fs from "node:fs";
+import { Readable } from "node:stream";
+//#region src/adapters/http/ui/theme/assets.ts
+const REQUEST_PATH_PATTERN = /^[a-z0-9][a-z0-9._/-]*$/i;
+/**
+* Serves the operator theme's `assets/` directory.
+*
+* Deliberately NOT `@routup/assets`' createHandler, for three reasons that
+* matter for an operator-supplied root:
+* - its lookup walks PATH SUFFIXES, so `/theme/anything/logo.svg` would
+*   serve `/logo.svg`; the same file becomes reachable at unbounded
+*   distinct URLs.
+* - it probes `.html` / `index.html` by default, which would make a stray
+*   index.html a servable document on the IdP origin.
+* - it performs no realpath containment check, so a symlink inside the
+*   mounted directory pointing outside it is served with a 200. A
+*   read-only mount does not prevent that, and refusing symlinks outright
+*   is not an option: a Kubernetes ConfigMap volume IS a symlink farm
+*   (`key -> ..data/key`).
+*/ function createThemeAssetsHandler(provider) {
+	return defineCoreHandler(async (event) => {
+		const assetsPath = await provider.getAssetsPath();
+		if (!assetsPath) {
+			event.response.status = 404;
+			return null;
+		}
+		let requestPath = event.path;
+		const { mountPath } = event;
+		if (requestPath.startsWith(mountPath)) requestPath = requestPath.substring(mountPath.length);
+		if (requestPath.includes("%")) try {
+			requestPath = decodeURIComponent(requestPath);
+		} catch {
+			event.response.status = 404;
+			return null;
+		}
+		requestPath = requestPath.replace(/^\/+/, "");
+		const extension = themeAssetExtension(requestPath);
+		if (!requestPath || !REQUEST_PATH_PATTERN.test(requestPath) || requestPath.split("/").includes("..") || !THEME_ASSET_EXTENSIONS.includes(extension)) {
+			event.response.status = 404;
+			return null;
+		}
+		let root;
+		let filePath;
+		let stats;
+		try {
+			root = await fs.promises.realpath(assetsPath);
+			filePath = await fs.promises.realpath(path.join(assetsPath, requestPath));
+			stats = await fs.promises.stat(filePath);
+		} catch {
+			event.response.status = 404;
+			return null;
+		}
+		if (!stats.isFile() || filePath !== root && !filePath.startsWith(root + path.sep)) {
+			event.response.status = 404;
+			return null;
+		}
+		const etag = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+		event.response.headers.set(HeaderName.CACHE_CONTROL, "public, max-age=0, must-revalidate");
+		if (event.headers.get(HeaderName.IF_NONE_MATCH) === etag) {
+			event.response.status = 304;
+			return null;
+		}
+		const response = await sendFile(event, {
+			content: (options) => Readable.toWeb(fs.createReadStream(filePath, options)),
+			stats: () => stats,
+			name: filePath
+		});
+		response.headers.set(HeaderName.CONTENT_TYPE, THEME_ASSET_CONTENT_TYPES[extension]);
+		response.headers.set("x-content-type-options", "nosniff");
+		response.headers.set("content-security-policy", THEME_ASSET_CSP);
+		return response;
+	});
+}
+//#endregion
+export { createThemeAssetsHandler };
+
+//# sourceMappingURL=assets.mjs.map

package/dist/adapters/http/ui/theme/assets.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.mjs","names":["fs","path","Readable","HeaderName","defineCoreHandler","sendFile","THEME_ASSET_CSP","THEME_ASSET_CONTENT_TYPES","THEME_ASSET_EXTENSIONS","themeAssetExtension","REQUEST_PATH_PATTERN","createThemeAssetsHandler","provider","event","assetsPath","getAssetsPath","response","status","requestPath","mountPath","startsWith","substring","length","includes","decodeURIComponent","replace","extension","test","split","root","filePath","stats","promises","realpath","join","stat","isFile","sep","etag","size","mtime","getTime","headers","set","CACHE_CONTROL","get","IF_NONE_MATCH","content","options","toWeb","createReadStream","name","CONTENT_TYPE"],"sources":["../../../../../src/adapters/http/ui/theme/assets.ts"],"sourcesContent":["/*\n * Copyright (c) 2026.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { Readable } from 'node:stream';\nimport type { Handler } from 'routup';\nimport { HeaderName, defineCoreHandler, sendFile } from 'routup';\nimport { THEME_ASSET_CSP } from './constants.ts';\nimport {\n    THEME_ASSET_CONTENT_TYPES,\n    THEME_ASSET_EXTENSIONS,\n    themeAssetExtension,\n} from './contract/index.ts';\nimport type { IThemeProvider } from './types.ts';\n\nconst REQUEST_PATH_PATTERN = /^[a-z0-9][a-z0-9._/-]*$/i;\n\n/**\n * Serves the operator theme's `assets/` directory.\n *\n * Deliberately NOT `@routup/assets`' createHandler, for three reasons that\n * matter for an operator-supplied root:\n * - its lookup walks PATH SUFFIXES, so `/theme/anything/logo.svg` would\n *   serve `/logo.svg`; the same file becomes reachable at unbounded\n *   distinct URLs.\n * - it probes `.html` / `index.html` by default, which would make a stray\n *   index.html a servable document on the IdP origin.\n * - it performs no realpath containment check, so a symlink inside the\n *   mounted directory pointing outside it is served with a 200. A\n *   read-only mount does not prevent that, and refusing symlinks outright\n *   is not an option: a Kubernetes ConfigMap volume IS a symlink farm\n *   (`key -> ..data/key`).\n */\nexport function createThemeAssetsHandler(provider: IThemeProvider) : Handler {\n    return defineCoreHandler(async (event) => {\n        const assetsPath = await provider.getAssetsPath();\n        if (!assetsPath) {\n            event.response.status = 404;\n\n            return null;\n        }\n\n        let requestPath = event.path;\n        const { mountPath } = event;\n        if (requestPath.startsWith(mountPath)) {\n            requestPath = requestPath.substring(mountPath.length);\n        }\n\n        if (requestPath.includes('%')) {\n            try {\n                requestPath = decodeURIComponent(requestPath);\n            } catch {\n                event.response.status = 404;\n\n                return null;\n            }\n        }\n\n        requestPath = requestPath.replace(/^\\/+/, '');\n\n        // The contract's own parser, so the set the handler serves cannot\n        // drift from the set the manifest validator accepts.\n        const extension = themeAssetExtension(requestPath);\n\n        if (\n            !requestPath ||\n            !REQUEST_PATH_PATTERN.test(requestPath) ||\n            requestPath.split('/').includes('..') ||\n            !THEME_ASSET_EXTENSIONS.includes(extension)\n        ) {\n            event.response.status = 404;\n\n            return null;\n        }\n\n        // Both the root and the file are realpathed HERE, per request, and\n        // never cached. A Kubernetes ConfigMap update swaps the `..data`\n        // symlink to a new timestamped directory and deletes the old one,\n        // so a root realpath captured at boot dangles after the first\n        // update and every asset 404s until the pod restarts.\n        //\n        // The realpath is also the control that survives a symlink pointing\n        // out of the mount; the pattern check above is only the cheap first\n        // pass. Resolving both within the same request keeps the comparison\n        // consistent: a swap landing between the two calls fails closed\n        // (a transient 404), never open.\n        let root : string;\n        let filePath : string;\n        let stats : fs.Stats;\n        try {\n            root = await fs.promises.realpath(assetsPath);\n            filePath = await fs.promises.realpath(path.join(assetsPath, requestPath));\n            stats = await fs.promises.stat(filePath);\n        } catch {\n            event.response.status = 404;\n\n            return null;\n        }\n\n        if (\n            !stats.isFile() ||\n            (filePath !== root && !filePath.startsWith(root + path.sep))\n        ) {\n            event.response.status = 404;\n\n            return null;\n        }\n\n        const etag = `W/\"${stats.size}-${stats.mtime.getTime()}\"`;\n        event.response.headers.set(HeaderName.CACHE_CONTROL, 'public, max-age=0, must-revalidate');\n\n        if (event.headers.get(HeaderName.IF_NONE_MATCH) === etag) {\n            event.response.status = 304;\n\n            return null;\n        }\n\n        const response = await sendFile(event, {\n            content: (options) => Readable.toWeb(\n                fs.createReadStream(filePath, options),\n            ) as ReadableStream,\n            stats: () => stats,\n            name: filePath,\n        });\n\n        // Pin the content type from our own extension map rather than\n        // letting it be sniffed or inferred, and neutralize SVG as active\n        // content (an SVG navigated to directly executes inline script).\n        response.headers.set(HeaderName.CONTENT_TYPE, THEME_ASSET_CONTENT_TYPES[extension]);\n        response.headers.set('x-content-type-options', 'nosniff');\n        response.headers.set('content-security-policy', THEME_ASSET_CSP);\n\n        return response;\n    });\n}\n"],"mappings":";;;;;;;;;;;;AAoBA,MAAMU,uBAAuB;;;;;;;;;;;;;;;;GAkB7B,SAAgBC,yBAAyBC,UAAwB;CAC7D,OAAOR,kBAAkB,OAAOS,UAAAA;EAC5B,MAAMC,aAAa,MAAMF,SAASG,cAAa;EAC/C,IAAI,CAACD,YAAY;GACbD,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAEA,IAAIC,cAAcL,MAAMZ;EACxB,MAAM,EAAEkB,cAAcN;EACtB,IAAIK,YAAYE,WAAWD,SAAAA,GACvBD,cAAcA,YAAYG,UAAUF,UAAUG,MAAM;EAGxD,IAAIJ,YAAYK,SAAS,GAAA,GACrB,IAAI;GACAL,cAAcM,mBAAmBN,WAAAA;EACrC,QAAQ;GACJL,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAGJC,cAAcA,YAAYO,QAAQ,QAAQ,EAAA;EAI1C,MAAMC,YAAYjB,oBAAoBS,WAAAA;EAEtC,IACI,CAACA,eACD,CAACR,qBAAqBiB,KAAKT,WAAAA,KAC3BA,YAAYU,MAAM,GAAA,CAAA,CAAKL,SAAS,IAAA,KAChC,CAACf,uBAAuBe,SAASG,SAAAA,GACnC;GACEb,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAaA,IAAIY;EACJ,IAAIC;EACJ,IAAIC;EACJ,IAAI;GACAF,OAAO,MAAM7B,GAAGgC,SAASC,SAASnB,UAAAA;GAClCgB,WAAW,MAAM9B,GAAGgC,SAASC,SAAShC,KAAKiC,KAAKpB,YAAYI,WAAAA,CAAAA;GAC5Da,QAAQ,MAAM/B,GAAGgC,SAASG,KAAKL,QAAAA;EACnC,QAAQ;GACJjB,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAEA,IACI,CAACc,MAAMK,OAAM,KACZN,aAAaD,QAAQ,CAACC,SAASV,WAAWS,OAAO5B,KAAKoC,GAAG,GAC5D;GACExB,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAEA,MAAMqB,OAAO,MAAMP,MAAMQ,KAAK,GAAGR,MAAMS,MAAMC,QAAO,EAAG;EACvD5B,MAAMG,SAAS0B,QAAQC,IAAIxC,WAAWyC,eAAe,oCAAA;EAErD,IAAI/B,MAAM6B,QAAQG,IAAI1C,WAAW2C,aAAa,MAAMR,MAAM;GACtDzB,MAAMG,SAASC,SAAS;GAExB,OAAO;EACX;EAEA,MAAMD,WAAW,MAAMX,SAASQ,OAAO;GACnCkC,UAAUC,YAAY9C,SAAS+C,MAC3BjD,GAAGkD,iBAAiBpB,UAAUkB,OAAAA,CAAAA;GAElCjB,aAAaA;GACboB,MAAMrB;EACV,CAAA;EAKAd,SAAS0B,QAAQC,IAAIxC,WAAWiD,cAAc7C,0BAA0BmB,UAAU;EAClFV,SAAS0B,QAAQC,IAAI,0BAA0B,SAAA;EAC/C3B,SAAS0B,QAAQC,IAAI,2BAA2BrC,eAAAA;EAEhD,OAAOU;CACX,CAAA;AACJ"}

package/dist/adapters/http/ui/theme/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SERVING constants. The theme's own vocabulary (layout, manifest, tokens,
+ * asset kinds) lives in contract/, which stays portable.
+ */
+/**
+ * Debounce for the manifest mtime re-check. A burst of renders costs one
+ * stat; an edit takes effect on the next render after the window.
+ */
+export declare const THEME_MANIFEST_REVALIDATE_INTERVAL = 1000;
+/**
+ * An SVG navigated to directly executes inline script, and a theme
+ * directory is exactly where operator SVGs land. This neutralizes that
+ * while leaving `<img>` and `background-image` rendering intact.
+ */
+export declare const THEME_ASSET_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; sandbox";
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapters/http/ui/theme/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/http/ui/theme/constants.ts"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;GAGG;AACH,eAAO,MAAM,kCAAkC,OAAQ,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,eAAe,0EAA0E,CAAC"}

package/dist/adapters/http/ui/theme/constants.mjs

@@ -0,0 +1,20 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/adapters/http/ui/theme/constants.ts
+/**
+* SERVING constants. The theme's own vocabulary (layout, manifest, tokens,
+* asset kinds) lives in contract/, which stays portable.
+*/ /**
+* Debounce for the manifest mtime re-check. A burst of renders costs one
+* stat; an edit takes effect on the next render after the window.
+*/ const THEME_MANIFEST_REVALIDATE_INTERVAL = 1e3;
+/**
+* An SVG navigated to directly executes inline script, and a theme
+* directory is exactly where operator SVGs land. This neutralizes that
+* while leaving `<img>` and `background-image` rendering intact.
+*/ const THEME_ASSET_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; sandbox";
+//#endregion
+export { THEME_ASSET_CSP, THEME_MANIFEST_REVALIDATE_INTERVAL };
+
+//# sourceMappingURL=constants.mjs.map

package/dist/adapters/http/ui/theme/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":["THEME_MANIFEST_REVALIDATE_INTERVAL","THEME_ASSET_CSP"],"sources":["../../../../../src/adapters/http/ui/theme/constants.ts"],"sourcesContent":["/*\n * Copyright (c) 2026.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\n/**\n * SERVING constants. The theme's own vocabulary (layout, manifest, tokens,\n * asset kinds) lives in contract/, which stays portable.\n */\n\n/**\n * Debounce for the manifest mtime re-check. A burst of renders costs one\n * stat; an edit takes effect on the next render after the window.\n */\nexport const THEME_MANIFEST_REVALIDATE_INTERVAL = 1_000;\n\n/**\n * An SVG navigated to directly executes inline script, and a theme\n * directory is exactly where operator SVGs land. This neutralizes that\n * while leaving `<img>` and `background-image` rendering intact.\n */\nexport const THEME_ASSET_CSP = \"default-src 'none'; style-src 'unsafe-inline'; img-src data:; sandbox\";\n"],"mappings":";;;;;;;;;;GAgBA,MAAaA,qCAAqC;;;;;GAOlD,MAAaC,kBAAkB"}

package/dist/adapters/http/ui/theme/contract/constants.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The theme CONTRACT: the on-disk layout, the manifest vocabulary and the
+ * URL space a theme occupies. Everything here is portable — no node APIs,
+ * no HTTP — so a browser-side theme editor or a CLI validator can share it
+ * verbatim. Serving concerns (headers, caches, mounts) live one level up.
+ */
+export declare const THEME_MANIFEST_FILE_NAME = "theme.json";
+/**
+ * The ONLY sub-directory reachable over HTTP. The mount root is
+ * `<themeDirectoryPath>/assets`, never the theme root, so `theme.json`
+ * (and any future non-public file) is unreachable by construction rather
+ * than by an extension filter a later edit could loosen.
+ */
+export declare const THEME_ASSETS_DIRECTORY_NAME = "assets";
+export declare const THEME_FRAGMENTS_DIRECTORY_NAME = "fragments";
+/**
+ * Raw markup spliced into `<head>`. Read only when the operator opts in
+ * via `themeFragmentsEnabled`: a fragment is unsanitized markup on the
+ * IdP origin, so it must be a deliberate decision and never a consequence
+ * of dropping a file into the mounted directory.
+ *
+ * Head-only by design. There is deliberately no in-`<body>` slot: a
+ * fragment rendered next to the consent buttons is a strictly better
+ * consent-forgery primitive than one in `<head>` (it could relabel or
+ * overlay Allow with no CSS at all).
+ */
+export declare const THEME_HEAD_FRAGMENT_FILE_NAME = "head.html";
+export declare const THEME_HEAD_FRAGMENT_MAX_LENGTH: number;
+/** The path segment the theme's `assets/` directory is served under. */
+export declare const THEME_ASSET_MOUNT_PATH = "theme";
+/**
+ * A manifest declares the contract version it was written against. An
+ * unknown version fails the boot instead of being partially understood.
+ */
+export declare const THEME_MANIFEST_VERSION = 1;
+/**
+ * Token names are validated by GRAMMAR, not against a closed list of the
+ * `--authup-*` properties the theme packages happen to declare today.
+ *
+ * A closed list would have to live here, and this package cannot depend on
+ * `@authup/client-web-kit-theme`, so nothing could bind the two and it
+ * would rot in both directions: a newly added CSS token would fail
+ * validation for a legitimate override, and a removed one would stay
+ * accepted. The grammar cannot rot.
+ *
+ * It is NOT sufficient for an untrusted (per-realm) token source, and a
+ * later rung must not adopt it unchanged. Values are guarded by a denylist
+ * of CSS functions, and a denylist over a language that keeps gaining
+ * functions leaks by construction: `image-set()` and `src()` already had
+ * to be added after `url()`. Filesystem input is operator trust, equal to
+ * the process, so a denylist is proportionate here. Untrusted input needs
+ * an allowlist of accepted value SHAPES (a colour, a length, a keyword)
+ * per token, which is a different validator.
+ */
+export declare const THEME_TOKEN_NAME_PATTERN: RegExp;
+export declare const THEME_TOKEN_VALUE_MAX_LENGTH = 256;
+/**
+ * Keeps a token value from closing the declaration block, opening a tag,
+ * starting a new at-rule or comment, or turning the server-emitted token
+ * block into a request-emitting sink. Layer 2 (`theme.css`) may of course
+ * use `url()`; that asymmetry is deliberate and documented.
+ *
+ * `{` is forbidden alongside `}`: it opens a block inside the declaration,
+ * which swallows the rule that follows. One stray brace in a light token
+ * silently absorbs the whole `.dark` rule, so dark mode stops applying
+ * with no error anywhere.
+ *
+ * Vendor prefixes are covered (`-webkit-image-set(`), and so is whitespace
+ * before the paren; escapes cannot be used to smuggle a name past this
+ * because `\` is forbidden outright.
+ */
+export declare const THEME_TOKEN_VALUE_FORBIDDEN_PATTERN: RegExp;
+/**
+ * Every asset kind a theme may contain, and the content type it is pinned
+ * to when served. Notably excludes `.html` and `.js`, so a stray document
+ * or script in the mounted directory can never be served from the IdP
+ * origin.
+ */
+export declare const THEME_ASSET_CONTENT_TYPES: Record<string, string>;
+/**
+ * Derived, never hand-maintained: the allowlist and the content-type map
+ * must describe the same set, or a servable extension would be sent with
+ * an undefined content type.
+ */
+export declare const THEME_ASSET_EXTENSIONS: string[];
+/**
+ * The subset a `logo` may use. Derived from the content-type map so a new
+ * image type is servable and usable as a logo in one edit.
+ */
+export declare const THEME_IMAGE_EXTENSIONS: string[];
+/**
+ * Emitted by server-core from a manifest's `logo`, never authored as a raw
+ * token: the value carries a `url()`, which the token grammar forbids for
+ * operator-supplied values so the token block cannot become a
+ * request-emitting sink. The href is built from an already-validated asset
+ * path.
+ */
+export declare const THEME_LOGO_TOKENS: readonly [{
+    readonly image: "--authup-auth-logo-image";
+    readonly markVisibility: "--authup-auth-logo-mark-visibility";
+}, {
+    readonly image: "--authup-account-logo-image";
+    readonly markVisibility: "--authup-account-logo-mark-visibility";
+}];
+/**
+ * The CSS layer the token block is emitted into.
+ *
+ * A layer name not present in the bundle's `@layer` statement is appended
+ * LAST in the layer order, so it beats `@layer authup` (the kit tokens)
+ * and `@layer base` (the app theme's brand rebinds and its `.dark` flips)
+ * without needing `!important`. Inside the block `.dark` beats `:root` by
+ * source order, so dark mode keeps working.
+ *
+ * Deliberately NOT an inline `style` attribute on `<html>`: that would win
+ * permanently, and the color-mode switcher flips the `.dark` class
+ * client-side with no reload, which would freeze the brand at whatever the
+ * cookie said at render time.
+ */
+export declare const THEME_CSS_LAYER_NAME = "authup-theme";
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapters/http/ui/theme/contract/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/adapters/http/ui/theme/contract/constants.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH,eAAO,MAAM,wBAAwB,eAAe,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,WAAW,CAAC;AAEpD,eAAO,MAAM,8BAA8B,cAAc,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,cAAc,CAAC;AAEzD,eAAO,MAAM,8BAA8B,QAAY,CAAC;AAExD,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,wBAAwB,QAAwB,CAAC;AAE9D,eAAO,MAAM,4BAA4B,MAAM,CAAC;AA8BhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mCAAmC,QAG/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAY7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,UAAyC,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,UACkD,CAAC;AAEtF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;EAGpB,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,iBAAiB,CAAC"}

package/dist/adapters/http/ui/theme/contract/constants.mjs

@@ -0,0 +1,136 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/adapters/http/ui/theme/contract/constants.ts
+/**
+* The theme CONTRACT: the on-disk layout, the manifest vocabulary and the
+* URL space a theme occupies. Everything here is portable — no node APIs,
+* no HTTP — so a browser-side theme editor or a CLI validator can share it
+* verbatim. Serving concerns (headers, caches, mounts) live one level up.
+*/ const THEME_MANIFEST_FILE_NAME = "theme.json";
+/**
+* The ONLY sub-directory reachable over HTTP. The mount root is
+* `<themeDirectoryPath>/assets`, never the theme root, so `theme.json`
+* (and any future non-public file) is unreachable by construction rather
+* than by an extension filter a later edit could loosen.
+*/ const THEME_ASSETS_DIRECTORY_NAME = "assets";
+const THEME_FRAGMENTS_DIRECTORY_NAME = "fragments";
+/**
+* Raw markup spliced into `<head>`. Read only when the operator opts in
+* via `themeFragmentsEnabled`: a fragment is unsanitized markup on the
+* IdP origin, so it must be a deliberate decision and never a consequence
+* of dropping a file into the mounted directory.
+*
+* Head-only by design. There is deliberately no in-`<body>` slot: a
+* fragment rendered next to the consent buttons is a strictly better
+* consent-forgery primitive than one in `<head>` (it could relabel or
+* overlay Allow with no CSS at all).
+*/ const THEME_HEAD_FRAGMENT_FILE_NAME = "head.html";
+const THEME_HEAD_FRAGMENT_MAX_LENGTH = 65536;
+/** The path segment the theme's `assets/` directory is served under. */ const THEME_ASSET_MOUNT_PATH = "theme";
+/**
+* A manifest declares the contract version it was written against. An
+* unknown version fails the boot instead of being partially understood.
+*/ const THEME_MANIFEST_VERSION = 1;
+/**
+* Token names are validated by GRAMMAR, not against a closed list of the
+* `--authup-*` properties the theme packages happen to declare today.
+*
+* A closed list would have to live here, and this package cannot depend on
+* `@authup/client-web-kit-theme`, so nothing could bind the two and it
+* would rot in both directions: a newly added CSS token would fail
+* validation for a legitimate override, and a removed one would stay
+* accepted. The grammar cannot rot.
+*
+* It is NOT sufficient for an untrusted (per-realm) token source, and a
+* later rung must not adopt it unchanged. Values are guarded by a denylist
+* of CSS functions, and a denylist over a language that keeps gaining
+* functions leaks by construction: `image-set()` and `src()` already had
+* to be added after `url()`. Filesystem input is operator trust, equal to
+* the process, so a denylist is proportionate here. Untrusted input needs
+* an allowlist of accepted value SHAPES (a colour, a length, a keyword)
+* per token, which is a different validator.
+*/ const THEME_TOKEN_NAME_PATTERN = /^--[a-z][a-z0-9-]*$/;
+const THEME_TOKEN_VALUE_MAX_LENGTH = 256;
+/**
+* Keeps a token value from closing the declaration block, opening a tag,
+* starting a new at-rule or comment, or turning the server-emitted token
+* block into a request-emitting sink. Layer 2 (`theme.css`) may of course
+* use `url()`; that asymmetry is deliberate and documented.
+*
+* `{` is forbidden alongside `}`: it opens a block inside the declaration,
+* which swallows the rule that follows. One stray brace in a light token
+* silently absorbs the whole `.dark` rule, so dark mode stops applying
+* with no error anywhere.
+*
+* Vendor prefixes are covered (`-webkit-image-set(`), and so is whitespace
+* before the paren; escapes cannot be used to smuggle a name past this
+* because `\` is forbidden outright.
+*/ const THEME_TOKEN_VALUE_FORBIDDEN_PATTERN = new RegExp(`[{}<>;@\\\\]|\\/\\*|(?:^|[^a-z0-9-])(?:-[a-z]+-)?(?:${[
+	"url",
+	"expression",
+	"image",
+	"image-set",
+	"src",
+	"cross-fade",
+	"element",
+	"paint"
+].join("|")})\\s*\\(`, "i");
+/**
+* Every asset kind a theme may contain, and the content type it is pinned
+* to when served. Notably excludes `.html` and `.js`, so a stray document
+* or script in the mounted directory can never be served from the IdP
+* origin.
+*/ const THEME_ASSET_CONTENT_TYPES = {
+	".css": "text/css; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2"
+};
+/**
+* Derived, never hand-maintained: the allowlist and the content-type map
+* must describe the same set, or a servable extension would be sent with
+* an undefined content type.
+*/ const THEME_ASSET_EXTENSIONS = Object.keys(THEME_ASSET_CONTENT_TYPES);
+/**
+* The subset a `logo` may use. Derived from the content-type map so a new
+* image type is servable and usable as a logo in one edit.
+*/ const THEME_IMAGE_EXTENSIONS = THEME_ASSET_EXTENSIONS.filter((extension) => THEME_ASSET_CONTENT_TYPES[extension].startsWith("image/"));
+/**
+* Emitted by server-core from a manifest's `logo`, never authored as a raw
+* token: the value carries a `url()`, which the token grammar forbids for
+* operator-supplied values so the token block cannot become a
+* request-emitting sink. The href is built from an already-validated asset
+* path.
+*/ const THEME_LOGO_TOKENS = [{
+	image: "--authup-auth-logo-image",
+	markVisibility: "--authup-auth-logo-mark-visibility"
+}, {
+	image: "--authup-account-logo-image",
+	markVisibility: "--authup-account-logo-mark-visibility"
+}];
+/**
+* The CSS layer the token block is emitted into.
+*
+* A layer name not present in the bundle's `@layer` statement is appended
+* LAST in the layer order, so it beats `@layer authup` (the kit tokens)
+* and `@layer base` (the app theme's brand rebinds and its `.dark` flips)
+* without needing `!important`. Inside the block `.dark` beats `:root` by
+* source order, so dark mode keeps working.
+*
+* Deliberately NOT an inline `style` attribute on `<html>`: that would win
+* permanently, and the color-mode switcher flips the `.dark` class
+* client-side with no reload, which would freeze the brand at whatever the
+* cookie said at render time.
+*/ const THEME_CSS_LAYER_NAME = "authup-theme";
+//#endregion
+export { THEME_ASSETS_DIRECTORY_NAME, THEME_ASSET_CONTENT_TYPES, THEME_ASSET_EXTENSIONS, THEME_ASSET_MOUNT_PATH, THEME_CSS_LAYER_NAME, THEME_FRAGMENTS_DIRECTORY_NAME, THEME_HEAD_FRAGMENT_FILE_NAME, THEME_HEAD_FRAGMENT_MAX_LENGTH, THEME_IMAGE_EXTENSIONS, THEME_LOGO_TOKENS, THEME_MANIFEST_FILE_NAME, THEME_MANIFEST_VERSION, THEME_TOKEN_NAME_PATTERN, THEME_TOKEN_VALUE_FORBIDDEN_PATTERN, THEME_TOKEN_VALUE_MAX_LENGTH };
+
+//# sourceMappingURL=constants.mjs.map

package/dist/adapters/http/ui/theme/contract/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":["THEME_MANIFEST_FILE_NAME","THEME_ASSETS_DIRECTORY_NAME","THEME_FRAGMENTS_DIRECTORY_NAME","THEME_HEAD_FRAGMENT_FILE_NAME","THEME_HEAD_FRAGMENT_MAX_LENGTH","THEME_ASSET_MOUNT_PATH","THEME_MANIFEST_VERSION","THEME_TOKEN_NAME_PATTERN","THEME_TOKEN_VALUE_MAX_LENGTH","THEME_TOKEN_VALUE_FORBIDDEN_FUNCTIONS","THEME_TOKEN_VALUE_FORBIDDEN_PATTERN","RegExp","join","THEME_ASSET_CONTENT_TYPES","THEME_ASSET_EXTENSIONS","Object","keys","THEME_IMAGE_EXTENSIONS","filter","extension","startsWith","THEME_LOGO_TOKENS","image","markVisibility","THEME_CSS_LAYER_NAME"],"sources":["../../../../../../src/adapters/http/ui/theme/contract/constants.ts"],"sourcesContent":["/*\n * Copyright (c) 2026.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\n/**\n * The theme CONTRACT: the on-disk layout, the manifest vocabulary and the\n * URL space a theme occupies. Everything here is portable — no node APIs,\n * no HTTP — so a browser-side theme editor or a CLI validator can share it\n * verbatim. Serving concerns (headers, caches, mounts) live one level up.\n */\n\nexport const THEME_MANIFEST_FILE_NAME = 'theme.json';\n\n/**\n * The ONLY sub-directory reachable over HTTP. The mount root is\n * `<themeDirectoryPath>/assets`, never the theme root, so `theme.json`\n * (and any future non-public file) is unreachable by construction rather\n * than by an extension filter a later edit could loosen.\n */\nexport const THEME_ASSETS_DIRECTORY_NAME = 'assets';\n\nexport const THEME_FRAGMENTS_DIRECTORY_NAME = 'fragments';\n\n/**\n * Raw markup spliced into `<head>`. Read only when the operator opts in\n * via `themeFragmentsEnabled`: a fragment is unsanitized markup on the\n * IdP origin, so it must be a deliberate decision and never a consequence\n * of dropping a file into the mounted directory.\n *\n * Head-only by design. There is deliberately no in-`<body>` slot: a\n * fragment rendered next to the consent buttons is a strictly better\n * consent-forgery primitive than one in `<head>` (it could relabel or\n * overlay Allow with no CSS at all).\n */\nexport const THEME_HEAD_FRAGMENT_FILE_NAME = 'head.html';\n\nexport const THEME_HEAD_FRAGMENT_MAX_LENGTH = 64 * 1024;\n\n/** The path segment the theme's `assets/` directory is served under. */\nexport const THEME_ASSET_MOUNT_PATH = 'theme';\n\n/**\n * A manifest declares the contract version it was written against. An\n * unknown version fails the boot instead of being partially understood.\n */\nexport const THEME_MANIFEST_VERSION = 1;\n\n/**\n * Token names are validated by GRAMMAR, not against a closed list of the\n * `--authup-*` properties the theme packages happen to declare today.\n *\n * A closed list would have to live here, and this package cannot depend on\n * `@authup/client-web-kit-theme`, so nothing could bind the two and it\n * would rot in both directions: a newly added CSS token would fail\n * validation for a legitimate override, and a removed one would stay\n * accepted. The grammar cannot rot.\n *\n * It is NOT sufficient for an untrusted (per-realm) token source, and a\n * later rung must not adopt it unchanged. Values are guarded by a denylist\n * of CSS functions, and a denylist over a language that keeps gaining\n * functions leaks by construction: `image-set()` and `src()` already had\n * to be added after `url()`. Filesystem input is operator trust, equal to\n * the process, so a denylist is proportionate here. Untrusted input needs\n * an allowlist of accepted value SHAPES (a colour, a length, a keyword)\n * per token, which is a different validator.\n */\nexport const THEME_TOKEN_NAME_PATTERN = /^--[a-z][a-z0-9-]*$/;\n\nexport const THEME_TOKEN_VALUE_MAX_LENGTH = 256;\n\n/**\n * Every CSS function that can load a remote resource.\n *\n * Blocking `url(` alone does not close the request-emitting-sink hole:\n * `image-set()`, `image()`, `src()` and `cross-fade()` all take a bare\n * string URL, and a token like `--authup-auth-logo-image` is substituted\n * straight into an image-accepting property. `element()` and `paint()`\n * cannot fetch, but they render document content into a paint sink and\n * have no business in an operator token either.\n *\n * A denylist over function names is still a denylist, so this list is the\n * floor rather than the argument: the values it guards are operator\n * authored, and an operator can already ship arbitrary CSS through\n * `theme.css`. It exists so a value cannot QUIETLY do something the\n * grammar advertises as impossible. A per-realm (untrusted) token source\n * must not reuse it as-is; see the note on the name pattern below.\n */\nconst THEME_TOKEN_VALUE_FORBIDDEN_FUNCTIONS = [\n    'url',\n    'expression',\n    'image',\n    'image-set',\n    'src',\n    'cross-fade',\n    'element',\n    'paint',\n];\n\n/**\n * Keeps a token value from closing the declaration block, opening a tag,\n * starting a new at-rule or comment, or turning the server-emitted token\n * block into a request-emitting sink. Layer 2 (`theme.css`) may of course\n * use `url()`; that asymmetry is deliberate and documented.\n *\n * `{` is forbidden alongside `}`: it opens a block inside the declaration,\n * which swallows the rule that follows. One stray brace in a light token\n * silently absorbs the whole `.dark` rule, so dark mode stops applying\n * with no error anywhere.\n *\n * Vendor prefixes are covered (`-webkit-image-set(`), and so is whitespace\n * before the paren; escapes cannot be used to smuggle a name past this\n * because `\\` is forbidden outright.\n */\nexport const THEME_TOKEN_VALUE_FORBIDDEN_PATTERN = new RegExp(\n    `[{}<>;@\\\\\\\\]|\\\\/\\\\*|(?:^|[^a-z0-9-])(?:-[a-z]+-)?(?:${THEME_TOKEN_VALUE_FORBIDDEN_FUNCTIONS.join('|')})\\\\s*\\\\(`,\n    'i',\n);\n\n/**\n * Every asset kind a theme may contain, and the content type it is pinned\n * to when served. Notably excludes `.html` and `.js`, so a stray document\n * or script in the mounted directory can never be served from the IdP\n * origin.\n */\nexport const THEME_ASSET_CONTENT_TYPES : Record<string, string> = {\n    '.css': 'text/css; charset=utf-8',\n    '.svg': 'image/svg+xml',\n    '.png': 'image/png',\n    '.jpg': 'image/jpeg',\n    '.jpeg': 'image/jpeg',\n    '.gif': 'image/gif',\n    '.webp': 'image/webp',\n    '.avif': 'image/avif',\n    '.ico': 'image/x-icon',\n    '.woff': 'font/woff',\n    '.woff2': 'font/woff2',\n};\n\n/**\n * Derived, never hand-maintained: the allowlist and the content-type map\n * must describe the same set, or a servable extension would be sent with\n * an undefined content type.\n */\nexport const THEME_ASSET_EXTENSIONS = Object.keys(THEME_ASSET_CONTENT_TYPES);\n\n/**\n * The subset a `logo` may use. Derived from the content-type map so a new\n * image type is servable and usable as a logo in one edit.\n */\nexport const THEME_IMAGE_EXTENSIONS = THEME_ASSET_EXTENSIONS\n    .filter((extension) => THEME_ASSET_CONTENT_TYPES[extension].startsWith('image/'));\n\n/**\n * Emitted by server-core from a manifest's `logo`, never authored as a raw\n * token: the value carries a `url()`, which the token grammar forbids for\n * operator-supplied values so the token block cannot become a\n * request-emitting sink. The href is built from an already-validated asset\n * path.\n */\nexport const THEME_LOGO_TOKENS = [\n    { image: '--authup-auth-logo-image', markVisibility: '--authup-auth-logo-mark-visibility' },\n    { image: '--authup-account-logo-image', markVisibility: '--authup-account-logo-mark-visibility' },\n] as const;\n\n/**\n * The CSS layer the token block is emitted into.\n *\n * A layer name not present in the bundle's `@layer` statement is appended\n * LAST in the layer order, so it beats `@layer authup` (the kit tokens)\n * and `@layer base` (the app theme's brand rebinds and its `.dark` flips)\n * without needing `!important`. Inside the block `.dark` beats `:root` by\n * source order, so dark mode keeps working.\n *\n * Deliberately NOT an inline `style` attribute on `<html>`: that would win\n * permanently, and the color-mode switcher flips the `.dark` class\n * client-side with no reload, which would freeze the brand at whatever the\n * cookie said at render time.\n */\nexport const THEME_CSS_LAYER_NAME = 'authup-theme';\n"],"mappings":";;;;;;;;;GAcA,MAAaA,2BAA2B;;;;;;GAQxC,MAAaC,8BAA8B;AAE3C,MAAaC,iCAAiC;;;;;;;;;;;GAa9C,MAAaC,gCAAgC;AAE7C,MAAaC,iCAAiC;yEAG9C,MAAaC,yBAAyB;;;;GAMtC,MAAaC,yBAAyB;;;;;;;;;;;;;;;;;;;GAqBtC,MAAaC,2BAA2B;AAExC,MAAaC,+BAA+B;;;;;;;;;;;;;;;GA6C5C,MAAaE,sCAAsC,IAAIC,OACnD,uDAAuDF;CA1BvD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAmBuDA,CAAAA,CAAsCG,KAAK,GAAA,EAAK,WACvG,GAAA;;;;;;GASJ,MAAaC,4BAAqD;CAC9D,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,SAAS;CACT,UAAU;AACd;;;;;GAOA,MAAaC,yBAAyBC,OAAOC,KAAKH,yBAAAA;;;;GAMlD,MAAaI,yBAAyBH,uBACjCI,QAAQC,cAAcN,0BAA0BM,UAAU,CAACC,WAAW,QAAA,CAAA;;;;;;;GAS3E,MAAaC,oBAAoB,CAC7B;CAAEC,OAAO;CAA4BC,gBAAgB;AAAqC,GAC1F;CAAED,OAAO;CAA+BC,gBAAgB;AAAwC,CACnG;;;;;;;;;;;;;;GAgBD,MAAaC,uBAAuB"}

package/dist/adapters/http/ui/theme/contract/head.d.ts

@@ -0,0 +1,12 @@
+import type { ThemeManifest } from './types.ts';
+export declare function escapeHtml(value: string): string;
+/**
+ * The `<style>`/`<link>` block injected before `</head>`.
+ *
+ * Every value here has already passed the manifest grammar (no `<`, `>`,
+ * `}`, `;` or `@` in a token value; asset paths are alphanumeric plus
+ * `._/-`), so the emitted CSS cannot be broken out of. The title is the
+ * one free-form field and is HTML-escaped.
+ */
+export declare function buildThemeHead(manifest: ThemeManifest, basePath: string, fragment?: string): string;
+//# sourceMappingURL=head.d.ts.map

package/dist/adapters/http/ui/theme/contract/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../../../../../../src/adapters/http/ui/theme/contract/head.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAI,MAAM,CAMjD;AA2CD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC1B,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GACjB,MAAM,CAuDT"}

package/dist/adapters/http/ui/theme/contract/head.mjs

@@ -0,0 +1,61 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { THEME_ASSETS_DIRECTORY_NAME, THEME_ASSET_MOUNT_PATH, THEME_CSS_LAYER_NAME, THEME_LOGO_TOKENS } from "./constants.mjs";
+//#region src/adapters/http/ui/theme/contract/head.ts
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/**
+* Turn a manifest asset path (`assets/logo.svg`) into the href it is
+* served under.
+*
+* Built with the base path up front rather than via rebaseAssetURLs, which
+* only rewrites the fixed `/public/` and `/account/` vite bases.
+*/ function buildAssetURL(assetPath, basePath) {
+	const name = assetPath.slice(`${THEME_ASSETS_DIRECTORY_NAME}/`.length);
+	return `${basePath}/${THEME_ASSET_MOUNT_PATH}/${name}`;
+}
+/**
+* The token pair that swaps the built-in mark for an operator image, for
+* one color mode. Empty when that mode declares no logo, so the other
+* mode's rule (or the built-in mark) stands.
+*/ function buildLogoTokens(logo, basePath) {
+	const tokens = {};
+	if (!logo) return tokens;
+	const url = buildAssetURL(logo, basePath);
+	for (const pair of THEME_LOGO_TOKENS) {
+		tokens[pair.image] = `url("${url}")`;
+		tokens[pair.markVisibility] = "hidden";
+	}
+	return tokens;
+}
+function buildTokenRule(selector, tokens) {
+	return `${selector}{${Object.keys(tokens).map((name) => `${name}:${tokens[name]}`).join(";")}}`;
+}
+/**
+* The `<style>`/`<link>` block injected before `</head>`.
+*
+* Every value here has already passed the manifest grammar (no `<`, `>`,
+* `}`, `;` or `@` in a token value; asset paths are alphanumeric plus
+* `._/-`), so the emitted CSS cannot be broken out of. The title is the
+* one free-form field and is HTML-escaped.
+*/ function buildThemeHead(manifest, basePath, fragment) {
+	const parts = [];
+	const rules = [];
+	const tokens = buildLogoTokens(manifest.logo, basePath);
+	Object.assign(tokens, manifest.tokens);
+	const tokensDark = buildLogoTokens(manifest.logoDark, basePath);
+	Object.assign(tokensDark, manifest.tokensDark);
+	if (Object.keys(tokens).length > 0) rules.push(buildTokenRule(":root", tokens));
+	if (Object.keys(tokensDark).length > 0) rules.push(buildTokenRule(".dark", tokensDark));
+	if (rules.length > 0) parts.push(`<style>@layer ${THEME_CSS_LAYER_NAME}{${rules.join("")}}</style>`);
+	if (manifest.favicon) parts.push(`<link rel="icon" href="${escapeHtml(buildAssetURL(manifest.favicon, basePath))}">`);
+	if (manifest.stylesheet) parts.push(`<link rel="stylesheet" href="${escapeHtml(buildAssetURL(manifest.stylesheet, basePath))}">`);
+	if (fragment) parts.push(fragment);
+	return parts.join("");
+}
+//#endregion
+export { buildThemeHead, escapeHtml };
+
+//# sourceMappingURL=head.mjs.map

package/dist/adapters/http/ui/theme/contract/head.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.mjs","names":["THEME_ASSETS_DIRECTORY_NAME","THEME_ASSET_MOUNT_PATH","THEME_CSS_LAYER_NAME","THEME_LOGO_TOKENS","escapeHtml","value","replace","buildAssetURL","assetPath","basePath","name","slice","length","buildLogoTokens","logo","tokens","url","pair","image","markVisibility","buildTokenRule","selector","declarations","Object","keys","map","join","buildThemeHead","manifest","fragment","parts","rules","assign","tokensDark","logoDark","push","favicon","stylesheet"],"sources":["../../../../../../src/adapters/http/ui/theme/contract/head.ts"],"sourcesContent":["/*\n * Copyright (c) 2026.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport {\n    THEME_ASSETS_DIRECTORY_NAME,\n    THEME_ASSET_MOUNT_PATH,\n    THEME_CSS_LAYER_NAME,\n    THEME_LOGO_TOKENS,\n} from './constants.ts';\nimport type { ThemeManifest } from './types.ts';\n\nexport function escapeHtml(value: string) : string {\n    return value\n        .replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;')\n        .replace(/\"/g, '&quot;');\n}\n\n/**\n * Turn a manifest asset path (`assets/logo.svg`) into the href it is\n * served under.\n *\n * Built with the base path up front rather than via rebaseAssetURLs, which\n * only rewrites the fixed `/public/` and `/account/` vite bases.\n */\nfunction buildAssetURL(assetPath: string, basePath: string) : string {\n    const name = assetPath.slice(`${THEME_ASSETS_DIRECTORY_NAME}/`.length);\n\n    return `${basePath}/${THEME_ASSET_MOUNT_PATH}/${name}`;\n}\n\n/**\n * The token pair that swaps the built-in mark for an operator image, for\n * one color mode. Empty when that mode declares no logo, so the other\n * mode's rule (or the built-in mark) stands.\n */\nfunction buildLogoTokens(logo: string | undefined, basePath: string) : Record<string, string> {\n    const tokens : Record<string, string> = {};\n    if (!logo) {\n        return tokens;\n    }\n\n    const url = buildAssetURL(logo, basePath);\n    for (const pair of THEME_LOGO_TOKENS) {\n        tokens[pair.image] = `url(\"${url}\")`;\n        tokens[pair.markVisibility] = 'hidden';\n    }\n\n    return tokens;\n}\n\nfunction buildTokenRule(selector: string, tokens: Record<string, string>) : string {\n    const declarations = Object.keys(tokens)\n        .map((name) => `${name}:${tokens[name]}`)\n        .join(';');\n\n    return `${selector}{${declarations}}`;\n}\n\n/**\n * The `<style>`/`<link>` block injected before `</head>`.\n *\n * Every value here has already passed the manifest grammar (no `<`, `>`,\n * `}`, `;` or `@` in a token value; asset paths are alphanumeric plus\n * `._/-`), so the emitted CSS cannot be broken out of. The title is the\n * one free-form field and is HTML-escaped.\n */\nexport function buildThemeHead(\n    manifest: ThemeManifest,\n    basePath: string,\n    fragment?: string,\n) : string {\n    const parts : string[] = [];\n\n    const rules : string[] = [];\n\n    // The logo is a manifest field rather than a raw token because its\n    // value needs url(), which the token grammar forbids. Merged before\n    // the authored tokens so an explicit token of the same name still wins.\n    //\n    // `logo` and `logoDark` are emitted into their own rule, so a brand\n    // whose mark is dark-on-light can ship a light-on-dark variant instead\n    // of disappearing against the dark card. Each mode carries the\n    // mark-visibility flag alongside its image, which makes all three\n    // combinations coherent:\n    //   logo only      -> one image, inherited by dark mode\n    //   both           -> a per-mode image\n    //   logoDark only  -> the built-in mark in light, the operator's in dark\n    const tokens = buildLogoTokens(manifest.logo, basePath);\n    Object.assign(tokens, manifest.tokens);\n\n    const tokensDark = buildLogoTokens(manifest.logoDark, basePath);\n    Object.assign(tokensDark, manifest.tokensDark);\n\n    if (Object.keys(tokens).length > 0) {\n        rules.push(buildTokenRule(':root', tokens));\n    }\n    // After :root, so it wins inside the layer by source order and the\n    // color-mode switcher keeps working.\n    if (Object.keys(tokensDark).length > 0) {\n        rules.push(buildTokenRule('.dark', tokensDark));\n    }\n\n    if (rules.length > 0) {\n        parts.push(`<style>@layer ${THEME_CSS_LAYER_NAME}{${rules.join('')}}</style>`);\n    }\n\n    if (manifest.favicon) {\n        parts.push(`<link rel=\"icon\" href=\"${escapeHtml(buildAssetURL(manifest.favicon, basePath))}\">`);\n    }\n\n    // Last, so the operator stylesheet wins over the token block above it.\n    if (manifest.stylesheet) {\n        parts.push(`<link rel=\"stylesheet\" href=\"${escapeHtml(buildAssetURL(manifest.stylesheet, basePath))}\">`);\n    }\n\n    // After the stylesheet, so a fragment can override everything the\n    // manifest emitted. Passed through verbatim: it is operator-authored\n    // markup, and a partial sanitizer would be worse than none because it\n    // invites treating fragments as untrusted-safe. The controls are that\n    // it is filesystem-only, off by default, and head-only.\n    if (fragment) {\n        parts.push(fragment);\n    }\n\n    return parts.join('');\n}\n"],"mappings":";;;;;AAeA,SAAgBI,WAAWC,OAAa;CACpC,OAAOA,MACFC,QAAQ,MAAM,OAAA,CAAA,CACdA,QAAQ,MAAM,MAAA,CAAA,CACdA,QAAQ,MAAM,MAAA,CAAA,CACdA,QAAQ,MAAM,QAAA;AACvB;;;;;;;GASA,SAASC,cAAcC,WAAmBC,UAAgB;CACtD,MAAMC,OAAOF,UAAUG,MAAM,GAAGX,4BAA4B,GAAGY,MAAM;CAErE,OAAO,GAAGH,SAAS,GAAGR,uBAAuB,GAAGS;AACpD;;;;;GAOA,SAASG,gBAAgBC,MAA0BL,UAAgB;CAC/D,MAAMM,SAAkC,CAAC;CACzC,IAAI,CAACD,MACD,OAAOC;CAGX,MAAMC,MAAMT,cAAcO,MAAML,QAAAA;CAChC,KAAK,MAAMQ,QAAQd,mBAAmB;EAClCY,OAAOE,KAAKC,SAAS,QAAQF,IAAI;EACjCD,OAAOE,KAAKE,kBAAkB;CAClC;CAEA,OAAOJ;AACX;AAEA,SAASK,eAAeC,UAAkBN,QAA8B;CAKpE,OAAO,GAAGM,SAAS,GAJEE,OAAOC,KAAKT,MAAAA,CAAAA,CAC5BU,KAAKf,SAAS,GAAGA,KAAK,GAAGK,OAAOL,OAAO,CAAA,CACvCgB,KAAK,GAEYJ,EAAa;AACvC;;;;;;;;GAUA,SAAgBK,eACZC,UACAnB,UACAoB,UAAiB;CAEjB,MAAMC,QAAmB,CAAA;CAEzB,MAAMC,QAAmB,CAAA;CAczB,MAAMhB,SAASF,gBAAgBe,SAASd,MAAML,QAAAA;CAC9Cc,OAAOS,OAAOjB,QAAQa,SAASb,MAAM;CAErC,MAAMkB,aAAapB,gBAAgBe,SAASM,UAAUzB,QAAAA;CACtDc,OAAOS,OAAOC,YAAYL,SAASK,UAAU;CAE7C,IAAIV,OAAOC,KAAKT,MAAAA,CAAAA,CAAQH,SAAS,GAC7BmB,MAAMI,KAAKf,eAAe,SAASL,MAAAA,CAAAA;CAIvC,IAAIQ,OAAOC,KAAKS,UAAAA,CAAAA,CAAYrB,SAAS,GACjCmB,MAAMI,KAAKf,eAAe,SAASa,UAAAA,CAAAA;CAGvC,IAAIF,MAAMnB,SAAS,GACfkB,MAAMK,KAAK,iBAAiBjC,qBAAqB,GAAG6B,MAAML,KAAK,EAAA,EAAI,UAAU;CAGjF,IAAIE,SAASQ,SACTN,MAAMK,KAAK,0BAA0B/B,WAAWG,cAAcqB,SAASQ,SAAS3B,QAAAA,CAAAA,EAAW,GAAG;CAIlG,IAAImB,SAASS,YACTP,MAAMK,KAAK,gCAAgC/B,WAAWG,cAAcqB,SAASS,YAAY5B,QAAAA,CAAAA,EAAW,GAAG;CAQ3G,IAAIoB,UACAC,MAAMK,KAAKN,QAAAA;CAGf,OAAOC,MAAMJ,KAAK,EAAA;AACtB"}

package/dist/adapters/http/ui/theme/contract/index.d.ts

@@ -0,0 +1,6 @@
+export * from './constants.ts';
+export * from './head.ts';
+export * from './manifest.ts';
+export * from './types.ts';
+export * from './utils.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/http/ui/theme/contract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/adapters/http/ui/theme/contract/index.ts"],"names":[],"mappings":"AAOA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/adapters/http/ui/theme/contract/index.mjs

@@ -0,0 +1,8 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { THEME_ASSETS_DIRECTORY_NAME, THEME_ASSET_CONTENT_TYPES, THEME_ASSET_EXTENSIONS, THEME_ASSET_MOUNT_PATH, THEME_CSS_LAYER_NAME, THEME_FRAGMENTS_DIRECTORY_NAME, THEME_HEAD_FRAGMENT_FILE_NAME, THEME_HEAD_FRAGMENT_MAX_LENGTH, THEME_IMAGE_EXTENSIONS, THEME_LOGO_TOKENS, THEME_MANIFEST_FILE_NAME, THEME_MANIFEST_VERSION, THEME_TOKEN_NAME_PATTERN, THEME_TOKEN_VALUE_FORBIDDEN_PATTERN, THEME_TOKEN_VALUE_MAX_LENGTH } from "./constants.mjs";
+import { buildThemeHead, escapeHtml } from "./head.mjs";
+import { themeAssetExtension } from "./utils.mjs";
+import { ThemeManifestValidator, parseThemeManifest } from "./manifest.mjs";
+export { THEME_ASSETS_DIRECTORY_NAME, THEME_ASSET_CONTENT_TYPES, THEME_ASSET_EXTENSIONS, THEME_ASSET_MOUNT_PATH, THEME_CSS_LAYER_NAME, THEME_FRAGMENTS_DIRECTORY_NAME, THEME_HEAD_FRAGMENT_FILE_NAME, THEME_HEAD_FRAGMENT_MAX_LENGTH, THEME_IMAGE_EXTENSIONS, THEME_LOGO_TOKENS, THEME_MANIFEST_FILE_NAME, THEME_MANIFEST_VERSION, THEME_TOKEN_NAME_PATTERN, THEME_TOKEN_VALUE_FORBIDDEN_PATTERN, THEME_TOKEN_VALUE_MAX_LENGTH, ThemeManifestValidator, buildThemeHead, escapeHtml, parseThemeManifest, themeAssetExtension };