@site-index/core 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,158 @@
+# @site-index/core
+
+Deterministic site-index pipeline for config resolution, discovery, loading, validation, deduplication, and artifact generation.
+
+[Repository README](../../../README.md)
+
+## Install
+
+```bash
+npm install @site-index/core
+```
+
+Requirements:
+
+- Node.js `>=22`
+
+## When to use
+
+Use `@site-index/core` when you need programmatic control and can provide module loading yourself.
+
+## When not to use
+
+- Use [`site-index`](../../site-index/README.md) for CLI-driven workflows.
+- Use [`@site-index/vite-plugin`](../vite-plugin/README.md) for Vite projects.
+
+## Public exports
+
+```ts
+export { Artifact } from "./domains/artifacts/artifact.js";
+export type { LoadModule, Options } from "./domains/options/types.js";
+export type * from "./domains/site-indexes/types.js";
+export type { Warning, Result } from "./types.js";
+export { main } from "./main.js";
+```
+
+## Main API
+
+```ts
+main(options: Options): Promise<Result<Artifact[]>>
+```
+
+Options:
+
+```ts
+type Options = {
+  siteUrl: string;
+  rootPath: string;
+  extensions?: string[] | undefined;
+  loadModule: LoadModule;
+};
+```
+
+`LoadModule`:
+
+```ts
+type LoadModule = (module: Module) => Promise<ModuleExports>;
+```
+
+`Module`:
+
+```ts
+type Module = {
+  filePath: string;
+  importId: string;
+};
+```
+
+`ModuleExports`:
+
+```ts
+type ModuleExports = {
+  siteIndexes: SiteIndex[];
+};
+```
+
+## Site index type
+
+```ts
+type SiteIndex = {
+  url: `/${string}`;
+  lastModified?: string | undefined;
+  sitemap?: string | undefined;
+  index?: boolean | undefined;
+};
+```
+
+Validation rules:
+
+- `url` must start with `/`
+- `url` cannot contain query strings or fragments
+- `lastModified` is optional
+- `lastModified` must be an ISO date or an ISO datetime with offset
+- `sitemap` is optional
+- `sitemap` defaults to `pages`
+- `sitemap` must be lowercase and can include hyphens
+- `index` is optional
+- `index` defaults to `true`
+- `index: false` excludes the URL from sitemap artifacts and adds `Disallow: <path>` to `robots.txt`
+
+## Artifacts
+
+Generated:
+
+- `sitemap.xml`
+- `sitemap-<name>.xml`
+- `robots.txt`
+
+Artifact content types:
+
+- `.xml` -> `application/xml; charset=utf-8`
+- `.txt` -> `text/plain; charset=utf-8`
+
+## Pipeline behavior
+
+`main(...)`:
+
+- resolves options
+- discovers `*.site-index.*` modules
+- loads modules via caller-provided `loadModule`
+- validates module exports
+- resolves and deduplicates site index entries
+- sorts output deterministically
+- generates immutable artifacts
+- returns warnings for recoverable issues
+
+Warning categories include:
+
+- no modules found
+- failed module load
+- invalid module exports
+- duplicate URL entries
+
+## Example
+
+Example with a runtime that can import the discovered module files:
+
+```ts
+import { main } from "@site-index/core";
+import type { Module, ModuleExports } from "@site-index/core";
+
+const result = await main({
+  siteUrl: "https://example.com",
+  rootPath: process.cwd(),
+  extensions: [".mjs"],
+  loadModule: async (module: Module): Promise<ModuleExports> => {
+    const loaded = await import(module.filePath);
+
+    return loaded.default as ModuleExports;
+  },
+});
+```
+
+## Related packages
+
+- [`site-index`](../../site-index/README.md)
+- [`@site-index/vite-plugin`](../vite-plugin/README.md)
+- [`@site-index/vite-runtime`](../vite-runtime/README.md)
+- [`@site-index/observability`](../observability/README.md)

