@ossido-labs/ossido 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Schofield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# ossido
+
+The core JavaScript runtime for [Ossido](https://ossido.dev) — the React/Rust
+full-stack framework.
+
+This package is installed into every scaffolded Ossido app. It provides the
+client entry/hydration, the server-side rendering entry, the build tooling, and
+the config types the framework relies on. You normally don't import it directly
+— the [`ossido` CLI](https://github.com/ossido-labs/ossido) and the framework's
+generated code wire it up for you.
+
+## Getting started
+
+Create a new project with the CLI (installs this package for you):
+
+```sh
+ossido new [PROJECT_NAME]
+```
+
+## Entry points
+
+- `ossido` — framework primitives (e.g. `Link`) used in app code
+- `ossido/config` — `OssidoConfig` type and config helpers
+- `ossido/client` / `ossido/hydration` — client bootstrap + hydration
+- `ossido/ssr` — server-side rendering entry
+- `ossido/build` / `ossido/build-client` — build pipeline
+
+Check [ossido](https://github.com/ossido-labs/ossido) for more.

package/bin/build-config.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { buildConfig } from '../dist/esm/build/index.js';
+
+buildConfig();

package/bin/build-prod.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { buildProd } from '../dist/esm/build/index.js';
+
+buildProd();

package/bin/dev-ssr.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { developmentSSRBundle } from '../dist/esm/build/index.js';
+
+developmentSSRBundle();

package/bin/run-build-hook.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { runBuildHook } from '../dist/esm/build/index.js';
+
+// Invoked by the Rust CLI as `ossido-run-build-hook <prebuild|postbuild>`.
+runBuildHook(process.argv[2]);

package/bin/watch.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { developmentCSRWatch } from '../dist/esm/build/index.js';
+
+developmentCSRWatch();

package/dist/esm/build/config/create-json-config.d.ts

@@ -0,0 +1,10 @@
+import type { InternalOssidoConfig } from '../types';
+/**
+ * This function creates a JSON config file for the server,
+ * that will be shared with the client as a prop.
+ * The file will be saved at`.ossido/config/config.json`.
+ *
+ * The file is in JSON format to ensure it's easily read by the server,
+ * which is written in Rust.
+ */
+export declare function createJsonConfig(config: InternalOssidoConfig): Promise<void>;

package/dist/esm/build/config/create-json-config.js

@@ -0,0 +1,52 @@
+import { CONFIG_FOLDER_NAME, DOT_OSSIDO_FOLDER_NAME, SERVER_CONFIG_NAME } from "../constants.js";
+import fs from "fs/promises";
+import path from "path";
+
+//#region src/build/config/create-json-config.ts
+const CONFIG_PATH = path.join(DOT_OSSIDO_FOLDER_NAME, CONFIG_FOLDER_NAME, SERVER_CONFIG_NAME);
+/**
+* Strip the build-time-only, non-serializable properties before the config is
+* written to JSON for the Rust server/client: `vite` (plugins are functions) and
+* `build` (the `prebuild`/`postbuild` hooks are functions). Both would otherwise
+* fail `structuredClone`, and neither is needed by the server/client — the hooks
+* are invoked from the JS build via `loadConfig` (which reads the transpiled
+* config, keeping the functions).
+*/
+function removeNonSerializableProperties(config) {
+	/**
+	* Using {@link structuredClone} cause the following errors based on runtime env:
+	* ```text
+	* node
+	* DOMException [DataCloneError]: configureServer(s){a.push(s)} could not be cloned.
+	*
+	* vitest
+	* DataCloneError: (id) => id === runtimePublicPath ? id : void 0 could not be cloned.
+	* ```
+	* when vite plugins are passed inside to the config.
+	*
+	* Since the purpose of this function is to remove the vite object
+	* we are going to use destructing rather than {@link structuredClone} and `delete`
+	*
+	* @see https://github.com/tuono-labs/tuono/issues/414
+	*/
+	const { vite, build, ...configRest } = config;
+	return structuredClone(configRest);
+}
+/**
+* This function creates a JSON config file for the server,
+* that will be shared with the client as a prop.
+* The file will be saved at`.ossido/config/config.json`.
+*
+* The file is in JSON format to ensure it's easily read by the server,
+* which is written in Rust.
+*/
+async function createJsonConfig(config) {
+	const jsonConfig = removeNonSerializableProperties(config);
+	const fullPath = path.resolve(CONFIG_PATH);
+	const jsonContent = JSON.stringify(jsonConfig);
+	await fs.writeFile(fullPath, jsonContent, "utf-8");
+}
+
+//#endregion
+export { createJsonConfig };
+//# sourceMappingURL=create-json-config.js.map

package/dist/esm/build/config/create-json-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-json-config.js","names":[],"sources":["../../../../src/build/config/create-json-config.ts"],"sourcesContent":["import fs from 'fs/promises';\nimport path from 'path';\n\nimport type { InternalOssidoConfig } from '../types';\n\nimport {\n  DOT_OSSIDO_FOLDER_NAME,\n  CONFIG_FOLDER_NAME,\n  SERVER_CONFIG_NAME,\n} from '../constants';\n\nconst CONFIG_PATH = path.join(\n  DOT_OSSIDO_FOLDER_NAME,\n  CONFIG_FOLDER_NAME,\n  SERVER_CONFIG_NAME,\n);\n/**\n * Strip the build-time-only, non-serializable properties before the config is\n * written to JSON for the Rust server/client: `vite` (plugins are functions) and\n * `build` (the `prebuild`/`postbuild` hooks are functions). Both would otherwise\n * fail `structuredClone`, and neither is needed by the server/client — the hooks\n * are invoked from the JS build via `loadConfig` (which reads the transpiled\n * config, keeping the functions).\n */\nfunction removeNonSerializableProperties(\n  config: InternalOssidoConfig,\n): Omit<InternalOssidoConfig, 'vite' | 'build'> {\n  /**\n   * Using {@link structuredClone} cause the following errors based on runtime env:\n   * ```text\n   * node\n   * DOMException [DataCloneError]: configureServer(s){a.push(s)} could not be cloned.\n   *\n   * vitest\n   * DataCloneError: (id) => id === runtimePublicPath ? id : void 0 could not be cloned.\n   * ```\n   * when vite plugins are passed inside to the config.\n   *\n   * Since the purpose of this function is to remove the vite object\n   * we are going to use destructing rather than {@link structuredClone} and `delete`\n   *\n   * @see https://github.com/tuono-labs/tuono/issues/414\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const { vite, build, ...configRest } = config;\n  return structuredClone(configRest);\n}\n\n/**\n * This function creates a JSON config file for the server,\n * that will be shared with the client as a prop.\n * The file will be saved at`.ossido/config/config.json`.\n *\n * The file is in JSON format to ensure it's easily read by the server,\n * which is written in Rust.\n */\nexport async function createJsonConfig(\n  config: InternalOssidoConfig,\n): Promise<void> {\n  const jsonConfig = removeNonSerializableProperties(config);\n\n  const fullPath = path.resolve(CONFIG_PATH);\n  const jsonContent = JSON.stringify(jsonConfig);\n\n  // No need to manage error state. Ossido CLI will manage it.\n  await fs.writeFile(fullPath, jsonContent, 'utf-8');\n}\n"],"mappings":";;;;;AAWA,MAAM,cAAc,KAAK,KACvB,wBACA,oBACA,kBACF;;;;;;;;;AASA,SAAS,gCACP,QAC8C;;;;;;;;;;;;;;;;;CAkB9C,MAAM,EAAE,MAAM,OAAO,GAAG,eAAe;CACvC,OAAO,gBAAgB,UAAU;AACnC;;;;;;;;;AAUA,eAAsB,iBACpB,QACe;CACf,MAAM,aAAa,gCAAgC,MAAM;CAEzD,MAAM,WAAW,KAAK,QAAQ,WAAW;CACzC,MAAM,cAAc,KAAK,UAAU,UAAU;CAG7C,MAAM,GAAG,UAAU,UAAU,aAAa,OAAO;AACnD"}

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

@@ -0,0 +1,2 @@
+export { loadConfig } from './load-config';
+export { createJsonConfig } from './create-json-config';

package/dist/esm/build/config/load-config.d.ts

@@ -0,0 +1,2 @@
+import type { InternalOssidoConfig } from '../types';
+export declare const loadConfig: () => Promise<InternalOssidoConfig>;

package/dist/esm/build/config/load-config.js

@@ -0,0 +1,20 @@
+import { CONFIG_FILE_NAME, CONFIG_FOLDER_NAME, DOT_OSSIDO_FOLDER_NAME } from "../constants.js";
+import { normalizeConfig } from "./normalize-config.js";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region src/build/config/load-config.ts
+const loadConfig = async () => {
+	try {
+		const configFile = await import(pathToFileURL(path.join(process.cwd(), DOT_OSSIDO_FOLDER_NAME, CONFIG_FOLDER_NAME, CONFIG_FILE_NAME)).href);
+		return normalizeConfig(configFile.default);
+	} catch (err) {
+		console.error("Failed to load ossido.config.ts");
+		console.error(err);
+		return {};
+	}
+};
+
+//#endregion
+export { loadConfig };
+//# sourceMappingURL=load-config.js.map

package/dist/esm/build/config/load-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.js","names":[],"sources":["../../../../src/build/config/load-config.ts"],"sourcesContent":["import path from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\nimport type { OssidoConfig } from '../../config';\n\nimport type { InternalOssidoConfig } from '../types';\n\nimport {\n  DOT_OSSIDO_FOLDER_NAME,\n  CONFIG_FOLDER_NAME,\n  CONFIG_FILE_NAME,\n} from '../constants';\n\nimport { normalizeConfig } from './normalize-config';\n\nexport const loadConfig = async (): Promise<InternalOssidoConfig> => {\n  try {\n    const configFile = (await import(\n      pathToFileURL(\n        path.join(\n          process.cwd(),\n          DOT_OSSIDO_FOLDER_NAME,\n          CONFIG_FOLDER_NAME,\n          CONFIG_FILE_NAME,\n        ),\n      ).href\n    )) as { default: OssidoConfig };\n\n    return normalizeConfig(configFile.default);\n  } catch (err) {\n    console.error('Failed to load ossido.config.ts');\n    console.error(err);\n    return {} as InternalOssidoConfig;\n  }\n};\n"],"mappings":";;;;;;AAeA,MAAa,aAAa,YAA2C;CACnE,IAAI;EACF,MAAM,aAAc,MAAM,OACxB,cACE,KAAK,KACH,QAAQ,IAAI,GACZ,wBACA,oBACA,gBACF,CACF,CAAC,CAAC;EAGJ,OAAO,gBAAgB,WAAW,OAAO;CAC3C,SAAS,KAAK;EACZ,QAAQ,MAAM,iCAAiC;EAC/C,QAAQ,MAAM,GAAG;EACjB,OAAO,CAAC;CACV;AACF"}

package/dist/esm/build/config/normalize-config.d.ts

@@ -0,0 +1,10 @@
+import type { OssidoConfig } from '../../config';
+import type { InternalOssidoConfig } from '../types';
+/**
+ * Wrapper function to normalize the ossido.config.ts file
+ *
+ * @warning Exported for unit test.
+ *          There is no easy way to mock the module export and change it in every test
+ *          and also testing the error
+ */
+export declare const normalizeConfig: (config: OssidoConfig) => InternalOssidoConfig;

package/dist/esm/build/config/normalize-config.js

@@ -0,0 +1,75 @@
+import { CONFIG_FOLDER_NAME, DOT_OSSIDO_FOLDER_NAME } from "../constants.js";
+import path from "node:path";
+
+//#region src/build/config/normalize-config.ts
+/**
+*  Normalize vite alias option:
+* - If the path starts with `src` folder, transform it to absolute, prepending the ossido root folder
+* - If the path is absolute, remove the ".ossido/config/" path from it
+* - Otherwise leave the path untouched
+*/
+const normalizeAliasPath = (aliasPath) => {
+	if (aliasPath.startsWith("./src") || aliasPath.startsWith("src")) return path.join(process.cwd(), aliasPath);
+	if (path.isAbsolute(aliasPath)) return aliasPath.replace(path.join(DOT_OSSIDO_FOLDER_NAME, CONFIG_FOLDER_NAME), "");
+	return aliasPath;
+};
+/**
+* From a given vite aliasOptions apply {@link normalizeAliasPath} for each alias.
+*
+* The config is bundled by `vite` and emitted inside {@link DOT_OSSIDO_FOLDER_NAME}/{@link CONFIG_FOLDER_NAME}.
+* According to this, we have to ensure that the aliases provided by the user are updated to refer to the right folders.
+*
+* @see https://github.com/Valerioageno/tuono/pull/153#issuecomment-2508142877
+*/
+const normalizeViteAlias = (alias) => {
+	if (!alias) return;
+	if (Array.isArray(alias)) return alias.map(({ replacement, ...userAliasDefinition }) => ({
+		...userAliasDefinition,
+		replacement: normalizeAliasPath(replacement)
+	}));
+	if (typeof alias === "object") {
+		const normalizedAlias = {};
+		for (const [key, value] of Object.entries(alias)) normalizedAlias[key] = normalizeAliasPath(value);
+		return normalizedAlias;
+	}
+	return alias;
+};
+/**
+* Wrapper function to normalize the ossido.config.ts file
+*
+* @warning Exported for unit test.
+*          There is no easy way to mock the module export and change it in every test
+*          and also testing the error
+*/
+const normalizeConfig = (config) => {
+	return {
+		server: {
+			host: config.server?.host ?? "localhost",
+			origin: config.server?.origin ?? null,
+			port: config.server?.port ?? 3e3
+		},
+		vite: {
+			alias: normalizeViteAlias(config.vite?.alias),
+			css: config.vite?.css,
+			optimizeDeps: config.vite?.optimizeDeps,
+			plugins: config.vite?.plugins ?? []
+		},
+		logging: {
+			format: config.logging?.format ?? "pretty",
+			routeTree: config.logging?.routeTree ?? false,
+			browser: {
+				enabled: config.logging?.browser?.enabled ?? true,
+				level: config.logging?.browser?.level ?? "info"
+			}
+		},
+		dev: { criticalCss: config.dev?.criticalCss ?? true },
+		ssr: { renderThreads: config.ssr?.renderThreads ?? null },
+		output: config.output ?? "server",
+		viewTransitions: config.viewTransitions ?? false,
+		...config.build ? { build: config.build } : {}
+	};
+};
+
+//#endregion
+export { normalizeConfig };
+//# sourceMappingURL=normalize-config.js.map

package/dist/esm/build/config/normalize-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-config.js","names":[],"sources":["../../../../src/build/config/normalize-config.ts"],"sourcesContent":["import path from 'node:path';\n\nimport type { AliasOptions } from 'vite';\n\nimport type { OssidoConfig } from '../../config';\n\nimport type { InternalOssidoConfig } from '../types';\n\nimport { DOT_OSSIDO_FOLDER_NAME, CONFIG_FOLDER_NAME } from '../constants';\n\n/**\n *  Normalize vite alias option:\n * - If the path starts with `src` folder, transform it to absolute, prepending the ossido root folder\n * - If the path is absolute, remove the \".ossido/config/\" path from it\n * - Otherwise leave the path untouched\n */\nconst normalizeAliasPath = (aliasPath: string): string => {\n  if (aliasPath.startsWith('./src') || aliasPath.startsWith('src')) {\n    return path.join(process.cwd(), aliasPath);\n  }\n\n  if (path.isAbsolute(aliasPath)) {\n    return aliasPath.replace(\n      path.join(DOT_OSSIDO_FOLDER_NAME, CONFIG_FOLDER_NAME),\n      '',\n    );\n  }\n\n  return aliasPath;\n};\n\n/**\n * From a given vite aliasOptions apply {@link normalizeAliasPath} for each alias.\n *\n * The config is bundled by `vite` and emitted inside {@link DOT_OSSIDO_FOLDER_NAME}/{@link CONFIG_FOLDER_NAME}.\n * According to this, we have to ensure that the aliases provided by the user are updated to refer to the right folders.\n *\n * @see https://github.com/Valerioageno/tuono/pull/153#issuecomment-2508142877\n */\nconst normalizeViteAlias = (alias?: AliasOptions): AliasOptions | undefined => {\n  if (!alias) return;\n\n  if (Array.isArray(alias)) {\n    return (alias as Extract<AliasOptions, ReadonlyArray<unknown>>).map(\n      ({ replacement, ...userAliasDefinition }) => ({\n        ...userAliasDefinition,\n        replacement: normalizeAliasPath(replacement),\n      }),\n    );\n  }\n\n  if (typeof alias === 'object') {\n    const normalizedAlias: AliasOptions = {};\n    for (const [key, value] of Object.entries(alias)) {\n      normalizedAlias[key] = normalizeAliasPath(value as string);\n    }\n    return normalizedAlias;\n  }\n\n  return alias;\n};\n\n/**\n * Wrapper function to normalize the ossido.config.ts file\n *\n * @warning Exported for unit test.\n *          There is no easy way to mock the module export and change it in every test\n *          and also testing the error\n */\nexport const normalizeConfig = (config: OssidoConfig): InternalOssidoConfig => {\n  return {\n    server: {\n      host: config.server?.host ?? 'localhost',\n      origin: config.server?.origin ?? null,\n      port: config.server?.port ?? 3000,\n    },\n    vite: {\n      alias: normalizeViteAlias(config.vite?.alias),\n      css: config.vite?.css,\n      optimizeDeps: config.vite?.optimizeDeps,\n      plugins: config.vite?.plugins ?? [],\n    },\n    logging: {\n      format: config.logging?.format ?? 'pretty',\n      routeTree: config.logging?.routeTree ?? false,\n      browser: {\n        enabled: config.logging?.browser?.enabled ?? true,\n        level: config.logging?.browser?.level ?? 'info',\n      },\n    },\n    dev: {\n      criticalCss: config.dev?.criticalCss ?? true,\n    },\n    ssr: {\n      // `null` = auto: the Rust runtime uses the machine's available\n      // parallelism (resolving it here would bake in the build machine's cores).\n      renderThreads: config.ssr?.renderThreads ?? null,\n    },\n    output: config.output ?? 'server',\n    viewTransitions: config.viewTransitions ?? false,\n    // Carried through as-is (its `prebuild`/`postbuild` are functions, so they\n    // are only reachable via `loadConfig`, never the JSON config). Spread\n    // conditionally so an absent `build` isn't materialised as `undefined`.\n    ...(config.build ? { build: config.build } : {}),\n  };\n};\n"],"mappings":";;;;;;;;;;AAgBA,MAAM,sBAAsB,cAA8B;CACxD,IAAI,UAAU,WAAW,OAAO,KAAK,UAAU,WAAW,KAAK,GAC7D,OAAO,KAAK,KAAK,QAAQ,IAAI,GAAG,SAAS;CAG3C,IAAI,KAAK,WAAW,SAAS,GAC3B,OAAO,UAAU,QACf,KAAK,KAAK,wBAAwB,kBAAkB,GACpD,EACF;CAGF,OAAO;AACT;;;;;;;;;AAUA,MAAM,sBAAsB,UAAmD;CAC7E,IAAI,CAAC,OAAO;CAEZ,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAQ,MAAwD,KAC7D,EAAE,aAAa,GAAG,2BAA2B;EAC5C,GAAG;EACH,aAAa,mBAAmB,WAAW;CAC7C,EACF;CAGF,IAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,kBAAgC,CAAC;EACvC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,gBAAgB,OAAO,mBAAmB,KAAe;EAE3D,OAAO;CACT;CAEA,OAAO;AACT;;;;;;;;AASA,MAAa,mBAAmB,WAA+C;CAC7E,OAAO;EACL,QAAQ;GACN,MAAM,OAAO,QAAQ,QAAQ;GAC7B,QAAQ,OAAO,QAAQ,UAAU;GACjC,MAAM,OAAO,QAAQ,QAAQ;EAC/B;EACA,MAAM;GACJ,OAAO,mBAAmB,OAAO,MAAM,KAAK;GAC5C,KAAK,OAAO,MAAM;GAClB,cAAc,OAAO,MAAM;GAC3B,SAAS,OAAO,MAAM,WAAW,CAAC;EACpC;EACA,SAAS;GACP,QAAQ,OAAO,SAAS,UAAU;GAClC,WAAW,OAAO,SAAS,aAAa;GACxC,SAAS;IACP,SAAS,OAAO,SAAS,SAAS,WAAW;IAC7C,OAAO,OAAO,SAAS,SAAS,SAAS;GAC3C;EACF;EACA,KAAK,EACH,aAAa,OAAO,KAAK,eAAe,KAC1C;EACA,KAAK,EAGH,eAAe,OAAO,KAAK,iBAAiB,KAC9C;EACA,QAAQ,OAAO,UAAU;EACzB,iBAAiB,OAAO,mBAAmB;EAI3C,GAAI,OAAO,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;CAChD;AACF"}

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

@@ -0,0 +1,5 @@
+export declare const DOT_OSSIDO_FOLDER_NAME = ".ossido";
+export declare const CONFIG_FOLDER_NAME = "config";
+export declare const CONFIG_FILE_NAME = "config.mjs";
+export declare const SERVER_CONFIG_NAME = "config.json";
+export declare const ENV_PREFIX = "OSSIDO_PUBLIC_";

package/dist/esm/build/constants.js

@@ -0,0 +1,10 @@
+//#region src/build/constants.ts
+const DOT_OSSIDO_FOLDER_NAME = ".ossido";
+const CONFIG_FOLDER_NAME = "config";
+const CONFIG_FILE_NAME = "config.mjs";
+const SERVER_CONFIG_NAME = "config.json";
+const ENV_PREFIX = "OSSIDO_PUBLIC_";
+
+//#endregion
+export { CONFIG_FILE_NAME, CONFIG_FOLDER_NAME, DOT_OSSIDO_FOLDER_NAME, ENV_PREFIX, SERVER_CONFIG_NAME };
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../src/build/constants.ts"],"sourcesContent":["export const DOT_OSSIDO_FOLDER_NAME = '.ossido';\nexport const CONFIG_FOLDER_NAME = 'config';\nexport const CONFIG_FILE_NAME = 'config.mjs';\nexport const SERVER_CONFIG_NAME = 'config.json';\nexport const ENV_PREFIX = 'OSSIDO_PUBLIC_';\n"],"mappings":";AAAA,MAAa,yBAAyB;AACtC,MAAa,qBAAqB;AAClC,MAAa,mBAAmB;AAChC,MAAa,qBAAqB;AAClC,MAAa,aAAa"}

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

@@ -0,0 +1,15 @@
+declare const developmentSSRBundle: () => void;
+declare const developmentCSRWatch: () => void;
+declare const buildProd: () => void;
+declare const buildConfig: () => void;
+/**
+ * Run a user-defined build lifecycle hook (`prebuild` / `postbuild`) from
+ * `ossido.config.ts`. Invoked by the Rust CLI (`ossido-run-build-hook <name>`)
+ * at the matching point of `ossido build`. No-ops when the hook is undefined.
+ *
+ * The output/public dirs and mode mirror what the build produces: static builds
+ * deploy `out/static`, server builds `out`. `postbuild` gets the emitted-file
+ * manifest; `prebuild` runs before anything is emitted, so its manifest is empty.
+ */
+declare const runBuildHook: (name: "prebuild" | "postbuild") => void;
+export { buildProd, buildConfig, developmentCSRWatch, developmentSSRBundle, runBuildHook, };

package/dist/esm/build/index.js

@@ -0,0 +1,245 @@
+import { blockingAsync, listFilesRecursive } from "./utils.js";
+import { ENV_PREFIX } from "./constants.js";
+import { loadConfig } from "./config/load-config.js";
+import { createJsonConfig } from "./config/create-json-config.js";
+import { createOssidoViteLogger } from "./logger.js";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { readFileSync, readdirSync } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { build, createServer, mergeConfig } from "vite";
+import react from "@vitejs/plugin-react-swc";
+import inject from "@rollup/plugin-inject";
+import { OssidoReactPlugin, routeGenerator } from "@ossido-labs/ossido-react-vite-plugin";
+import { ErrorOverlayVitePlugin } from "@ossido-labs/ossido-ui/vite-plugin";
+
+//#region src/build/index.ts
+const require = createRequire(import.meta.url);
+/**
+* Absolute entry paths for the generated `.ossido` scaffold.
+*
+* The vite config sets `root: '.ossido'`. Vite's `build()` resolves a relative
+* `rollupOptions.input` against the CWD, but the dev server's dependency
+* scanner (rolldown, vite 8+) resolves it against `root` — so a path like
+* `./.ossido/client-main.tsx` double-nests to `.ossido/.ossido/...` and fails to
+* resolve. Absolute paths are unambiguous across both code paths.
+*/
+const CLIENT_MAIN_ENTRY = resolve(".ossido/client-main.tsx");
+const SERVER_MAIN_ENTRY = resolve(".ossido/server-main.tsx");
+/**
+* `@rollup/plugin-inject` injects these imports into every module that
+* references the globals below — including third-party files deep in
+* `node_modules` (e.g. `react-dom/server`). Vite 8's bundler (rolldown)
+* resolves an injected bare specifier relative to the *importing* file, so
+* `'@ossido-labs/ossido/ssr'` fails to resolve from within `react-dom`. Resolving to
+* absolute paths up-front makes the injected imports resolvable from anywhere
+* (and is a no-op for rollup on Vite <= 7).
+*/
+const SSR_POLYFILLS_MODULE = require.resolve("@ossido-labs/ossido/ssr");
+const WEB_STREAMS_POLYFILL_MODULE = require.resolve("web-streams-polyfill");
+const VITE_SSR_PLUGINS = [{
+	enforce: "post",
+	...inject({
+		ReadableStream: [WEB_STREAMS_POLYFILL_MODULE, "ReadableStream"],
+		/**
+		* Added to support `react@19`
+		* @see https://github.com/tuono-labs/tuono/issues/218
+		*/
+		MessageChannel: [SSR_POLYFILLS_MODULE, "MessageChannelPolyfill"],
+		MessageEvent: [SSR_POLYFILLS_MODULE, "MessageEventPolyfill"],
+		Event: [SSR_POLYFILLS_MODULE, "EventPolyfill"]
+	})
+}];
+/**
+* From a resolved {@link InternalOssidoConfig} return a `vite` "mergeable"
+* {@link InlineConfig} including all default ossido related options
+*/
+function createBaseViteConfigFromOssidoConfig(ossidoConfig) {
+	/**
+	* @warning Keep in sync with {@link LazyLoadingPlugin} tests:
+	* packages/lazy-fn-vite-plugin/tests/transpileSource.test.ts
+	*/
+	const pluginFilesInclude = /\.(jsx|js|mdx|md|tsx|ts)$/;
+	return {
+		root: ".ossido",
+		logLevel: "error",
+		customLogger: createOssidoViteLogger("error"),
+		publicDir: "../public",
+		cacheDir: "cache",
+		envDir: "../",
+		envPrefix: ENV_PREFIX,
+		define: {
+			__OSSIDO_STATIC__: JSON.stringify(process.env.OSSIDO_STATIC === "true"),
+			__OSSIDO_CRITICAL_CSS__: JSON.stringify(ossidoConfig.dev?.criticalCss ?? true),
+			__OSSIDO_VIEW_TRANSITIONS__: JSON.stringify(ossidoConfig.viewTransitions ?? false)
+		},
+		resolve: { alias: ossidoConfig.vite?.alias ?? {} },
+		css: ossidoConfig.vite?.css,
+		optimizeDeps: ossidoConfig.vite?.optimizeDeps,
+		plugins: [
+			...ossidoConfig.vite?.plugins ?? [],
+			react({ include: pluginFilesInclude }),
+			OssidoReactPlugin({ criticalCss: ossidoConfig.dev?.criticalCss ?? true })
+		]
+	};
+}
+const developmentSSRBundle = () => {
+	blockingAsync(async () => {
+		const config = await loadConfig();
+		await build(mergeConfig(createBaseViteConfigFromOssidoConfig(config), {
+			cacheDir: "cache-ssr",
+			plugins: VITE_SSR_PLUGINS,
+			build: {
+				ssr: true,
+				minify: false,
+				outDir: "server",
+				emptyOutDir: true,
+				rollupOptions: {
+					input: SERVER_MAIN_ENTRY,
+					output: {
+						entryFileNames: "dev-server.js",
+						format: "es"
+					}
+				}
+			},
+			ssr: {
+				target: "webworker",
+				noExternal: true
+			}
+		}));
+	});
+};
+const developmentCSRWatch = () => {
+	blockingAsync(async () => {
+		const config = await loadConfig();
+		await (await createServer(mergeConfig(createBaseViteConfigFromOssidoConfig(config), {
+			base: "/vite-server/",
+			plugins: [ErrorOverlayVitePlugin],
+			server: {
+				host: config.server.host,
+				port: config.server.port + 1,
+				strictPort: true
+			},
+			build: {
+				manifest: true,
+				emptyOutDir: true,
+				rollupOptions: { input: CLIENT_MAIN_ENTRY }
+			}
+		}))).listen();
+	});
+};
+const KB = 1024;
+const formatKb = (bytes) => `${(bytes / KB).toFixed(1)} kB`;
+/**
+* Print a compact per-asset size summary (raw + gzip) for the prod build, so
+* size regressions are visible on every `ossido build` without extra tooling.
+* Reads the emitted files directly — works regardless of vite's log level.
+*/
+const printBundleSummary = () => {
+	const collectDir = (dir, prefix) => {
+		try {
+			return readdirSync(dir, {
+				recursive: true,
+				encoding: "utf-8"
+			}).filter((file) => /\.(js|css)$/.test(file)).map((file) => {
+				const content = readFileSync(join(dir, file));
+				return {
+					label: `${prefix}/${file}`,
+					size: content.length,
+					gzip: gzipSync(content).length
+				};
+			});
+		} catch {
+			return [];
+		}
+	};
+	const assets = [...collectDir(resolve("out/client"), "client"), ...collectDir(resolve("out/server"), "server")].sort((a, b) => b.size - a.size);
+	if (!assets.length) return;
+	const labelWidth = Math.max(...assets.map((asset) => asset.label.length));
+	console.log("");
+	for (const asset of assets) console.log(`  ${asset.label.padEnd(labelWidth)}  ${formatKb(asset.size).padStart(10)} │ gzip: ${formatKb(asset.gzip).padStart(9)}`);
+	const total = assets.reduce((sum, asset) => sum + asset.size, 0);
+	const totalGzip = assets.reduce((sum, asset) => sum + asset.gzip, 0);
+	console.log(`  ${"total".padEnd(labelWidth)}  ${formatKb(total).padStart(10)} │ gzip: ${formatKb(totalGzip).padStart(9)}`);
+	console.log("");
+};
+const buildProd = () => {
+	blockingAsync(async () => {
+		const config = await loadConfig();
+		await routeGenerator();
+		await Promise.all([build(mergeConfig(createBaseViteConfigFromOssidoConfig(config), { build: {
+			manifest: true,
+			emptyOutDir: true,
+			outDir: "../out/client",
+			rollupOptions: { input: CLIENT_MAIN_ENTRY }
+		} })), build(mergeConfig(createBaseViteConfigFromOssidoConfig(config), {
+			plugins: VITE_SSR_PLUGINS,
+			build: {
+				ssr: true,
+				minify: true,
+				outDir: "../out/server",
+				emptyOutDir: true,
+				rollupOptions: {
+					input: SERVER_MAIN_ENTRY,
+					output: {
+						entryFileNames: "prod-server.js",
+						format: "es"
+					}
+				}
+			},
+			ssr: {
+				target: "webworker",
+				noExternal: true
+			}
+		}))]);
+		printBundleSummary();
+	});
+};
+const buildConfig = () => {
+	blockingAsync(async () => {
+		await build({
+			root: ".ossido",
+			logLevel: "error",
+			cacheDir: "cache",
+			envDir: "../",
+			build: {
+				ssr: true,
+				outDir: "config",
+				emptyOutDir: true,
+				rollupOptions: {
+					input: "./ossido.config.ts",
+					output: { entryFileNames: "config.mjs" }
+				}
+			}
+		});
+		const config = await loadConfig();
+		await createJsonConfig(config);
+	});
+};
+/**
+* Run a user-defined build lifecycle hook (`prebuild` / `postbuild`) from
+* `ossido.config.ts`. Invoked by the Rust CLI (`ossido-run-build-hook <name>`)
+* at the matching point of `ossido build`. No-ops when the hook is undefined.
+*
+* The output/public dirs and mode mirror what the build produces: static builds
+* deploy `out/static`, server builds `out`. `postbuild` gets the emitted-file
+* manifest; `prebuild` runs before anything is emitted, so its manifest is empty.
+*/
+const runBuildHook = (name) => blockingAsync(async () => {
+	const config = await loadConfig();
+	const hook = config.build?.[name];
+	if (typeof hook !== "function") return;
+	const mode = process.env.OSSIDO_STATIC === "true" ? "static" : "server";
+	const outputDirectory = resolve(mode === "static" ? "out/static" : "out");
+	await hook({
+		mode,
+		outputDirectory,
+		publicDirectory: resolve("public"),
+		manifest: name === "postbuild" ? listFilesRecursive(outputDirectory) : [],
+		config
+	});
+});
+
+//#endregion
+export { buildConfig, buildProd, developmentCSRWatch, developmentSSRBundle, runBuildHook };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/build/index.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { resolve, join } from 'node:path';\nimport { readdirSync, readFileSync } from 'node:fs';\nimport { gzipSync } from 'node:zlib';\n\nimport type { InlineConfig, Plugin } from 'vite';\nimport { build, createServer, mergeConfig } from 'vite';\nimport react from '@vitejs/plugin-react-swc';\nimport inject from '@rollup/plugin-inject';\nimport { OssidoReactPlugin, routeGenerator } from '@ossido-labs/ossido-react-vite-plugin';\nimport { ErrorOverlayVitePlugin } from '@ossido-labs/ossido-ui/vite-plugin';\n\nimport type { OssidoConfig } from '../config';\n\nimport type { InternalOssidoConfig } from './types';\nimport { blockingAsync, listFilesRecursive } from './utils';\nimport { createJsonConfig, loadConfig } from './config';\nimport { ENV_PREFIX } from './constants';\nimport { createOssidoViteLogger } from './logger';\n\nconst require = createRequire(import.meta.url);\n\n/**\n * Absolute entry paths for the generated `.ossido` scaffold.\n *\n * The vite config sets `root: '.ossido'`. Vite's `build()` resolves a relative\n * `rollupOptions.input` against the CWD, but the dev server's dependency\n * scanner (rolldown, vite 8+) resolves it against `root` — so a path like\n * `./.ossido/client-main.tsx` double-nests to `.ossido/.ossido/...` and fails to\n * resolve. Absolute paths are unambiguous across both code paths.\n */\nconst CLIENT_MAIN_ENTRY = resolve('.ossido/client-main.tsx');\nconst SERVER_MAIN_ENTRY = resolve('.ossido/server-main.tsx');\n\n/**\n * `@rollup/plugin-inject` injects these imports into every module that\n * references the globals below — including third-party files deep in\n * `node_modules` (e.g. `react-dom/server`). Vite 8's bundler (rolldown)\n * resolves an injected bare specifier relative to the *importing* file, so\n * `'@ossido-labs/ossido/ssr'` fails to resolve from within `react-dom`. Resolving to\n * absolute paths up-front makes the injected imports resolvable from anywhere\n * (and is a no-op for rollup on Vite <= 7).\n */\nconst SSR_POLYFILLS_MODULE = require.resolve('@ossido-labs/ossido/ssr');\nconst WEB_STREAMS_POLYFILL_MODULE = require.resolve('web-streams-polyfill');\n\nconst VITE_SSR_PLUGINS: Array<Plugin> = [\n  {\n    enforce: 'post',\n    // `@rollup/plugin-inject` is typed against an older rollup than the one\n    // bundled with vite, so its `Plugin` type needs widening to vite's.\n    ...(inject({\n      ReadableStream: [WEB_STREAMS_POLYFILL_MODULE, 'ReadableStream'],\n\n      /**\n       * Added to support `react@19`\n       * @see https://github.com/tuono-labs/tuono/issues/218\n       */\n      MessageChannel: [SSR_POLYFILLS_MODULE, 'MessageChannelPolyfill'],\n      MessageEvent: [SSR_POLYFILLS_MODULE, 'MessageEventPolyfill'],\n      Event: [SSR_POLYFILLS_MODULE, 'EventPolyfill'],\n    }) as unknown as Plugin),\n  },\n];\n\n/**\n * From a resolved {@link InternalOssidoConfig} return a `vite` \"mergeable\"\n * {@link InlineConfig} including all default ossido related options\n */\nfunction createBaseViteConfigFromOssidoConfig(\n  ossidoConfig: InternalOssidoConfig,\n): InlineConfig {\n  /**\n   * @warning Keep in sync with {@link LazyLoadingPlugin} tests:\n   * packages/lazy-fn-vite-plugin/tests/transpileSource.test.ts\n   */\n  const pluginFilesInclude = /\\.(jsx|js|mdx|md|tsx|ts)$/;\n\n  const viteBaseConfig: InlineConfig = {\n    root: '.ossido',\n    // `'error'` (not `'silent'`) so build failures surface instead of\n    // degrading to a silent client-side fallback with hydration mismatches.\n    logLevel: 'error',\n    // Tag vite's output `[FE]` so it matches the rest of the Ossido logs. The\n    // level is passed explicitly so the logger honours it (see the logger docs)\n    // — this keeps vite's info/benign-warning noise out at `'error'`.\n    customLogger: createOssidoViteLogger('error'),\n    publicDir: '../public',\n    cacheDir: 'cache',\n    envDir: '../',\n    envPrefix: ENV_PREFIX,\n\n    define: {\n      // Baked into the client bundle for `ossido build --static` (the CLI sets\n      // `OSSIDO_STATIC` for the react build). The router reads it to fetch the\n      // pre-rendered `.json` data files instead of the extensionless\n      // `/__ossido/data{path}` route, which has no server in a static export.\n      __OSSIDO_STATIC__: JSON.stringify(process.env.OSSIDO_STATIC === 'true'),\n      // Baked into both bundles so `<CriticalCss>` skips rendering its dev\n      // stylesheet links when `dev.criticalCss: false` — the vite endpoint is\n      // disabled in that case, so the links would otherwise be dead requests\n      // that block rendering.\n      __OSSIDO_CRITICAL_CSS__: JSON.stringify(\n        ossidoConfig.dev?.criticalCss ?? true,\n      ),\n      // Baked into both bundles so the router wraps client navigations in\n      // `document.startViewTransition` only when the app opted in via\n      // `viewTransitions: true`. Off by default.\n      __OSSIDO_VIEW_TRANSITIONS__: JSON.stringify(\n        ossidoConfig.viewTransitions ?? false,\n      ),\n    },\n\n    resolve: {\n      alias: ossidoConfig.vite?.alias ?? {},\n    },\n\n    css: ossidoConfig.vite?.css,\n\n    optimizeDeps: ossidoConfig.vite?.optimizeDeps,\n\n    plugins: [\n      ...(ossidoConfig.vite?.plugins ?? []),\n\n      /**\n       * even if `include` is not a valid option for this\n       * plugin, we have to use it.\n       * If not specified, when running `ossido dev`, the mdx\n       * won't be compiled include any style in the page and it might\n       * seem broken.\n       */\n      // @ts-expect-error see above comment\n      react({ include: pluginFilesInclude }),\n\n      OssidoReactPlugin({ criticalCss: ossidoConfig.dev?.criticalCss ?? true }),\n    ],\n  };\n\n  // seems redundant but it's useful to log the value when debugging, until we have a logging infrastructure.\n  return viteBaseConfig;\n}\n\nconst developmentSSRBundle = (): void => {\n  blockingAsync(async () => {\n    const config = await loadConfig();\n    await build(\n      mergeConfig<InlineConfig, InlineConfig>(\n        createBaseViteConfigFromOssidoConfig(config),\n        {\n          // A dedicated cache dir, separate from the client dev server's\n          // (`.ossido/cache`). Both run concurrently in dev, and this SSR bundle\n          // is rebuilt on every `.tsx`/`.mdx`/CSS-module edit — sharing the cache\n          // makes each rebuild invalidate the dev server's optimized-deps cache,\n          // which triggers a spurious full-page reload (and data refetch) right\n          // after the in-place Fast Refresh has already applied.\n          cacheDir: 'cache-ssr',\n          plugins: VITE_SSR_PLUGINS,\n          build: {\n            ssr: true,\n            minify: false,\n            outDir: 'server',\n            emptyOutDir: true,\n            rollupOptions: {\n              input: SERVER_MAIN_ENTRY,\n              output: {\n                entryFileNames: 'dev-server.js',\n                // ESM (not IIFE) so the SSR entry can use top-level `await`; the\n                // Rust runtime compiles it as a V8 module (`Ssr::from_module`).\n                // The build stays a single `dev-server.js` — the only file the\n                // runtime reads — because the SSR build disables code splitting.\n                format: 'es',\n              },\n            },\n          },\n          ssr: {\n            target: 'webworker',\n            noExternal: true,\n          },\n        },\n      ),\n    );\n  });\n};\n\nconst developmentCSRWatch = (): void => {\n  blockingAsync(async () => {\n    const config = await loadConfig();\n\n    const server = await createServer(\n      mergeConfig<InlineConfig, InlineConfig>(\n        createBaseViteConfigFromOssidoConfig(config),\n        {\n          // Entry point for the development vite proxy\n          base: '/vite-server/',\n          plugins: [ErrorOverlayVitePlugin],\n\n          server: {\n            host: config.server.host,\n            port: config.server.port + 1,\n            strictPort: true,\n          },\n          build: {\n            manifest: true,\n            emptyOutDir: true,\n            rollupOptions: {\n              input: CLIENT_MAIN_ENTRY,\n            },\n          },\n        },\n      ),\n    );\n    await server.listen();\n  });\n};\n\nconst KB = 1024;\n\nconst formatKb = (bytes: number): string => `${(bytes / KB).toFixed(1)} kB`;\n\n/**\n * Print a compact per-asset size summary (raw + gzip) for the prod build, so\n * size regressions are visible on every `ossido build` without extra tooling.\n * Reads the emitted files directly — works regardless of vite's log level.\n */\nconst printBundleSummary = (): void => {\n  interface AssetRow {\n    label: string;\n    size: number;\n    gzip: number;\n  }\n\n  const collectDir = (dir: string, prefix: string): Array<AssetRow> => {\n    try {\n      return readdirSync(dir, { recursive: true, encoding: 'utf-8' })\n        .filter((file) => /\\.(js|css)$/.test(file))\n        .map((file) => {\n          const content = readFileSync(join(dir, file));\n          return {\n            label: `${prefix}/${file}`,\n            size: content.length,\n            gzip: gzipSync(content).length,\n          };\n        });\n    } catch {\n      return [];\n    }\n  };\n\n  const assets = [\n    ...collectDir(resolve('out/client'), 'client'),\n    ...collectDir(resolve('out/server'), 'server'),\n  ].sort((a, b) => b.size - a.size);\n\n  if (!assets.length) return;\n\n  const labelWidth = Math.max(...assets.map((asset) => asset.label.length));\n  console.log('');\n  for (const asset of assets) {\n    console.log(\n      `  ${asset.label.padEnd(labelWidth)}  ${formatKb(asset.size).padStart(10)} │ gzip: ${formatKb(asset.gzip).padStart(9)}`,\n    );\n  }\n  const total = assets.reduce((sum, asset) => sum + asset.size, 0);\n  const totalGzip = assets.reduce((sum, asset) => sum + asset.gzip, 0);\n  console.log(\n    `  ${'total'.padEnd(labelWidth)}  ${formatKb(total).padStart(10)} │ gzip: ${formatKb(totalGzip).padStart(9)}`,\n  );\n  console.log('');\n};\n\nconst buildProd = (): void => {\n  blockingAsync(async () => {\n    const config = await loadConfig();\n\n    // Generate the route tree once up front. Both builds' plugin instances\n    // re-run the generator on `configResolved`, but it skips the write when\n    // the content is unchanged — pre-generating removes the concurrent-write\n    // hazard so the two builds (independent outputs) can run in parallel.\n    await routeGenerator();\n\n    await Promise.all([\n      build(\n        mergeConfig<InlineConfig, InlineConfig>(\n          createBaseViteConfigFromOssidoConfig(config),\n          {\n            build: {\n              manifest: true,\n              emptyOutDir: true,\n              outDir: '../out/client',\n              rollupOptions: {\n                input: CLIENT_MAIN_ENTRY,\n              },\n            },\n          },\n        ),\n      ),\n      build(\n        mergeConfig<InlineConfig, InlineConfig>(\n          createBaseViteConfigFromOssidoConfig(config),\n          {\n            plugins: VITE_SSR_PLUGINS,\n            build: {\n              ssr: true,\n              minify: true,\n              outDir: '../out/server',\n              emptyOutDir: true,\n              rollupOptions: {\n                input: SERVER_MAIN_ENTRY,\n                output: {\n                  entryFileNames: 'prod-server.js',\n                  // ESM (not IIFE) so the SSR entry can use top-level `await`;\n                  // the Rust runtime compiles it as a V8 module\n                  // (`Ssr::from_module`). The build stays a single\n                  // `prod-server.js` — the only file the runtime reads —\n                  // because the SSR build disables code splitting.\n                  format: 'es',\n                },\n              },\n            },\n            ssr: {\n              target: 'webworker',\n              noExternal: true,\n            },\n          },\n        ),\n      ),\n    ]);\n\n    printBundleSummary();\n  });\n};\n\nconst buildConfig = (): void => {\n  blockingAsync(async (): Promise<void> => {\n    await build({\n      root: '.ossido',\n      // `'error'` (not `'silent'`) so config build failures are visible.\n      logLevel: 'error',\n      cacheDir: 'cache',\n      envDir: '../',\n      build: {\n        ssr: true,\n        outDir: 'config',\n        emptyOutDir: true,\n        rollupOptions: {\n          input: './ossido.config.ts',\n          output: {\n            entryFileNames: 'config.mjs',\n          },\n        },\n      },\n    });\n\n    const config = await loadConfig();\n    await createJsonConfig(config);\n  });\n};\n\n/**\n * Run a user-defined build lifecycle hook (`prebuild` / `postbuild`) from\n * `ossido.config.ts`. Invoked by the Rust CLI (`ossido-run-build-hook <name>`)\n * at the matching point of `ossido build`. No-ops when the hook is undefined.\n *\n * The output/public dirs and mode mirror what the build produces: static builds\n * deploy `out/static`, server builds `out`. `postbuild` gets the emitted-file\n * manifest; `prebuild` runs before anything is emitted, so its manifest is empty.\n */\nconst runBuildHook = (name: 'prebuild' | 'postbuild'): void =>\n  blockingAsync(async () => {\n    const config = await loadConfig();\n    const hook = config.build?.[name];\n    if (typeof hook !== 'function') return;\n\n    const mode = process.env.OSSIDO_STATIC === 'true' ? 'static' : 'server';\n    const outputDirectory = resolve(mode === 'static' ? 'out/static' : 'out');\n    const publicDirectory = resolve('public');\n    const manifest =\n      name === 'postbuild' ? listFilesRecursive(outputDirectory) : [];\n\n    // `loadConfig` returns the resolved `InternalOssidoConfig` (a structural\n    // superset of the public `OssidoConfig` the hook context exposes).\n    await hook({\n      mode,\n      outputDirectory,\n      publicDirectory,\n      manifest,\n      config: config as OssidoConfig,\n    });\n  });\n\nexport {\n  buildProd,\n  buildConfig,\n  developmentCSRWatch,\n  developmentSSRBundle,\n  runBuildHook,\n};\n"],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import { type Logger, type LogLevel } from 'vite';
+type FeLevel = 'INFO' | 'WARN' | 'ERROR';
+/** Print a single `[FE]`-tagged log line. */
+export declare function feLog(level: FeLevel, message: string): void;
+/**
+ * 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'`).
+ */
+export declare function createOssidoViteLogger(logLevel?: LogLevel): Logger;
+export {};