@ossido-labs/ossido 0.1.0

package/dist/esm/build/logger.js

@@ -0,0 +1,76 @@
+//#region src/build/logger.ts
+/**
+* `[FE]`-tagged logging for the frontend build/dev tooling (vite, the SSR
+* bundler), matching the Rust `[FE]` format so all Ossido logs read the same:
+* `[FE] LEVEL HH:MM:SS - message`. The `[FE]` tag is cyan; the level is coloured
+* by severity.
+*/
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[1m";
+const DIM = "\x1B[2m";
+const CYAN = "\x1B[36m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const GREEN = "\x1B[32m";
+/**
+* Colours are disabled when `NO_COLOR` is set to a non-empty value (matching the
+* Rust side / the `NO_COLOR` convention), so `NO_COLOR=1 ossido dev` is plain.
+*/
+const COLOR_ENABLED = typeof process === "undefined" || !process.env.NO_COLOR;
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false });
+}
+/** Wrap `text` in ANSI `code`…`RESET`, unless colours are disabled. */
+function paint(code, text) {
+	return COLOR_ENABLED ? `${code}${text}${RESET}` : text;
+}
+function levelColor(level) {
+	if (level === "ERROR") return RED;
+	if (level === "WARN") return YELLOW;
+	return GREEN;
+}
+function formatLine(level, message) {
+	return `${paint(`${BOLD}${CYAN}`, "[FE]")} ${paint(levelColor(level), level)} ${paint(DIM, timestamp())} - ${message}`;
+}
+/** Print a single `[FE]`-tagged log line. */
+function feLog(level, message) {
+	console.log(formatLine(level, message));
+}
+const LEVEL_RANK = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+/**
+* A vite {@link Logger} that routes vite's own output through the `[FE]` format,
+* honouring `logLevel` (vite does not pre-filter for a custom logger, so the
+* logger must do it — otherwise info/warn noise leaks even at `'error'`).
+*/
+function createOssidoViteLogger(logLevel = "info") {
+	const threshold = LEVEL_RANK[logLevel] ?? LEVEL_RANK.info;
+	const logger = {
+		hasWarned: false,
+		info: (message) => {
+			if (threshold >= LEVEL_RANK.info) feLog("INFO", message);
+		},
+		warn: (message) => {
+			logger.hasWarned = true;
+			if (threshold >= LEVEL_RANK.warn) feLog("WARN", message);
+		},
+		warnOnce: (message) => {
+			if (threshold >= LEVEL_RANK.warn) feLog("WARN", message);
+		},
+		error: (message) => {
+			logger.hasWarned = true;
+			if (threshold >= LEVEL_RANK.error) feLog("ERROR", message);
+		},
+		clearScreen: () => void 0,
+		hasErrorLogged: () => false
+	};
+	return logger;
+}
+
+//#endregion
+export { createOssidoViteLogger, feLog };
+//# sourceMappingURL=logger.js.map

