@site-index/vite-runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deasilsoft
+
+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,119 @@
+# @site-index/vite-runtime
+
+Vite-backed runtime for executing site-index pipelines through Vite SSR module loading.
+
+[Repository README](../../../README.md)
+
+## Install
+
+```bash
+npm install @site-index/vite-runtime
+```
+
+Requirements:
+
+- Node.js `>=22`
+- peer dependency: `vite ^8.0.10`
+
+## When to use
+
+Use this package when building adapters or integrations that need direct Vite-backed pipeline execution.
+
+## When not to use
+
+- Most users should use [`site-index`](../../site-index/README.md) or [`@site-index/vite-plugin`](../vite-plugin/README.md) directly.
+
+## Public exports
+
+```ts
+export { createRuntimeService } from "./domains/runtime/factory.js";
+export { RuntimeServiceBuilder } from "./domains/runtime/builder.js";
+export { RuntimeService } from "./domains/runtime/service.js";
+export type { Options, RuntimeViteConfig } from "./types.js";
+```
+
+## Public API
+
+Factory:
+
+```ts
+createRuntimeService(): RuntimeServiceBuilder
+```
+
+Builder:
+
+```ts
+class RuntimeServiceBuilder {
+  withOptions(options: Options): this;
+  withViteConfig(config: RuntimeViteConfig): this;
+  withViteServer(server: Vite.ViteDevServer): this;
+  build(): RuntimeService;
+}
+```
+
+Runtime service:
+
+```ts
+class RuntimeService {
+  buildArtifacts(): Promise<SiteIndex.Result<SiteIndex.Artifact[]>>;
+  getArtifacts(): readonly SiteIndex.Artifact[];
+  getWatchedFiles(): ReadonlySet<string>;
+  close(): Promise<void>;
+}
+```
+
+Options:
+
+```ts
+type Options = Pick<SiteIndex.Options, "siteUrl" | "extensions">;
+```
+
+Runtime Vite config:
+
+```ts
+type RuntimeViteConfig = {
+  root: Vite.ResolvedConfig["root"];
+  mode: Vite.ResolvedConfig["mode"];
+  configFile?: Vite.ResolvedConfig["configFile"];
+};
+```
+
+## Behavior
+
+- uses Vite SSR loading for executing discovered site-index modules
+- can run with an existing Vite dev server
+- can create its own middleware-mode Vite server from config
+- tracks watched files through Vite's SSR module graph
+- serializes `buildArtifacts()` calls through an internal queue
+- snapshots latest artifacts and watched files
+- clears snapshots and closes internally created server resources on `close()`
+- does not close externally provided Vite dev servers
+
+## Example
+
+```ts
+import { createRuntimeService } from "@site-index/vite-runtime";
+
+const runtime = createRuntimeService()
+  .withOptions({
+    siteUrl: "https://example.com",
+  })
+  .withViteConfig({
+    root: process.cwd(),
+    mode: "production",
+  })
+  .build();
+
+try {
+  const result = await runtime.buildArtifacts();
+  // use result.data and result.warnings
+} finally {
+  await runtime.close();
+}
+```
+
+## Related packages
+
+- [`@site-index/core`](../core/README.md)
+- [`@site-index/vite-plugin`](../vite-plugin/README.md)
+- [`site-index`](../../site-index/README.md)

package/dist/domains/module/loader.d.ts

@@ -0,0 +1,13 @@
+import type * as SiteIndex from "@site-index/core";
+import type * as Vite from "vite";
+import type { WatchedFilesBuilder } from "./watched-files.builder.js";
+type Input = {
+    getServer: () => Promise<Vite.ViteDevServer>;
+    watchedFilesBuilder: WatchedFilesBuilder;
+};
+export declare class ModuleLoader {
+    #private;
+    constructor(input: Input);
+    loadModule(module: SiteIndex.Module): Promise<SiteIndex.ModuleExports>;
+}
+export {};

package/dist/domains/module/loader.js