package/dist/domains/artifacts/artifact.d.ts

@@ -0,0 +1,16 @@
+declare const CONTENT_TYPE_BY_EXT: {
+    readonly ".xml": "application/xml; charset=utf-8";
+    readonly ".txt": "text/plain; charset=utf-8";
+};
+type FileExtension = keyof typeof CONTENT_TYPE_BY_EXT;
+type ContentType = (typeof CONTENT_TYPE_BY_EXT)[FileExtension];
+export declare class Artifact {
+    readonly filePath: string;
+    readonly content: string;
+    readonly contentType: ContentType;
+    constructor(input: {
+        filePath: string;
+        content: string;
+    });
+}
+export {};

package/dist/domains/artifacts/artifact.js

@@ -0,0 +1,20 @@
+const CONTENT_TYPE_BY_EXT = {
+    ".xml": "application/xml; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+};
+const FILE_EXTENSIONS = Object.keys(CONTENT_TYPE_BY_EXT);
+export class Artifact {
+    filePath;
+    content;
+    contentType;
+    constructor(input) {
+        const extension = FILE_EXTENSIONS.find((extension) => input.filePath.endsWith(extension));
+        if (!extension) {
+            throw new Error(`Unsupported artifact file extension: ${input.filePath}`);
+        }
+        this.filePath = input.filePath;
+        this.content = input.content;
+        this.contentType = CONTENT_TYPE_BY_EXT[extension];
+        Object.freeze(this);
+    }
+}

package/dist/domains/artifacts/make.artifacts.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedSiteIndex } from "../site-indexes/schemas/site-indexes.schema.js";
+import type { Artifact } from "./artifact.js";
+export declare function makeArtifacts(siteUrl: string, siteIndexes: ResolvedSiteIndex[]): Artifact[];

package/dist/domains/artifacts/make.artifacts.js

@@ -0,0 +1,26 @@
+import { makeRobotsArtifact } from "./robots.artifacts.js";
+import { makeSitemapArtifacts, makeSitemapIndexArtifact, } from "./sitemaps.artifacts.js";
+function makeSitemapGroups(siteIndexes) {
+    const sitemapGroups = new Map();
+    for (const siteIndex of siteIndexes) {
+        if (!siteIndex.index)
+            continue;
+        const sitemapGroup = sitemapGroups.get(siteIndex.sitemap);
+        if (sitemapGroup) {
+            sitemapGroup.push(siteIndex);
+        }
+        else {
+            sitemapGroups.set(siteIndex.sitemap, [siteIndex]);
+        }
+    }
+    return sitemapGroups;
+}
+export function makeArtifacts(siteUrl, siteIndexes) {
+    const sitemapGroups = makeSitemapGroups(siteIndexes);
+    const sitemapArtifacts = makeSitemapArtifacts(sitemapGroups, siteUrl);
+    return [
+        ...sitemapArtifacts,
+        makeSitemapIndexArtifact(sitemapArtifacts, siteUrl),
+        makeRobotsArtifact(siteIndexes, siteUrl),
+    ];
+}

package/dist/domains/artifacts/robots.artifacts.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedSiteIndex } from "../site-indexes/schemas/site-indexes.schema.js";
+import { Artifact } from "./artifact.js";
+export declare function makeRobotsArtifact(siteIndexes: ResolvedSiteIndex[], siteUrl: string): Artifact;

package/dist/domains/artifacts/robots.artifacts.js