package/dist/esm/build/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":[],"sources":["../../../src/build/logger.ts"],"sourcesContent":["import { type Logger, type LogLevel } from 'vite';\n\n/**\n * `[FE]`-tagged logging for the frontend build/dev tooling (vite, the SSR\n * bundler), matching the Rust `[FE]` format so all Ossido logs read the same:\n * `[FE] LEVEL HH:MM:SS - message`. The `[FE]` tag is cyan; the level is coloured\n * by severity.\n */\n\nconst RESET = '\\x1b[0m';\nconst BOLD = '\\x1b[1m';\nconst DIM = '\\x1b[2m';\nconst CYAN = '\\x1b[36m';\nconst RED = '\\x1b[31m';\nconst YELLOW = '\\x1b[33m';\nconst GREEN = '\\x1b[32m';\n\n/**\n * Colours are disabled when `NO_COLOR` is set to a non-empty value (matching the\n * Rust side / the `NO_COLOR` convention), so `NO_COLOR=1 ossido dev` is plain.\n */\nconst COLOR_ENABLED = typeof process === 'undefined' || !process.env.NO_COLOR;\n\ntype FeLevel = 'INFO' | 'WARN' | 'ERROR';\n\nfunction timestamp(): string {\n  return new Date().toLocaleTimeString('en-GB', { hour12: false });\n}\n\n/** Wrap `text` in ANSI `code`…`RESET`, unless colours are disabled. */\nfunction paint(code: string, text: string): string {\n  return COLOR_ENABLED ? `${code}${text}${RESET}` : text;\n}\n\nfunction levelColor(level: FeLevel): string {\n  if (level === 'ERROR') return RED;\n  if (level === 'WARN') return YELLOW;\n  return GREEN;\n}\n\nfunction formatLine(level: FeLevel, message: string): string {\n  const tag = paint(`${BOLD}${CYAN}`, '[FE]');\n  const lvl = paint(levelColor(level), level);\n  const time = paint(DIM, timestamp());\n  return `${tag} ${lvl} ${time} - ${message}`;\n}\n\n/** Print a single `[FE]`-tagged log line. */\nexport function feLog(level: FeLevel, message: string): void {\n  // eslint-disable-next-line no-console\n  console.log(formatLine(level, message));\n}\n\nconst LEVEL_RANK: Record<LogLevel, number> = {\n  silent: 0,\n  error: 1,\n  warn: 2,\n  info: 3,\n};\n\n/**\n * A vite {@link Logger} that routes vite's own output through the `[FE]` format,\n * honouring `logLevel` (vite does not pre-filter for a custom logger, so the\n * logger must do it — otherwise info/warn noise leaks even at `'error'`).\n */\nexport function createOssidoViteLogger(logLevel: LogLevel = 'info'): Logger {\n  const threshold = LEVEL_RANK[logLevel] ?? LEVEL_RANK.info;\n  const logger: Logger = {\n    hasWarned: false,\n    info: (message) => {\n      if (threshold >= LEVEL_RANK.info) feLog('INFO', message);\n    },\n    warn: (message) => {\n      logger.hasWarned = true;\n      if (threshold >= LEVEL_RANK.warn) feLog('WARN', message);\n    },\n    warnOnce: (message) => {\n      if (threshold >= LEVEL_RANK.warn) feLog('WARN', message);\n    },\n    error: (message) => {\n      logger.hasWarned = true;\n      if (threshold >= LEVEL_RANK.error) feLog('ERROR', message);\n    },\n    // Ossido manages its own console; never clear it from under other processes.\n    clearScreen: () => undefined,\n    hasErrorLogged: () => false,\n  };\n  return logger;\n}\n"],"mappings":";;;;;;;AASA,MAAM,QAAQ;AACd,MAAM,OAAO;AACb,MAAM,MAAM;AACZ,MAAM,OAAO;AACb,MAAM,MAAM;AACZ,MAAM,SAAS;AACf,MAAM,QAAQ;;;;;AAMd,MAAM,gBAAgB,OAAO,YAAY,eAAe,CAAC,QAAQ,IAAI;AAIrE,SAAS,YAAoB;CAC3B,wBAAO,IAAI,KAAK,EAAC,CAAC,mBAAmB,SAAS,EAAE,QAAQ,MAAM,CAAC;AACjE;;AAGA,SAAS,MAAM,MAAc,MAAsB;CACjD,OAAO,gBAAgB,GAAG,OAAO,OAAO,UAAU;AACpD;AAEA,SAAS,WAAW,OAAwB;CAC1C,IAAI,UAAU,SAAS,OAAO;CAC9B,IAAI,UAAU,QAAQ,OAAO;CAC7B,OAAO;AACT;AAEA,SAAS,WAAW,OAAgB,SAAyB;CAI3D,OAAO,GAHK,MAAM,GAAG,OAAO,QAAQ,MAGxB,EAAE,GAFF,MAAM,WAAW,KAAK,GAAG,KAElB,EAAE,GADR,MAAM,KAAK,UAAU,CACP,EAAE,KAAK;AACpC;;AAGA,SAAgB,MAAM,OAAgB,SAAuB;CAE3D,QAAQ,IAAI,WAAW,OAAO,OAAO,CAAC;AACxC;AAEA,MAAM,aAAuC;CAC3C,QAAQ;CACR,OAAO;CACP,MAAM;CACN,MAAM;AACR;;;;;;AAOA,SAAgB,uBAAuB,WAAqB,QAAgB;CAC1E,MAAM,YAAY,WAAW,aAAa,WAAW;CACrD,MAAM,SAAiB;EACrB,WAAW;EACX,OAAO,YAAY;GACjB,IAAI,aAAa,WAAW,MAAM,MAAM,QAAQ,OAAO;EACzD;EACA,OAAO,YAAY;GACjB,OAAO,YAAY;GACnB,IAAI,aAAa,WAAW,MAAM,MAAM,QAAQ,OAAO;EACzD;EACA,WAAW,YAAY;GACrB,IAAI,aAAa,WAAW,MAAM,MAAM,QAAQ,OAAO;EACzD;EACA,QAAQ,YAAY;GAClB,OAAO,YAAY;GACnB,IAAI,aAAa,WAAW,OAAO,MAAM,SAAS,OAAO;EAC3D;EAEA,mBAAmB;EACnB,sBAAsB;CACxB;CACA,OAAO;AACT"}

package/dist/esm/build/types.d.ts

@@ -0,0 +1,29 @@
+import type { OssidoConfig, OssidoConfigServer, OssidoConfigOutput, OssidoLogFormat, OssidoLogLevel } from '../config';
+/** Fully-resolved logging config (defaults filled) written to `config.json`. */
+export interface InternalOssidoConfigLogging {
+    format: OssidoLogFormat;
+    routeTree: boolean;
+    browser: {
+        enabled: boolean;
+        level: OssidoLogLevel;
+    };
+}
+/** Fully-resolved dev config (defaults filled). */
+export interface InternalOssidoConfigDev {
+    criticalCss: boolean;
+}
+/**
+ * Fully-resolved SSR config. `renderThreads` is `null` when unset — the Rust
+ * runtime then defaults it to the machine's available parallelism.
+ */
+export interface InternalOssidoConfigSsr {
+    renderThreads: number | null;
+}
+export interface InternalOssidoConfig extends Omit<OssidoConfig, 'server' | 'logging' | 'dev' | 'ssr' | 'output' | 'viewTransitions'> {
+    server: OssidoConfigServer;
+    logging: InternalOssidoConfigLogging;
+    dev: InternalOssidoConfigDev;
+    ssr: InternalOssidoConfigSsr;
+    output: OssidoConfigOutput;
+    viewTransitions: boolean;
+}

package/dist/esm/build/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const blockingAsync: (callback: () => Promise<void>) => void;
+/**
+ * Every file under `dir`, as paths relative to `dir` (posix-style separators).
+ * Returns `[]` if `dir` doesn't exist. Used to build a build hook's `manifest`.
+ */
+export declare const listFilesRecursive: (dir: string) => Array<string>;

package/dist/esm/build/utils.js

@@ -0,0 +1,40 @@
+import { join } from "node:path";
+import { readdirSync } from "node:fs";
+
+//#region src/build/utils.ts
+const blockingAsync = (callback) => {
+	(async () => {
+		try {
+			await callback();
+		} catch (error) {
+			console.error(error);
+			process.exitCode = 1;
+		}
+	})();
+};
+/**
+* Every file under `dir`, as paths relative to `dir` (posix-style separators).
+* Returns `[]` if `dir` doesn't exist. Used to build a build hook's `manifest`.
+*/
+const listFilesRecursive = (dir) => {
+	const walk = (current, prefix) => {
+		let entries;
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			return [];
+		}
+		const files = [];
+		for (const entry of entries) {
+			const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) files.push(...walk(join(current, entry.name), rel));
+			else if (entry.isFile()) files.push(rel);
+		}
+		return files;
+	};
+	return walk(dir, "");
+};
+
+//#endregion
+export { blockingAsync, listFilesRecursive };
+//# sourceMappingURL=utils.js.map