@@ -0,0 +1,25 @@
+export class ModuleLoader {
+    #moduleExports = new Map();
+    #getServer;
+    #watchedFilesBuilder;
+    constructor(input) {
+        this.#getServer = input.getServer;
+        this.#watchedFilesBuilder = input.watchedFilesBuilder;
+    }
+    async loadModule(module) {
+        const cachedModuleExports = this.#moduleExports.get(module.importId);
+        if (cachedModuleExports !== undefined) {
+            return cachedModuleExports;
+        }
+        const server = await this.#getServer();
+        const loadedModule = await server.ssrLoadModule(module.importId);
+        const moduleExports = loadedModule.default;
+        const node = await server.environments.ssr.moduleGraph.getModuleByUrl(module.importId);
+        if (node === undefined) {
+            throw new Error(`Unable to resolve loaded module "${module.importId}"`);
+        }
+        this.#moduleExports.set(module.importId, moduleExports);
+        this.#watchedFilesBuilder.addModuleNode(node);
+        return moduleExports;
+    }
+}

package/dist/domains/module/watched-files.builder.d.ts

@@ -0,0 +1,7 @@
+import type * as Vite from "vite";
+import { WatchedFiles } from "./watched-files.js";
+export declare class WatchedFilesBuilder {
+    #private;
+    addModuleNode(node: Vite.EnvironmentModuleNode): void;
+    build(): WatchedFiles;
+}

package/dist/domains/module/watched-files.builder.js

@@ -0,0 +1,20 @@
+import { WatchedFiles } from "./watched-files.js";
+export class WatchedFilesBuilder {
+    #nodes = new Set();
+    #files = new Set();
+    addModuleNode(node) {
+        if (this.#nodes.has(node)) {
+            return;
+        }
+        this.#nodes.add(node);
+        if (typeof node.file === "string") {
+            this.#files.add(node.file);
+        }
+        for (const importedModule of node.importedModules) {
+            this.addModuleNode(importedModule);
+        }
+    }
+    build() {
+        return new WatchedFiles(this.#files);
+    }
+}

package/dist/domains/module/watched-files.d.ts

@@ -0,0 +1,6 @@
+export declare class WatchedFiles {
+    #private;
+    constructor(files: Iterable<string>);
+    getFiles(): ReadonlySet<string>;
+    static empty(): WatchedFiles;
+}

package/dist/domains/module/watched-files.js

@@ -0,0 +1,12 @@
+export class WatchedFiles {
+    #files;
+    constructor(files) {
+        this.#files = new Set(files);
+    }
+    getFiles() {
+        return new Set(this.#files);
+    }
+    static empty() {
+        return new WatchedFiles([]);
+    }
+}

package/dist/domains/runtime/builder.d.ts

@@ -0,0 +1,10 @@
+import type * as Vite from "vite";
+import type { Options, RuntimeViteConfig } from "../../types.js";
+import { RuntimeService } from "./service.js";
+export declare class RuntimeServiceBuilder {
+    #private;
+    withOptions(options: Options): this;
+    withViteConfig(config: RuntimeViteConfig): this;
+    withViteServer(server: Vite.ViteDevServer): this;
+    build(): RuntimeService;
+}

package/dist/domains/runtime/builder.js

@@ -0,0 +1,28 @@
+import { CreatedServerConnection } from "../server/created.connection.js";
+import { ExistingServerConnection } from "../server/existing.connection.js";
+import { RuntimeService } from "./service.js";
+export class RuntimeServiceBuilder {
+    #options;
+    #serverConnection;
+    withOptions(options) {
+        this.#options = options;
+        return this;
+    }
+    withViteConfig(config) {
+        this.#serverConnection = new CreatedServerConnection(config);
+        return this;
+    }
+    withViteServer(server) {
+        this.#serverConnection = new ExistingServerConnection(server);
+        return this;
+    }
+    build() {
+        if (this.#options === undefined) {
+            throw new Error("Options must be provided to build the RuntimeService.");
+        }
+        if (this.#serverConnection === undefined) {
+            throw new Error("Vite server or config must be provided to build the RuntimeService.");
+        }
+        return new RuntimeService(this.#options, this.#serverConnection);
+    }
+}

package/dist/domains/runtime/factory.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeServiceBuilder } from "./builder.js";
+export declare function createRuntimeService(): RuntimeServiceBuilder;

package/dist/domains/runtime/factory.js

@@ -0,0 +1,4 @@
+import { RuntimeServiceBuilder } from "./builder.js";
+export function createRuntimeService() {
+    return new RuntimeServiceBuilder();
+}

package/dist/domains/runtime/service.d.ts

@@ -0,0 +1,11 @@
+import * as SiteIndex from "@site-index/core";
+import type { Options } from "../../types.js";
+import type { ServerConnection } from "../server/connection.js";
+export declare class RuntimeService {
+    #private;
+    constructor(options: Options, serverConnection: ServerConnection);
+    buildArtifacts(): Promise<SiteIndex.Result<SiteIndex.Artifact[]>>;
+    getArtifacts(): readonly SiteIndex.Artifact[];
+    getWatchedFiles(): ReadonlySet<string>;
+    close(): Promise<void>;
+}

package/dist/domains/runtime/service.js

@@ -0,0 +1,47 @@
+import * as SiteIndex from "@site-index/core";
+import { ModuleLoader } from "../module/loader.js";
+import { WatchedFilesBuilder } from "../module/watched-files.builder.js";
+import { RuntimeSnapshot } from "./snapshot.js";
+export class RuntimeService {
+    #options;
+    #serverConnection;
+    #snapshot = RuntimeSnapshot.empty();
+    #buildQueue = Promise.resolve();
+    constructor(options, serverConnection) {
+        this.#options = options;
+        this.#serverConnection = serverConnection;
+    }
+    async buildArtifacts() {
+        const run = this.#buildQueue.then(async () => this.#runBuildArtifacts(), async () => this.#runBuildArtifacts());
+        this.#buildQueue = run.then(() => { }, () => { });
+        return run;
+    }
+    async #runBuildArtifacts() {
+        const watchedFilesBuilder = new WatchedFilesBuilder();
+        const moduleLoader = new ModuleLoader({
+            getServer: () => this.#serverConnection.getServer(),
+            watchedFilesBuilder,
+        });
+        const result = await SiteIndex.main({
+            siteUrl: this.#options.siteUrl,
+            rootPath: this.#serverConnection.getRootPath(),
+            extensions: this.#options.extensions,
+            loadModule: moduleLoader.loadModule.bind(moduleLoader),
+        });
+        this.#snapshot = new RuntimeSnapshot({
+            artifacts: result.data,
+            watchedFiles: watchedFilesBuilder.build(),
+        });
+        return result;
+    }
+    getArtifacts() {
+        return this.#snapshot.getArtifacts();
+    }
+    getWatchedFiles() {
+        return this.#snapshot.getWatchedFiles();
+    }
+    async close() {
+        this.#snapshot = RuntimeSnapshot.empty();
+        await this.#serverConnection.close();
+    }
+}