@@ -0,0 +1,19 @@
+import { Artifact } from "./artifact.js";
+function renderRobotsTxt(siteUrl, disallowedPaths) {
+    const lines = ["User-agent: *"];
+    for (const path of disallowedPaths) {
+        lines.push(`Disallow: ${path}`);
+    }
+    lines.push(`Sitemap: ${siteUrl}/sitemap.xml`);
+    return lines.join("\n");
+}
+export function makeRobotsArtifact(siteIndexes, siteUrl) {
+    const disallowed = siteIndexes
+        .filter((siteIndex) => !siteIndex.index)
+        .map((siteIndex) => siteIndex.url)
+        .toSorted((a, b) => a.localeCompare(b));
+    return new Artifact({
+        filePath: "robots.txt",
+        content: renderRobotsTxt(siteUrl, disallowed),
+    });
+}

package/dist/domains/artifacts/sitemaps.artifacts.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedSiteIndex } from "../site-indexes/schemas/site-indexes.schema.js";
+import { Artifact } from "./artifact.js";
+export declare function makeSitemapArtifacts(sitemaps: Map<string, ResolvedSiteIndex[]>, siteUrl: string): Artifact[];
+export declare function makeSitemapIndexArtifact(sitemaps: Artifact[], siteUrl: string): Artifact;

package/dist/domains/artifacts/sitemaps.artifacts.js

@@ -0,0 +1,56 @@
+import { Artifact } from "./artifact.js";
+const XML_VERSION_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>';
+const SITEMAP_XML_NAMESPACE = "https://www.sitemaps.org/schemas/sitemap/0.9";
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function renderSitemapXml(siteIndexes, siteUrl) {
+    const lines = [
+        XML_VERSION_DECLARATION,
+        `<urlset xmlns="${SITEMAP_XML_NAMESPACE}">`,
+    ];
+    for (const siteIndex of siteIndexes) {
+        const loc = escapeXml(`${siteUrl}${siteIndex.url}`);
+        lines.push("  <url>", `    <loc>${loc}</loc>`);
+        if (siteIndex.lastModified) {
+            const lastmod = escapeXml(siteIndex.lastModified);
+            lines.push(`    <lastmod>${lastmod}</lastmod>`);
+        }
+        lines.push("  </url>");
+    }
+    lines.push("</urlset>");
+    return lines.join("\n");
+}
+export function makeSitemapArtifacts(sitemaps, siteUrl) {
+    const sortedSitemaps = [...sitemaps.entries()].toSorted(([a], [b]) => a.localeCompare(b));
+    return sortedSitemaps.map(([sitemap, siteIndexes]) => new Artifact({
+        filePath: `sitemap-${sitemap}.xml`,
+        content: renderSitemapXml(siteIndexes, siteUrl),
+    }));
+}
+function renderSitemapIndexXml(paths, siteUrl) {
+    const lines = [
+        XML_VERSION_DECLARATION,
+        `<sitemapindex xmlns="${SITEMAP_XML_NAMESPACE}">`,
+    ];
+    for (const path of paths) {
+        const loc = escapeXml(`${siteUrl}${path}`);
+        lines.push("  <sitemap>", `    <loc>${loc}</loc>`, "  </sitemap>");
+    }
+    lines.push("</sitemapindex>");
+    return lines.join("\n");
+}
+export function makeSitemapIndexArtifact(sitemaps, siteUrl) {
+    const paths = sitemaps
+        .map((artifact) => artifact.filePath)
+        .toSorted((a, b) => a.localeCompare(b));
+    return new Artifact({
+        filePath: "sitemap.xml",
+        content: renderSitemapIndexXml(paths, siteUrl),
+    });
+}

package/dist/domains/options/options.resolve.d.ts

@@ -0,0 +1,11 @@
+import { z as Zod } from "zod";
+import type { LoadModule, Options } from "./types.js";
+declare const OptionsSchema: Zod.ZodObject<{
+    siteUrl: Zod.ZodPipe<Zod.ZodURL, Zod.ZodTransform<string, string>>;
+    rootPath: Zod.ZodString;
+    extensions: Zod.ZodDefault<Zod.ZodOptional<Zod.ZodArray<Zod.ZodString>>>;
+    loadModule: Zod.ZodCustom<LoadModule, LoadModule>;
+}, Zod.core.$strip>;
+type Config = Zod.infer<typeof OptionsSchema>;
+export declare function resolveOptions(options: Options): Config;
+export {};