package/dist/esm/build/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/build/utils.ts"],"sourcesContent":["import { readdirSync } from 'node:fs';\nimport { join } from 'node:path';\n\nexport const blockingAsync = (callback: () => Promise<void>): void => {\n  void (async (): Promise<void> => {\n    try {\n      await callback();\n    } catch (error) {\n      // Surface build failures instead of silently swallowing them. A failed\n      // SSR bundle build, for example, otherwise degrades to a confusing\n      // client-side fallback with hydration mismatches.\n      console.error(error);\n      process.exitCode = 1;\n    }\n  })();\n};\n\n/**\n * Every file under `dir`, as paths relative to `dir` (posix-style separators).\n * Returns `[]` if `dir` doesn't exist. Used to build a build hook's `manifest`.\n */\nexport const listFilesRecursive = (dir: string): Array<string> => {\n  const walk = (current: string, prefix: string): Array<string> => {\n    let entries;\n    try {\n      entries = readdirSync(current, { withFileTypes: true });\n    } catch {\n      return []; // missing directory (e.g. no output produced)\n    }\n    const files: Array<string> = [];\n    for (const entry of entries) {\n      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;\n      if (entry.isDirectory()) {\n        files.push(...walk(join(current, entry.name), rel));\n      } else if (entry.isFile()) {\n        files.push(rel);\n      }\n    }\n    return files;\n  };\n  return walk(dir, '');\n};\n"],"mappings":";;;;AAGA,MAAa,iBAAiB,aAAwC;CACpE,CAAM,YAA2B;EAC/B,IAAI;GACF,MAAM,SAAS;EACjB,SAAS,OAAO;GAId,QAAQ,MAAM,KAAK;GACnB,QAAQ,WAAW;EACrB;CACF,EAAC,CAAE;AACL;;;;;AAMA,MAAa,sBAAsB,QAA+B;CAChE,MAAM,QAAQ,SAAiB,WAAkC;EAC/D,IAAI;EACJ,IAAI;GACF,UAAU,YAAY,SAAS,EAAE,eAAe,KAAK,CAAC;EACxD,QAAQ;GACN,OAAO,CAAC;EACV;EACA,MAAM,QAAuB,CAAC;EAC9B,KAAK,MAAM,SAAS,SAAS;GAC3B,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,SAAS,MAAM;GACvD,IAAI,MAAM,YAAY,GACpB,MAAM,KAAK,GAAG,KAAK,KAAK,SAAS,MAAM,IAAI,GAAG,GAAG,CAAC;QAC7C,IAAI,MAAM,OAAO,GACtB,MAAM,KAAK,GAAG;EAElB;EACA,OAAO;CACT;CACA,OAAO,KAAK,KAAK,EAAE;AACrB"}

package/dist/esm/build-client/index.d.ts

@@ -0,0 +1 @@
+import 'vite/client';

package/dist/esm/build-client/index.js

@@ -0,0 +1 @@
+import "vite/client";

package/dist/esm/client/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * A typed `fetch` client for a project's `#[api(METHOD)]` routes.
+ *
+ * The HTTP method is the client method name (`apiClient.post(...)`) so the URL,
+ * route params, and the `.json()` response are all inferred from the method +
+ * path. The route map is generated into `.ossido/types.ts` as an augmentation of
+ * the `Register` interface below:
+ *
+ * ```ts
+ * declare module "@ossido-labs/ossido/client" {
+ *   interface Register {
+ *     apiRoutes: {
+ *       "/api/pokemons/[name]": {
+ *         GET: { params: { name: string }; response: import("@ossido-labs/ossido/types").Pokemon }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ```ts
+ * import { apiClient } from '@ossido-labs/ossido/client'
+ *
+ * const res = await apiClient.get('/api/pokemons/[name]', { params: { name: 'pikachu' } })
+ * const pokemon = await res.json() //=> Pokemon
+ * ```
+ */
+type MethodName = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type HttpMethod = Uppercase<MethodName>;
+/**
+ * Augmentation target for the generated route map. Left empty here; the
+ * project's generated `.ossido/types.ts` merges an `apiRoutes` member into it.
+ */
+export interface Register {
+}
+interface ApiRouteEntry {
+    params: Record<string, string>;
+    response: unknown;
+}
+type AnyApiRoutes = Record<string, Partial<Record<HttpMethod, ApiRouteEntry>>>;
+/**
+ * The registered routes, or a permissive fallback when a project hasn't
+ * generated its types yet (so the client stays usable, just untyped).
+ */
+type ApiRoutes = Register extends {
+    apiRoutes: infer R;
+} ? R extends AnyApiRoutes ? R : AnyApiRoutes : AnyApiRoutes;
+/** Paths that serve the given HTTP method. */
+type PathsFor<M extends HttpMethod> = {
+    [P in keyof ApiRoutes]: M extends keyof ApiRoutes[P] ? P : never;
+}[keyof ApiRoutes] & string;
+type EntryFor<P extends string, M extends HttpMethod> = P extends keyof ApiRoutes ? M extends keyof ApiRoutes[P] ? ApiRoutes[P][M] extends ApiRouteEntry ? ApiRoutes[P][M] : ApiRouteEntry : ApiRouteEntry : ApiRouteEntry;
+type ParamsOf<P extends string, M extends HttpMethod> = EntryFor<P, M>['params'];
+type ResponseOf<P extends string, M extends HttpMethod> = EntryFor<P, M>['response'];
+/**
+ * Whether a params object *requires* any key. `{} extends T` is true only when
+ * every property of `T` is optional/absent — so a static route
+ * (`Record<string, never>`) is `false` and a dynamic one (`{ id: string }`) is
+ * `true`. (`keyof T extends never` would be wrong: `keyof Record<string, never>`
+ * is `string`, not `never`.)
+ */
+type HasKeys<T> = {} extends T ? false : true;
+/** A `fetch` {@link Response} whose `json()` is typed to the route's response. */
+export interface TypedResponse<T> extends Response {
+    json(): Promise<T>;
+}
+/**
+ * `fetch` options minus `method` (the method is the client method name), plus
+ * `params` to fill the URL's `[segments]` — required only for dynamic routes.
+ */
+export type RequestOptions<Params> = Omit<RequestInit, 'method'> & (HasKeys<Params> extends true ? {
+    params: Params;
+} : {
+    params?: Record<string, never>;
+});
+type MethodFn<M extends HttpMethod> = <P extends PathsFor<M>>(path: P, ...args: HasKeys<ParamsOf<P, M>> extends true ? [options: RequestOptions<ParamsOf<P, M>>] : [options?: RequestOptions<ParamsOf<P, M>>]) => Promise<TypedResponse<ResponseOf<P, M>>>;
+export type ApiClient = {
+    [M in MethodName]: MethodFn<Uppercase<M>>;
+};
+export interface CreateApiClientOptions {
+    /** Prepended to every request path (e.g. an absolute origin for SSR fetches). */
+    baseUrl?: string;
+    /** Default `fetch` options merged into every request. */
+    defaults?: Omit<RequestInit, 'method'>;
+    /** Custom `fetch` implementation (defaults to the global `fetch`). */
+    fetch?: typeof fetch;
+}
+/** Create an {@link ApiClient}, optionally with a base URL and default options. */
+export declare function createApiClient(options?: CreateApiClientOptions): ApiClient;
+/** The default client — global `fetch`, relative paths. */
+export declare const apiClient: ApiClient;
+export {};

package/dist/esm/client/index.js

@@ -0,0 +1,38 @@
+//#region src/client/index.ts
+const PARAM_SEGMENT = /\[(\.\.\.)?([^\]]+)\]/g;
+/** Substitute `params` into a path template's `[segments]`. */
+function buildPath(path, params) {
+	if (!params) return path;
+	return path.replace(PARAM_SEGMENT, (_match, spread, name) => {
+		const value = params[name];
+		if (value == null) throw new TypeError(`Missing value for route param "${name}" in "${path}"`);
+		const str = String(value);
+		return spread ? str.split("/").map(encodeURIComponent).join("/") : encodeURIComponent(str);
+	});
+}
+/** Create an {@link ApiClient}, optionally with a base URL and default options. */
+function createApiClient(options = {}) {
+	const { baseUrl = "", defaults, fetch: fetchImpl } = options;
+	const request = (method) => (path, opts = {}) => {
+		const { params, ...init } = opts;
+		const url = baseUrl + buildPath(path, params);
+		return (fetchImpl ?? fetch)(url, {
+			...defaults,
+			...init,
+			method
+		});
+	};
+	return {
+		get: request("GET"),
+		post: request("POST"),
+		put: request("PUT"),
+		patch: request("PATCH"),
+		delete: request("DELETE")
+	};
+}
+/** The default client — global `fetch`, relative paths. */
+const apiClient = createApiClient();
+
+//#endregion
+export { apiClient, createApiClient };
+//# sourceMappingURL=index.js.map

package/dist/esm/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/client/index.ts"],"sourcesContent":["/**\n * A typed `fetch` client for a project's `#[api(METHOD)]` routes.\n *\n * The HTTP method is the client method name (`apiClient.post(...)`) so the URL,\n * route params, and the `.json()` response are all inferred from the method +\n * path. The route map is generated into `.ossido/types.ts` as an augmentation of\n * the `Register` interface below:\n *\n * ```ts\n * declare module \"@ossido-labs/ossido/client\" {\n *   interface Register {\n *     apiRoutes: {\n *       \"/api/pokemons/[name]\": {\n *         GET: { params: { name: string }; response: import(\"@ossido-labs/ossido/types\").Pokemon }\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ```ts\n * import { apiClient } from '@ossido-labs/ossido/client'\n *\n * const res = await apiClient.get('/api/pokemons/[name]', { params: { name: 'pikachu' } })\n * const pokemon = await res.json() //=> Pokemon\n * ```\n */\n\ntype MethodName = 'get' | 'post' | 'put' | 'patch' | 'delete';\ntype HttpMethod = Uppercase<MethodName>;\n\n/**\n * Augmentation target for the generated route map. Left empty here; the\n * project's generated `.ossido/types.ts` merges an `apiRoutes` member into it.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface Register {}\n\n// Route params are always URL-segment strings; an empty route has\n// `Record<string, never>` (no fillable segments).\ninterface ApiRouteEntry {\n  params: Record<string, string>;\n  response: unknown;\n}\ntype AnyApiRoutes = Record<string, Partial<Record<HttpMethod, ApiRouteEntry>>>;\n\n/**\n * The registered routes, or a permissive fallback when a project hasn't\n * generated its types yet (so the client stays usable, just untyped).\n */\ntype ApiRoutes = Register extends { apiRoutes: infer R }\n  ? R extends AnyApiRoutes\n    ? R\n    : AnyApiRoutes\n  : AnyApiRoutes;\n\n/** Paths that serve the given HTTP method. */\ntype PathsFor<M extends HttpMethod> = {\n  [P in keyof ApiRoutes]: M extends keyof ApiRoutes[P] ? P : never;\n}[keyof ApiRoutes] &\n  string;\n\ntype EntryFor<\n  P extends string,\n  M extends HttpMethod,\n> = P extends keyof ApiRoutes\n  ? M extends keyof ApiRoutes[P]\n    ? ApiRoutes[P][M] extends ApiRouteEntry\n      ? ApiRoutes[P][M]\n      : ApiRouteEntry\n    : ApiRouteEntry\n  : ApiRouteEntry;\n\ntype ParamsOf<P extends string, M extends HttpMethod> = EntryFor<\n  P,\n  M\n>['params'];\ntype ResponseOf<P extends string, M extends HttpMethod> = EntryFor<\n  P,\n  M\n>['response'];\n\n/**\n * Whether a params object *requires* any key. `{} extends T` is true only when\n * every property of `T` is optional/absent — so a static route\n * (`Record<string, never>`) is `false` and a dynamic one (`{ id: string }`) is\n * `true`. (`keyof T extends never` would be wrong: `keyof Record<string, never>`\n * is `string`, not `never`.)\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ntype HasKeys<T> = {} extends T ? false : true;\n\n/** A `fetch` {@link Response} whose `json()` is typed to the route's response. */\nexport interface TypedResponse<T> extends Response {\n  json(): Promise<T>;\n}\n\n/**\n * `fetch` options minus `method` (the method is the client method name), plus\n * `params` to fill the URL's `[segments]` — required only for dynamic routes.\n */\nexport type RequestOptions<Params> = Omit<RequestInit, 'method'> &\n  (HasKeys<Params> extends true\n    ? { params: Params }\n    : { params?: Record<string, never> });\n\ntype MethodFn<M extends HttpMethod> = <P extends PathsFor<M>>(\n  path: P,\n  ...args: HasKeys<ParamsOf<P, M>> extends true\n    ? [options: RequestOptions<ParamsOf<P, M>>]\n    : [options?: RequestOptions<ParamsOf<P, M>>]\n) => Promise<TypedResponse<ResponseOf<P, M>>>;\n\nexport type ApiClient = { [M in MethodName]: MethodFn<Uppercase<M>> };\n\nexport interface CreateApiClientOptions {\n  /** Prepended to every request path (e.g. an absolute origin for SSR fetches). */\n  baseUrl?: string;\n  /** Default `fetch` options merged into every request. */\n  defaults?: Omit<RequestInit, 'method'>;\n  /** Custom `fetch` implementation (defaults to the global `fetch`). */\n  fetch?: typeof fetch;\n}\n\n// Matches `[name]` and `[...slug]`, capturing the spread marker and the name.\nconst PARAM_SEGMENT = /\\[(\\.\\.\\.)?([^\\]]+)\\]/g;\n\n/** Substitute `params` into a path template's `[segments]`. */\nfunction buildPath(path: string, params?: Record<string, unknown>): string {\n  if (!params) return path;\n  return path.replace(\n    PARAM_SEGMENT,\n    (_match, spread: string | undefined, name: string) => {\n      const value = params[name];\n      if (value == null) {\n        throw new TypeError(\n          `Missing value for route param \"${name}\" in \"${path}\"`,\n        );\n      }\n      const str = String(value);\n      // A catch-all (`[...slug]`) spans multiple segments, so keep its slashes.\n      return spread\n        ? str.split('/').map(encodeURIComponent).join('/')\n        : encodeURIComponent(str);\n    },\n  );\n}\n\n/** Create an {@link ApiClient}, optionally with a base URL and default options. */\nexport function createApiClient(\n  options: CreateApiClientOptions = {},\n): ApiClient {\n  const { baseUrl = '', defaults, fetch: fetchImpl } = options;\n\n  const request =\n    (method: HttpMethod) =>\n    (\n      path: string,\n      opts: RequestInit & { params?: Record<string, unknown> } = {},\n    ): Promise<Response> => {\n      const { params, ...init } = opts;\n      const url = baseUrl + buildPath(path, params);\n      return (fetchImpl ?? fetch)(url, { ...defaults, ...init, method });\n    };\n\n  return {\n    get: request('GET'),\n    post: request('POST'),\n    put: request('PUT'),\n    patch: request('PATCH'),\n    delete: request('DELETE'),\n  } as ApiClient;\n}\n\n/** The default client — global `fetch`, relative paths. */\nexport const apiClient: ApiClient = createApiClient();\n"],"mappings":";AA6HA,MAAM,gBAAgB;;AAGtB,SAAS,UAAU,MAAc,QAA0C;CACzE,IAAI,CAAC,QAAQ,OAAO;CACpB,OAAO,KAAK,QACV,gBACC,QAAQ,QAA4B,SAAiB;EACpD,MAAM,QAAQ,OAAO;EACrB,IAAI,SAAS,MACX,MAAM,IAAI,UACR,kCAAkC,KAAK,QAAQ,KAAK,EACtD;EAEF,MAAM,MAAM,OAAO,KAAK;EAExB,OAAO,SACH,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,kBAAkB,CAAC,CAAC,KAAK,GAAG,IAC/C,mBAAmB,GAAG;CAC5B,CACF;AACF;;AAGA,SAAgB,gBACd,UAAkC,CAAC,GACxB;CACX,MAAM,EAAE,UAAU,IAAI,UAAU,OAAO,cAAc;CAErD,MAAM,WACH,YAEC,MACA,OAA2D,CAAC,MACtC;EACtB,MAAM,EAAE,QAAQ,GAAG,SAAS;EAC5B,MAAM,MAAM,UAAU,UAAU,MAAM,MAAM;EAC5C,QAAQ,aAAa,MAAK,CAAE,KAAK;GAAE,GAAG;GAAU,GAAG;GAAM;EAAO,CAAC;CACnE;CAEF,OAAO;EACL,KAAK,QAAQ,KAAK;EAClB,MAAM,QAAQ,MAAM;EACpB,KAAK,QAAQ,KAAK;EAClB,OAAO,QAAQ,OAAO;EACtB,QAAQ,QAAQ,QAAQ;CAC1B;AACF;;AAGA,MAAa,YAAuB,gBAAgB"}

package/dist/esm/config/index.d.ts

@@ -0,0 +1 @@
+export type { OssidoConfig, OssidoConfigServer, OssidoConfigLogging, OssidoConfigSsr, OssidoConfigOutput, OssidoConfigBuild, OssidoBuildContext, OssidoBuildHook, OssidoLogFormat, OssidoLogLevel, } from './types';

package/dist/esm/config/types.d.ts

@@ -0,0 +1,130 @@
+import type { AliasOptions, DepOptimizationOptions, PluginOption, CSSOptions } from 'vite';
+export interface OssidoConfigServer {
+    host: string;
+    origin: string | null;
+    port: number;
+}
+/** Output format for the server logs. */
+export type OssidoLogFormat = 'pretty' | 'json';
+/** Log severities, lowest to highest. */
+export type OssidoLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export interface OssidoConfigLogging {
+    /**
+     * Output style for the (Rust) server logs.
+     * - `'pretty'` (default): human, coloured, single line.
+     * - `'json'`: one JSON object per line, GCP Cloud Logging compatible.
+     */
+    format?: OssidoLogFormat;
+    /**
+     * Print the route tree on `ossido dev` start-up. Default `false` — set to
+     * `true` to opt in. (`ossido build` always prints it, regardless of this
+     * option.)
+     */
+    routeTree?: boolean;
+    /** Forwarding of browser `console.*` to the dev server console (dev only). */
+    browser?: {
+        /** Whether to forward browser logs at all. Default `true`. */
+        enabled?: boolean;
+        /** Minimum console level to forward. Default `'info'`. */
+        level?: OssidoLogLevel;
+    };
+}
+/**
+ * @see http://ossido.dev/documentation/configuration
+ */
+export interface OssidoConfig {
+    server?: Partial<OssidoConfigServer>;
+    vite?: {
+        alias?: AliasOptions;
+        css?: CSSOptions;
+        optimizeDeps?: DepOptimizationOptions;
+        plugins?: Array<PluginOption>;
+    };
+    logging?: OssidoConfigLogging;
+    dev?: OssidoConfigDev;
+    ssr?: OssidoConfigSsr;
+    /**
+     * Default build output mode. Default `'server'`.
+     * - `'server'`: build the SSR server (`ossido build`).
+     * - `'static'`: statically generate the site (equivalent to `ossido build
+     *   --static`).
+     *
+     * The `--static` / `--server` CLI flags override this per invocation.
+     */
+    output?: OssidoConfigOutput;
+    /** Build lifecycle hooks (`ossido build`, both output modes; not `dev`). */
+    build?: OssidoConfigBuild;
+    /**
+     * Animate client-side navigations with the browser
+     * [View Transitions API](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API).
+     * Default `false`. When enabled, `push`/`replace`/`<Link>`/back-forward
+     * navigations run inside `document.startViewTransition` (a crossfade by
+     * default; customise with `view-transition-name` / `::view-transition-*` CSS).
+     * No-ops where unsupported or under `prefers-reduced-motion`; override per
+     * navigation with `push(path, { viewTransition: false })` or
+     * `<Link viewTransition={false}>`.
+     */
+    viewTransitions?: boolean;
+}
+/** Build output mode. */
+export type OssidoConfigOutput = 'static' | 'server';
+/**
+ * Everything a build hook is given about the current `ossido build`.
+ */
+export interface OssidoBuildContext {
+    /** The resolved output mode for this build. */
+    mode: OssidoConfigOutput;
+    /**
+     * Absolute path to the deployable output directory: `out/static` for a static
+     * build, `out` for a server build. The directory you'd upload/deploy.
+     */
+    outputDirectory: string;
+    /** Absolute path to the project's source `public/` folder. */
+    publicDirectory: string;
+    /**
+     * Emitted file paths, relative to `outputDirectory`. Populated for
+     * `postbuild` (after all artifacts exist); empty for `prebuild`.
+     */
+    manifest: Array<string>;
+    /** The resolved Ossido config, so hooks can branch on build settings. */
+    config: OssidoConfig;
+}
+/**
+ * A build lifecycle hook. May be async — the build awaits it, and a thrown
+ * error fails the build.
+ */
+export type OssidoBuildHook = (ctx: OssidoBuildContext) => void | Promise<void>;
+/** `prebuild` / `postbuild` hooks, defined under `build` in the config. */
+export interface OssidoConfigBuild {
+    /** Runs before the build starts (its `ctx.manifest` is empty). */
+    prebuild?: OssidoBuildHook;
+    /** Runs after all build artifacts have been produced. */
+    postbuild?: OssidoBuildHook;
+}
+/** Server-side rendering options. */
+export interface OssidoConfigSsr {
+    /**
+     * Number of dedicated V8 render-pool threads. Each holds a warm isolate and
+     * renders one request at a time, off the async runtime (which stays free for
+     * I/O). Defaults to the machine's available parallelism (CPU cores), resolved
+     * at runtime.
+     *
+     * Lower it to cap memory on constrained hosts (e.g. `1`); raising it past the
+     * core count only adds contention for CPU-bound rendering. Overridable at
+     * runtime with the `OSSIDO_SSR_THREADS` environment variable.
+     */
+    renderThreads?: number;
+}
+/** Development-only tweaks. */
+export interface OssidoConfigDev {
+    /**
+     * Compute and inject per-route critical CSS during dev navigation, preventing
+     * a flash of unstyled content (vite injects CSS via JS, which otherwise
+     * arrives a beat late). Default `true`.
+     *
+     * Computing it walks the route's module/CSS graph, which adds latency to
+     * navigation. Set `false` for the snappiest dev navigation, accepting a brief
+     * unstyled flash on first visit to a route.
+     */
+    criticalCss?: boolean;
+}

package/dist/esm/constants.d.ts

@@ -0,0 +1 @@
+export declare const SERVER_PAYLOAD_VARIABLE_NAME = "__OSSIDO_SERVER_PAYLOAD__";

package/dist/esm/constants.js

@@ -0,0 +1,6 @@
+//#region src/constants.ts
+const SERVER_PAYLOAD_VARIABLE_NAME = "__OSSIDO_SERVER_PAYLOAD__";
+
+//#endregion
+export { SERVER_PAYLOAD_VARIABLE_NAME };
+//# sourceMappingURL=constants.js.map

package/dist/esm/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/constants.ts"],"sourcesContent":["export const SERVER_PAYLOAD_VARIABLE_NAME = '__OSSIDO_SERVER_PAYLOAD__';\n"],"mappings":";AAAA,MAAa,+BAA+B"}

package/dist/esm/hydration/browserLogForwarding.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Dev-only: forward browser `console.*` (and uncaught errors) to the Ossido dev
+ * server console, where they are printed tagged `[FE]`. The server applies the
+ * `logging.browser` level/enabled config. The original console output is kept
+ * intact.
+ */
+export declare function installBrowserLogForwarding(): void;

package/dist/esm/hydration/browserLogForwarding.js

@@ -0,0 +1,152 @@
+//#region src/hydration/browserLogForwarding.ts
+const CONSOLE_METHODS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug",
+	"trace"
+];
+const LOGS_ENDPOINT = "/__ossido/logs";
+const DATA_ROUTE_PREFIX = "/__ossido/data";
+const FLUSH_DELAY_MS = 60;
+const MAX_FRAMES = 6;
+const MAX_TRACKED_DATA_LOADS = 50;
+/** Mirror the backend's status→level mapping so a failed data load stands out. */
+function levelForStatus(status) {
+	if (status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function formatArg(arg) {
+	if (typeof arg === "string") return arg;
+	if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+	if (arg === void 0) return "undefined";
+	try {
+		return JSON.stringify(arg);
+	} catch {
+		return String(arg);
+	}
+}
+/** Tidy a browser stack: drop the leading `Name: message` line, trim frames and
+* strip the dev-server origin so paths read like the project source. */
+function cleanStack(stack) {
+	if (!stack) return [];
+	const origin = typeof location !== "undefined" ? location.origin : "";
+	return stack.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("at ") || line.includes("@")).map((line) => line.replaceAll(`${origin}/`, "").replaceAll("vite-server/", "")).slice(0, MAX_FRAMES);
+}
+function toEntry(level, args) {
+	const message = args.map(formatArg).join(" ");
+	const errorArg = args.find((arg) => arg instanceof Error);
+	return {
+		level,
+		message,
+		error: errorArg ? {
+			name: errorArg.name,
+			message: errorArg.message,
+			stack: cleanStack(errorArg.stack)
+		} : void 0
+	};
+}
+let installed = false;
+function installBrowserLogForwarding() {
+	if (installed || typeof window === "undefined") return;
+	installed = true;
+	const queue = [];
+	let scheduled = false;
+	const flush = () => {
+		scheduled = false;
+		if (queue.length === 0) return;
+		const body = JSON.stringify(queue.splice(0, queue.length));
+		const blob = new Blob([body], { type: "application/json" });
+		if (!navigator.sendBeacon?.(LOGS_ENDPOINT, blob)) fetch(LOGS_ENDPOINT, {
+			method: "POST",
+			body,
+			headers: { "Content-Type": "application/json" },
+			keepalive: true
+		}).catch(() => void 0);
+	};
+	const schedule = () => {
+		if (scheduled) return;
+		scheduled = true;
+		setTimeout(flush, FLUSH_DELAY_MS);
+	};
+	const enqueue = (level, args) => {
+		try {
+			queue.push(toEntry(level, args));
+			schedule();
+		} catch {}
+	};
+	const withForwarding = (level) => (original) => (...args) => {
+		original(...args);
+		enqueue(level, args);
+	};
+	for (const method of CONSOLE_METHODS) console[method] = withForwarding(method)(console[method].bind(console));
+	window.addEventListener("error", (event) => {
+		enqueue("error", [event.error ?? event.message]);
+	});
+	window.addEventListener("unhandledrejection", (event) => {
+		enqueue("error", [event.reason]);
+	});
+	const dataLoads = /* @__PURE__ */ new Map();
+	const originalFetch = typeof window.fetch === "function" ? window.fetch.bind(window) : void 0;
+	if (originalFetch) window.fetch = (input, init) => {
+		const request = originalFetch(input, init);
+		try {
+			const raw = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+			const { pathname, search } = new URL(raw, location.origin);
+			if (pathname.startsWith(DATA_ROUTE_PREFIX)) {
+				const navPath = pathname.slice(14) + search || "/";
+				const start = performance.now();
+				if (dataLoads.size >= MAX_TRACKED_DATA_LOADS) {
+					const oldest = dataLoads.keys().next().value;
+					if (oldest !== void 0) dataLoads.delete(oldest);
+				}
+				dataLoads.set(navPath, request.then((res) => ({
+					status: res.status,
+					durationMs: performance.now() - start
+				}), () => null));
+			}
+		} catch {}
+		return request;
+	};
+	const emitNavigation = async () => {
+		try {
+			const path = window.location.pathname + window.location.search;
+			const load = dataLoads.get(path);
+			dataLoads.delete(path);
+			const timing = load ? await load : null;
+			queue.push(timing ? {
+				level: levelForStatus(timing.status),
+				message: path,
+				navigation: true,
+				status: timing.status,
+				durationMs: timing.durationMs
+			} : {
+				level: "info",
+				message: path,
+				navigation: true
+			});
+			schedule();
+		} catch {}
+	};
+	const reportNavigation = () => {
+		queueMicrotask(() => {
+			emitNavigation();
+		});
+	};
+	const patchHistory = (method) => {
+		const original = history[method].bind(history);
+		history[method] = (...args) => {
+			original(...args);
+			reportNavigation();
+		};
+	};
+	patchHistory("pushState");
+	patchHistory("replaceState");
+	window.addEventListener("popstate", reportNavigation);
+}
+
+//#endregion
+export { installBrowserLogForwarding };
+//# sourceMappingURL=browserLogForwarding.js.map