package/dist/domains/runtime/snapshot.d.ts

@@ -0,0 +1,14 @@
+import type * as SiteIndex from "@site-index/core";
+import { WatchedFiles } from "../module/watched-files.js";
+type Input = {
+    artifacts: readonly SiteIndex.Artifact[];
+    watchedFiles: WatchedFiles;
+};
+export declare class RuntimeSnapshot {
+    #private;
+    constructor(input: Input);
+    getArtifacts(): readonly SiteIndex.Artifact[];
+    getWatchedFiles(): ReadonlySet<string>;
+    static empty(): RuntimeSnapshot;
+}
+export {};

package/dist/domains/runtime/snapshot.js

@@ -0,0 +1,21 @@
+import { WatchedFiles } from "../module/watched-files.js";
+export class RuntimeSnapshot {
+    #artifacts;
+    #watchedFiles;
+    constructor(input) {
+        this.#artifacts = [...input.artifacts];
+        this.#watchedFiles = input.watchedFiles;
+    }
+    getArtifacts() {
+        return [...this.#artifacts];
+    }
+    getWatchedFiles() {
+        return this.#watchedFiles.getFiles();
+    }
+    static empty() {
+        return new RuntimeSnapshot({
+            artifacts: [],
+            watchedFiles: WatchedFiles.empty(),
+        });
+    }
+}

package/dist/domains/server/config.d.ts

@@ -0,0 +1,3 @@
+import * as Vite from "vite";
+import type { RuntimeViteConfig } from "../../types.js";
+export declare function makeServerConfig(input: RuntimeViteConfig): Vite.InlineConfig;

package/dist/domains/server/config.js

@@ -0,0 +1,16 @@
+import * as Vite from "vite";
+export function makeServerConfig(input) {
+    const output = {
+        root: input.root,
+        mode: input.mode,
+        appType: "custom",
+        server: {
+            middlewareMode: true,
+            hmr: false,
+        },
+    };
+    if (input.configFile !== undefined) {
+        output.configFile = input.configFile;
+    }
+    return output;
+}

package/dist/domains/server/connection.d.ts

@@ -0,0 +1,6 @@
+import type * as Vite from "vite";
+export type ServerConnection = {
+    getServer(): Promise<Vite.ViteDevServer>;
+    getRootPath(): string;
+    close(): Promise<void>;
+};

package/dist/domains/server/connection.js

@@ -0,0 +1 @@
+export {};

package/dist/domains/server/created.connection.d.ts

@@ -0,0 +1,10 @@
+import * as Vite from "vite";
+import type { RuntimeViteConfig } from "../../types.js";
+import type { ServerConnection } from "./connection.js";
+export declare class CreatedServerConnection implements ServerConnection {
+    #private;
+    constructor(config: RuntimeViteConfig);
+    getServer(): Promise<Vite.ViteDevServer>;
+    getRootPath(): string;
+    close(): Promise<void>;
+}

package/dist/domains/server/created.connection.js

@@ -0,0 +1,21 @@
+import * as Vite from "vite";
+import { makeServerConfig } from "./config.js";
+export class CreatedServerConnection {
+    #config;
+    #server;
+    constructor(config) {
+        this.#config = config;
+    }
+    async getServer() {
+        this.#server ??= await Vite.createServer(makeServerConfig(this.#config));
+        return this.#server;
+    }
+    getRootPath() {
+        return this.#config.root;
+    }
+    async close() {
+        const server = this.#server;
+        this.#server = undefined;
+        await server?.close();
+    }
+}

package/dist/domains/server/existing.connection.d.ts

@@ -0,0 +1,9 @@
+import type * as Vite from "vite";
+import type { ServerConnection } from "./connection.js";
+export declare class ExistingServerConnection implements ServerConnection {
+    #private;
+    constructor(server: Vite.ViteDevServer);
+    getServer(): Promise<Vite.ViteDevServer>;
+    getRootPath(): string;
+    close(): Promise<void>;
+}

package/dist/domains/server/existing.connection.js

@@ -0,0 +1,13 @@
+export class ExistingServerConnection {
+    #server;
+    constructor(server) {
+        this.#server = server;
+    }
+    async getServer() {
+        return this.#server;
+    }
+    getRootPath() {
+        return this.#server.config.root;
+    }
+    async close() { }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createRuntimeService } from "./domains/runtime/factory.js";
+export { RuntimeServiceBuilder } from "./domains/runtime/builder.js";
+export { RuntimeService } from "./domains/runtime/service.js";
+export type { Options, RuntimeViteConfig } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createRuntimeService } from "./domains/runtime/factory.js";
+export { RuntimeServiceBuilder } from "./domains/runtime/builder.js";
+export { RuntimeService } from "./domains/runtime/service.js";

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import type * as SiteIndex from "@site-index/core";
+import type * as Vite from "vite";
+export type Options = Pick<SiteIndex.Options, "siteUrl" | "extensions">;
+export type RuntimeViteConfig = {
+    root: Vite.ResolvedConfig["root"];
+    mode: Vite.ResolvedConfig["mode"];
+    configFile?: Vite.ResolvedConfig["configFile"];
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@site-index/vite-runtime",
+  "version": "0.1.0",
+  "description": "Vite-backed runtime for executing site-index pipelines.",
+  "keywords": [
+    "site-index",
+    "sitemap",
+    "robots",
+    "seo",
+    "vite"
+  ],
+  "homepage": "https://github.com/Deasilsoft/site-index/tree/main/packages/@site-index/vite-runtime",
+  "bugs": {
+    "url": "https://github.com/Deasilsoft/site-index/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deasilsoft/site-index.git",
+    "directory": "packages/@site-index/vite-runtime"
+  },
+  "license": "MIT",
+  "author": "Deasilsoft <contact@deasilsoft.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist coverage",
+    "prepack": "npm run clean && npm run build",
+    "pretest": "npm pack --dry-run",
+    "test": "vitest run --coverage",
+    "pretypecheck": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json"
+  },
+  "dependencies": {
+    "@site-index/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.6",
+    "vite": "^8.0.12",
+    "vitest": "^4.1.6"
+  },
+  "peerDependencies": {
+    "vite": "^8.0.10"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}