package/dist/domains/options/options.resolve.js

@@ -0,0 +1,15 @@
+import { z as Zod } from "zod";
+const OptionsSchema = Zod.object({
+    siteUrl: Zod.url({
+        protocol: /^https?$/,
+        hostname: Zod.regexes.domain,
+    }).transform((url) => url.trim().replace(/\/+$/, "")),
+    rootPath: Zod.string().trim().min(1),
+    extensions: Zod.array(Zod.string().regex(/^\.\w+$/))
+        .optional()
+        .default([".js", ".mjs", ".ts"]),
+    loadModule: Zod.custom((value) => typeof value === "function", "loadModule must be a function"),
+});
+export function resolveOptions(options) {
+    return OptionsSchema.parse(options);
+}

package/dist/domains/options/types.d.ts

@@ -0,0 +1,8 @@
+import type { Module, ModuleExports } from "../site-indexes/types.js";
+export type LoadModule = (module: Module) => Promise<ModuleExports>;
+export type Options = {
+    siteUrl: string;
+    rootPath: string;
+    extensions?: string[] | undefined;
+    loadModule: LoadModule;
+};

package/dist/domains/options/types.js

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

package/dist/domains/site-indexes/process/modules.discovery.d.ts

@@ -0,0 +1,2 @@
+import type { Module } from "../types.js";
+export declare function discoverModules(root: string, supportedExtensions: string[]): Promise<Module[]>;

package/dist/domains/site-indexes/process/modules.discovery.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { glob } from "tinyglobby";
+const IGNORED_PATHS = [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/coverage/**",
+    "**/.git/**",
+];
+function makeModule(root, filePath) {
+    const relativePath = path.relative(root, filePath);
+    const posixPath = relativePath.split(path.sep).join("/");
+    return {
+        filePath,
+        importId: `./${posixPath}`,
+    };
+}
+export async function discoverModules(root, supportedExtensions) {
+    const filePaths = await glob(supportedExtensions.map((extension) => `**/*.site-index${extension}`), {
+        cwd: root,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+        ignore: IGNORED_PATHS,
+    });
+    filePaths.sort((a, b) => a.localeCompare(b));
+    return filePaths.map((filePath) => makeModule(root, filePath));
+}

package/dist/domains/site-indexes/process/modules.load.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from "../../../types.js";
+import type { LoadModule } from "../../options/types.js";
+import type { LoadedModule, Module } from "../types.js";
+export declare function loadModules(modules: Module[], loadModule: LoadModule): Promise<Result<LoadedModule[]>>;

package/dist/domains/site-indexes/process/modules.load.js

@@ -0,0 +1,22 @@
+export async function loadModules(modules, loadModule) {
+    const data = [];
+    const warnings = [];
+    for (const module of modules) {
+        try {
+            const exports = await loadModule(module);
+            data.push({
+                importId: module.importId,
+                filePath: module.filePath,
+                siteIndexes: exports.siteIndexes,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push({
+                message: `Failed to load module "${module.filePath}" (${module.importId}): ${message}`,
+                filePath: module.filePath,
+            });
+        }
+    }
+    return { data, warnings };
+}

package/dist/domains/site-indexes/process/modules.resolve.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from "../../../types.js";
+import { type ResolvedModule } from "../schemas/modules.schema.js";
+import type { LoadedModule } from "../types.js";
+export declare function resolveModules(modules: LoadedModule[]): Result<ResolvedModule[]>;

package/dist/domains/site-indexes/process/modules.resolve.js

@@ -0,0 +1,17 @@
+import { ResolvedModuleSchema, } from "../schemas/modules.schema.js";
+export function resolveModules(modules) {
+    const data = [];
+    const warnings = [];
+    for (const module of modules) {
+        const resolved = ResolvedModuleSchema.safeParse(module);
+        if (!resolved.success) {
+            warnings.push({
+                message: `Invalid module: ${resolved.error.message}`,
+                filePath: module.filePath,
+            });
+            continue;
+        }
+        data.push(resolved.data);
+    }
+    return { data, warnings };
+}

package/dist/domains/site-indexes/process/site-indexes.resolve.d.ts

@@ -0,0 +1,5 @@
+import type { Result } from "../../../types.js";
+import type { ResolvedModule } from "../schemas/modules.schema.js";
+import type { ResolvedSiteIndex } from "../schemas/site-indexes.schema.js";
+import type { WithSource } from "../types.js";
+export declare function resolveSiteIndexes(modules: ResolvedModule[]): Result<WithSource<ResolvedSiteIndex>[]>;

package/dist/domains/site-indexes/process/site-indexes.resolve.js

@@ -0,0 +1,24 @@
+export function resolveSiteIndexes(modules) {
+    const data = new Map();
+    const warnings = [];
+    for (const module of modules) {
+        for (const siteIndex of module.siteIndexes) {
+            const duplicate = data.get(siteIndex.url);
+            if (duplicate) {
+                warnings.push({
+                    message: `Duplicate URL "${duplicate.url}" found in "${duplicate.filePath}"`,
+                    filePath: module.filePath,
+                });
+                continue;
+            }
+            data.set(siteIndex.url, {
+                ...siteIndex,
+                filePath: module.filePath,
+            });
+        }
+    }
+    return {
+        data: [...data.values()].toSorted((a, b) => a.sitemap.localeCompare(b.sitemap) || a.url.localeCompare(b.url)),
+        warnings,
+    };
+}

package/dist/domains/site-indexes/schemas/modules.schema.d.ts

@@ -0,0 +1,12 @@
+import { z as Zod } from "zod";
+export declare const ResolvedModuleSchema: Zod.ZodObject<{
+    filePath: Zod.ZodString;
+    importId: Zod.ZodString;
+    siteIndexes: Zod.ZodArray<Zod.ZodObject<{
+        url: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<`/${string}`, string>>;
+        lastModified: Zod.ZodOptional<Zod.ZodUnion<readonly [Zod.ZodISODate, Zod.ZodISODateTime]>>;
+        sitemap: Zod.ZodDefault<Zod.ZodString>;
+        index: Zod.ZodDefault<Zod.ZodBoolean>;
+    }, Zod.core.$strict>>;
+}, Zod.core.$strict>;
+export type ResolvedModule = Zod.infer<typeof ResolvedModuleSchema>;

package/dist/domains/site-indexes/schemas/modules.schema.js

@@ -0,0 +1,7 @@
+import { z as Zod } from "zod";
+import { SiteIndexSchema } from "./site-indexes.schema.js";
+export const ResolvedModuleSchema = Zod.strictObject({
+    filePath: Zod.string(),
+    importId: Zod.string(),
+    siteIndexes: Zod.array(SiteIndexSchema),
+});

package/dist/domains/site-indexes/schemas/site-indexes.schema.d.ts

@@ -0,0 +1,8 @@
+import { z as Zod } from "zod";
+export declare const SiteIndexSchema: Zod.ZodObject<{
+    url: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<`/${string}`, string>>;
+    lastModified: Zod.ZodOptional<Zod.ZodUnion<readonly [Zod.ZodISODate, Zod.ZodISODateTime]>>;
+    sitemap: Zod.ZodDefault<Zod.ZodString>;
+    index: Zod.ZodDefault<Zod.ZodBoolean>;
+}, Zod.core.$strict>;
+export type ResolvedSiteIndex = Zod.infer<typeof SiteIndexSchema>;

package/dist/domains/site-indexes/schemas/site-indexes.schema.js

@@ -0,0 +1,15 @@
+import { z as Zod } from "zod";
+const LastModifiedSchema = Zod.union([
+    Zod.iso.date(),
+    Zod.iso.datetime({ offset: true }),
+]);
+export const SiteIndexSchema = Zod.strictObject({
+    url: Zod.string()
+        .regex(/^\/[^?#]*$/, "Invalid url (must start with '/' and not contain query/fragment)")
+        .transform((path) => path),
+    lastModified: LastModifiedSchema.optional(),
+    sitemap: Zod.string()
+        .regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Invalid sitemap name (must be lowercase and can include hyphens)")
+        .default("pages"),
+    index: Zod.boolean().default(true),
+});

package/dist/domains/site-indexes/types.d.ts

@@ -0,0 +1,17 @@
+export type SiteIndex = {
+    url: `/${string}`;
+    lastModified?: string | undefined;
+    sitemap?: string | undefined;
+    index?: boolean | undefined;
+};
+export type WithSource<T> = T & {
+    filePath: string;
+};
+export type Module = {
+    filePath: string;
+    importId: string;
+};
+export type ModuleExports = {
+    siteIndexes: SiteIndex[];
+};
+export type LoadedModule = Module & ModuleExports;

package/dist/domains/site-indexes/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Artifact } from "./domains/artifacts/artifact.js";
+export type { LoadModule, Options } from "./domains/options/types.js";
+export type * from "./domains/site-indexes/types.js";
+export type { Warning, Result } from "./types.js";
+export { main } from "./main.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Artifact } from "./domains/artifacts/artifact.js";
+export { main } from "./main.js";

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+import type { Artifact } from "./domains/artifacts/artifact.js";
+import type { Options } from "./domains/options/types.js";
+import type { Result } from "./types.js";
+export declare function main(options: Options): Promise<Result<Artifact[]>>;

package/dist/main.js

@@ -0,0 +1,28 @@
+import { makeArtifacts } from "./domains/artifacts/make.artifacts.js";
+import { resolveOptions } from "./domains/options/options.resolve.js";
+import { discoverModules } from "./domains/site-indexes/process/modules.discovery.js";
+import { loadModules } from "./domains/site-indexes/process/modules.load.js";
+import { resolveModules } from "./domains/site-indexes/process/modules.resolve.js";
+import { resolveSiteIndexes } from "./domains/site-indexes/process/site-indexes.resolve.js";
+export async function main(options) {
+    const warnings = [];
+    const config = resolveOptions(options);
+    const modules = await discoverModules(config.rootPath, config.extensions);
+    if (modules.length === 0) {
+        warnings.push({
+            message: `No modules found in: ${config.rootPath}`,
+        });
+        return {
+            data: [],
+            warnings,
+        };
+    }
+    const loadedModules = await loadModules(modules, config.loadModule);
+    const resolvedModules = resolveModules(loadedModules.data);
+    const resolvedSiteIndexes = resolveSiteIndexes(resolvedModules.data);
+    warnings.push(...loadedModules.warnings, ...resolvedModules.warnings, ...resolvedSiteIndexes.warnings);
+    return {
+        data: makeArtifacts(config.siteUrl, resolvedSiteIndexes.data),
+        warnings,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+export type Warning = {
+    message: string;
+    filePath?: string | undefined;
+};
+export type Result<T> = {
+    data: T;
+    warnings: Warning[];
+};

package/dist/types.js

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

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@site-index/core",
+  "version": "0.1.0",
+  "description": "Deterministic site-index pipeline: config, discovery, loading, validation, and artifact generation.",
+  "keywords": [
+    "site-index",
+    "sitemap",
+    "robots",
+    "seo"
+  ],
+  "homepage": "https://github.com/Deasilsoft/site-index/tree/main/packages/@site-index/core",
+  "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/core"
+  },
+  "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": {
+    "tinyglobby": "^0.2.16",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.6",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}