kennel 0.1.8

package/dist/publish/config.d.ts

@@ -0,0 +1,28 @@
+import type { ChildCommand } from '../shared/process.js';
+import type { PackageJson } from '../site/vitepress.js';
+import type { PublishOptions } from './options.js';
+export type DopplerTokenCommand = {
+    command: string;
+    args: string[];
+};
+export declare function publicationConfig(config: any): Record<string, any>;
+export declare function publicationDomains(config: any): Record<string, any>;
+export declare function publicationAccess(config: any): Record<string, any>;
+export declare function publicationAdminMcp(config: any): Record<string, any>;
+export declare function publishAuthDefaults(config: any): any;
+export declare function splitCsv(value: unknown): string[];
+export declare function publishAuthWithWranglerFallbacks(auth: any, vars: Record<string, unknown>): any;
+export declare function publishHostname(config: any, options: Pick<PublishOptions, 'hostname'>): string;
+export declare function publishHostnames(config: any, options: Pick<PublishOptions, 'hostname'>): string[];
+export declare function publishProjectName(config: any, root: string): string;
+export declare function publishWorkerName(config: any, root: string): string;
+export declare function publishCloudflareConfig(config: any): Record<string, any>;
+export declare function publishAccountId(config: any): string;
+export declare function publishDopplerTokenConfig(config: any): Record<string, any>;
+export declare function hasDopplerTokenConfig(config: any): boolean;
+export declare function dopplerTokenCommand(config: any): DopplerTokenCommand | null;
+export declare function publishBuildCommand(root: string, pkg: PackageJson): ChildCommand;
+export declare function publishWranglerCommand(root: string): string;
+export declare function publishWranglerArgs(root: string, args: string[]): string[];
+export declare function publishTestUrl(hostname: string): string;
+export declare function packageJsonPath(root: string): string;

package/dist/publish/config.js

@@ -0,0 +1,190 @@
+import { join } from 'node:path';
+import { isObject } from '../shared/object.js';
+import { localBin, packageManagerFor, runArgsFor } from '../shared/package-manager.js';
+import { normalizeHostname, slugifyHostname } from '../shared/path.js';
+export function publicationConfig(config) {
+    if (isObject(config.publication))
+        return config.publication;
+    if (isObject(config.publish))
+        return config.publish;
+    return {};
+}
+export function publicationDomains(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.domains))
+        return publication.domains;
+    return {};
+}
+export function publicationAccess(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.access))
+        return publication.access;
+    if (isObject(publication.auth))
+        return publication.auth;
+    return {};
+}
+export function publicationAdminMcp(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.adminMcp))
+        return publication.adminMcp;
+    if (isObject(publication.adminMCP))
+        return publication.adminMCP;
+    return {};
+}
+export function publishAuthDefaults(config) {
+    const existing = publicationAccess(config);
+    return {
+        mode: existing.mode ?? 'email-code-worker',
+        allowedDomains: Array.isArray(existing.allowedDomains) ? existing.allowedDomains : [],
+        allowedEmails: Array.isArray(existing.allowedEmails) ? existing.allowedEmails : [],
+        fromEmail: existing.fromEmail ?? '',
+        emailSubject: existing.emailSubject ?? 'Your sign-in code',
+    };
+}
+export function splitCsv(value) {
+    if (typeof value !== 'string')
+        return [];
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+export function publishAuthWithWranglerFallbacks(auth, vars) {
+    const allowedDomains = auth.allowedDomains.length > 0
+        ? auth.allowedDomains
+        : splitCsv(vars.KENNEL_AUTH_ALLOWED_DOMAINS ?? vars.CDP_AUTH_ALLOWED_DOMAINS);
+    const allowedEmails = auth.allowedEmails.length > 0
+        ? auth.allowedEmails
+        : splitCsv(vars.KENNEL_AUTH_ALLOWED_EMAILS ?? vars.CDP_AUTH_ALLOWED_EMAILS);
+    const fromEmail = auth.fromEmail
+        || vars.KENNEL_AUTH_FROM_EMAIL
+        || vars.CDP_AUTH_FROM_EMAIL
+        || '';
+    const emailSubject = auth.emailSubject
+        || vars.KENNEL_AUTH_EMAIL_SUBJECT
+        || vars.CDP_AUTH_EMAIL_SUBJECT
+        || 'Your sign-in code';
+    return {
+        ...auth,
+        allowedDomains,
+        allowedEmails,
+        fromEmail,
+        emailSubject,
+    };
+}
+export function publishHostname(config, options) {
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const hostname = options.hostname
+        || domains.primary
+        || publication.hostname
+        || publication.domain
+        || publication.url;
+    if (typeof hostname !== 'string' || hostname.trim() === '')
+        return '';
+    return normalizeHostname(hostname);
+}
+export function publishHostnames(config, options) {
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const adminMcp = publicationAdminMcp(config);
+    const candidates = [
+        publishHostname(config, options),
+        typeof adminMcp.hostname === 'string' ? adminMcp.hostname : undefined,
+        ...(Array.isArray(domains.aliases) ? domains.aliases : []),
+        ...(Array.isArray(domains.hostnames) ? domains.hostnames : []),
+        ...(Array.isArray(publication.hostnames) ? publication.hostnames : []),
+        ...(Array.isArray(publication.aliases) ? publication.aliases : []),
+    ];
+    return [...new Set(candidates.map(normalizeHostname).filter(Boolean))];
+}
+export function publishProjectName(config, root) {
+    const raw = config.name ?? config.project?.name ?? config.title ?? root.split('/').pop();
+    const slug = typeof raw === 'string' ? slugifyHostname(raw) : '';
+    return slug || 'kennel-docs';
+}
+export function publishWorkerName(config, root) {
+    const publication = publicationConfig(config);
+    if (typeof publication.workerName === 'string' && publication.workerName.trim())
+        return publication.workerName.trim();
+    return `${publishProjectName(config, root)}-gate`;
+}
+export function publishCloudflareConfig(config) {
+    const publication = publicationConfig(config);
+    return isObject(publication.cloudflare) ? publication.cloudflare : {};
+}
+export function publishAccountId(config) {
+    const publication = publicationConfig(config);
+    const cloudflare = publishCloudflareConfig(config);
+    if (typeof publication.accountId === 'string' && publication.accountId.trim())
+        return publication.accountId.trim();
+    if (typeof cloudflare.accountId === 'string' && cloudflare.accountId.trim())
+        return cloudflare.accountId.trim();
+    if (typeof process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID === 'string' && process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID.trim()) {
+        return process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID.trim();
+    }
+    if (typeof process.env.CLOUDFLARE_ACCOUNT_ID === 'string' && process.env.CLOUDFLARE_ACCOUNT_ID.trim()) {
+        return process.env.CLOUDFLARE_ACCOUNT_ID.trim();
+    }
+    return '';
+}
+export function publishDopplerTokenConfig(config) {
+    const cloudflare = publishCloudflareConfig(config);
+    if (isObject(cloudflare.token))
+        return cloudflare.token;
+    if (isObject(cloudflare.dopplerToken))
+        return cloudflare.dopplerToken;
+    return {};
+}
+export function hasDopplerTokenConfig(config) {
+    const token = publishDopplerTokenConfig(config);
+    return typeof token.secret === 'string' && token.secret.trim() !== '';
+}
+export function dopplerTokenCommand(config) {
+    const token = publishDopplerTokenConfig(config);
+    const secret = typeof token.secret === 'string' && token.secret.trim() ? token.secret.trim() : '';
+    if (!secret)
+        return null;
+    const args = ['secrets', 'get', secret];
+    if (typeof token.scope === 'string' && token.scope.trim())
+        args.push('--scope', token.scope.trim());
+    if (typeof token.project === 'string' && token.project.trim())
+        args.push('--project', token.project.trim());
+    if (typeof token.config === 'string' && token.config.trim())
+        args.push('--config', token.config.trim());
+    args.push('--plain', '--raw');
+    return { command: 'doppler', args };
+}
+export function publishBuildCommand(root, pkg) {
+    const scripts = pkg.scripts ?? {};
+    const packageManager = packageManagerFor(root);
+    if (typeof scripts['docs:build'] === 'string') {
+        return { command: packageManager, args: runArgsFor(packageManager, 'docs:build', []) };
+    }
+    if (typeof scripts.build === 'string') {
+        return { command: packageManager, args: runArgsFor(packageManager, 'build', []) };
+    }
+    const vitepress = localBin(root, 'vitepress');
+    if (vitepress)
+        return { command: vitepress, args: ['build', '.'] };
+    if (packageManager === 'npm')
+        return { command: packageManager, args: ['exec', '--', 'vitepress', 'build', '.'] };
+    return { command: packageManager, args: ['x', 'vitepress', 'build', '.'] };
+}
+export function publishWranglerCommand(root) {
+    const wrangler = localBin(root, 'wrangler');
+    if (wrangler)
+        return wrangler;
+    return 'npx';
+}
+export function publishWranglerArgs(root, args) {
+    return localBin(root, 'wrangler') ? args : ['wrangler', ...args];
+}
+export function publishTestUrl(hostname) {
+    if (!hostname)
+        return '';
+    return hostname.startsWith('http://') || hostname.startsWith('https://') ? hostname : `https://${hostname}`;
+}
+export function packageJsonPath(root) {
+    return join(root, 'package.json');
+}

package/dist/publish/options.d.ts

@@ -0,0 +1,13 @@
+export type PublishOptions = {
+    targetPath: string;
+    configFile: string;
+    force: boolean;
+    dryRun: boolean;
+    skipTest: boolean;
+    hostname: string;
+    testEmail: string;
+    deploy: boolean;
+    build: boolean;
+    useDopplerToken: boolean;
+};
+export declare function splitPublishArgs(input: string[]): PublishOptions;

package/dist/publish/options.js

@@ -0,0 +1,78 @@
+import { DEFAULT_PROJECT_CONFIG } from '../shared/project-config.js';
+export function splitPublishArgs(input) {
+    const options = {
+        targetPath: '.',
+        configFile: DEFAULT_PROJECT_CONFIG,
+        force: false,
+        dryRun: false,
+        skipTest: false,
+        hostname: '',
+        testEmail: '',
+        deploy: true,
+        build: true,
+        useDopplerToken: false,
+    };
+    const positional = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const arg = input[index];
+        if (arg === '--force') {
+            options.force = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === '--skip-test') {
+            options.skipTest = true;
+            continue;
+        }
+        if (arg === '--no-build') {
+            options.build = false;
+            continue;
+        }
+        if (arg === '--no-deploy') {
+            options.deploy = false;
+            continue;
+        }
+        if (arg === '--use-doppler-token') {
+            options.useDopplerToken = true;
+            continue;
+        }
+        if (arg === '--config') {
+            options.configFile = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--config=')) {
+            options.configFile = arg.slice('--config='.length);
+            continue;
+        }
+        if (arg === '--hostname') {
+            options.hostname = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--hostname=')) {
+            options.hostname = arg.slice('--hostname='.length);
+            continue;
+        }
+        if (arg === '--test-email') {
+            options.testEmail = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--test-email=')) {
+            options.testEmail = arg.slice('--test-email='.length);
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`Unknown publish option: ${arg}`);
+        positional.push(arg);
+    }
+    if (positional.length > 0)
+        options.targetPath = positional[0];
+    if (!options.configFile)
+        throw new Error('publish requires a config file name');
+    return options;
+}

package/dist/schema/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(targetPath: string): void;

package/dist/schema/doctor.js

@@ -0,0 +1,69 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { isObject } from '../shared/object.js';
+import { matchesDocumentSpec, matchesGlob, SCHEMA_FILES } from './documents.js';
+import { cachedSchemaFor, candidateFiles, validateTarget } from './validation.js';
+export function doctor(targetPath) {
+    const target = resolve(targetPath);
+    const entry = cachedSchemaFor(target);
+    if (!entry)
+        throw new Error(`No ${SCHEMA_FILES.join(' or ')} found from ${target} upward`);
+    const config = entry.schema['x-kennel'];
+    const specs = entry.documentSpecs;
+    const candidates = candidateFiles(target);
+    if (entry.usingDefaultDocuments) {
+        const docsHere = candidates.filter((candidate) => dirname(candidate.filePath) === target);
+        const label = docsHere.length > 0
+            ? docsHere.map((candidate) => relative(target, candidate.filePath)).join(', ')
+            : 'client.yml or index.md';
+        console.log(`${docsHere.length > 0 ? 'ok' : 'missing'} ${label}`);
+    }
+    else {
+        for (const spec of specs) {
+            if (spec.path && !spec.path.includes('/')) {
+                const filePath = join(target, spec.path);
+                console.log(`${existsSync(filePath) && statSync(filePath).isFile() ? 'ok' : 'missing'} ${spec.path}`);
+            }
+            else {
+                const label = spec.path ?? spec.glob;
+                const matches = candidates.filter((candidate) => (matchesDocumentSpec(candidate.filePath, entry.schemaPath, spec)));
+                console.log(`${matches.length > 0 ? 'ok' : 'missing'} ${label}`);
+            }
+        }
+    }
+    if (isObject(config)) {
+        const requiredDirectories = Array.isArray(config.requiredDirectories) ? config.requiredDirectories : [];
+        for (const directoryName of requiredDirectories) {
+            if (typeof directoryName !== 'string')
+                continue;
+            const directoryPath = join(target, directoryName);
+            console.log(`${existsSync(directoryPath) && statSync(directoryPath).isDirectory() ? 'ok' : 'missing'} ${directoryName.replace(/\/?$/, '/')}`);
+        }
+        const requiredFiles = Array.isArray(config.requiredFiles) ? config.requiredFiles : [];
+        for (const fileName of requiredFiles) {
+            if (typeof fileName !== 'string')
+                continue;
+            const filePath = join(target, fileName);
+            console.log(`${existsSync(filePath) && statSync(filePath).isFile() ? 'ok' : 'missing'} ${fileName}`);
+        }
+        const directoryContents = Array.isArray(config.directoryContents) ? config.directoryContents : [];
+        for (const rule of directoryContents) {
+            if (!isObject(rule) || typeof rule.path !== 'string')
+                continue;
+            const directoryPath = join(target, rule.path);
+            const glob = typeof rule.glob === 'string' ? rule.glob : '*';
+            const minFiles = Number.isInteger(rule.minFiles) ? Number(rule.minFiles) : 1;
+            const label = `${rule.path.replace(/\/?$/, '/')} ${glob}`;
+            const fileCount = existsSync(directoryPath) && statSync(directoryPath).isDirectory()
+                ? readdirSync(directoryPath, { withFileTypes: true })
+                    .filter((item) => item.isFile() && matchesGlob(item.name, glob))
+                    .length
+                : 0;
+            console.log(`${fileCount >= minFiles ? 'ok' : 'missing'} ${label} (${fileCount}/${minFiles})`);
+        }
+    }
+    const docsHere = candidates.filter((candidate) => dirname(candidate.filePath) === target);
+    for (const candidate of docsHere) {
+        validateTarget(candidate.filePath);
+    }
+}

package/dist/schema/documents.d.ts

@@ -0,0 +1,18 @@
+import type { DocumentConfig, DocumentSpec, ParserName } from './types.js';
+export declare const SCHEMA_FILES: readonly ["schema.json", "_schema.json"];
+export declare const DEFAULT_DOCUMENTS: DocumentSpec[];
+export declare const IGNORED_DIRECTORIES: Set<string>;
+export declare function findNearestSchema(startPath: string): string | null;
+export declare function loadSchemaFor(targetPath: string): {
+    schemaPath: string;
+    schema: any;
+};
+export declare function parseMarkdownFrontmatter(content: string, filePath: string): any;
+export declare function parseDocument(filePath: string, parser?: ParserName): any;
+export declare function schemaRoot(schemaPath: string): string;
+export declare function parserForPath(filePath: string): ParserName;
+export declare function normalizeDocumentSpec(spec: unknown): DocumentSpec;
+export declare function documentConfig(schema: any): DocumentConfig;
+export declare function globToRegex(glob: string): RegExp;
+export declare function matchesDocumentSpec(filePath: string, schemaPath: string, spec: DocumentSpec): boolean;
+export declare function matchesGlob(name: string, glob: string): boolean;

package/dist/schema/documents.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import YAML from 'yaml';
+import { isObject } from '../shared/object.js';
+export const SCHEMA_FILES = ['schema.json', '_schema.json'];
+export const DEFAULT_DOCUMENTS = [
+    { path: 'client.yml', glob: null, parser: 'yaml' },
+    { path: 'index.md', glob: null, parser: 'markdown-frontmatter' },
+];
+export const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules']);
+export function findNearestSchema(startPath) {
+    let current = resolve(startPath);
+    if (existsSync(current) && statSync(current).isFile())
+        current = dirname(current);
+    while (true) {
+        for (const schemaFile of SCHEMA_FILES) {
+            const schemaPath = join(current, schemaFile);
+            if (existsSync(schemaPath))
+                return schemaPath;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export function loadSchemaFor(targetPath) {
+    const schemaPath = findNearestSchema(targetPath);
+    if (!schemaPath) {
+        throw new Error(`No ${SCHEMA_FILES.join(' or ')} found from ${resolve(targetPath)} upward`);
+    }
+    return {
+        schemaPath,
+        schema: JSON.parse(readFileSync(schemaPath, 'utf8')),
+    };
+}
+export function parseMarkdownFrontmatter(content, filePath) {
+    if (!content.startsWith('---\n')) {
+        throw new Error(`${filePath} is missing YAML frontmatter`);
+    }
+    const end = content.indexOf('\n---', 4);
+    if (end === -1) {
+        throw new Error(`${filePath} has unterminated YAML frontmatter`);
+    }
+    const frontmatter = YAML.parse(content.slice(4, end));
+    if (!isObject(frontmatter)) {
+        throw new Error(`${filePath} frontmatter must be a YAML object`);
+    }
+    return frontmatter;
+}
+export function parseDocument(filePath, parser = parserForPath(filePath)) {
+    const content = readFileSync(filePath, 'utf8');
+    if (parser === 'markdown-frontmatter')
+        return parseMarkdownFrontmatter(content, filePath);
+    if (parser !== 'yaml')
+        throw new Error(`Unsupported parser "${parser}" for ${filePath}`);
+    return YAML.parse(content);
+}
+export function schemaRoot(schemaPath) {
+    return dirname(schemaPath);
+}
+export function parserForPath(filePath) {
+    return filePath.endsWith('.md') ? 'markdown-frontmatter' : 'yaml';
+}
+export function normalizeDocumentSpec(spec) {
+    if (typeof spec === 'string') {
+        return { path: spec, glob: null, parser: parserForPath(spec) };
+    }
+    if (!isObject(spec)) {
+        throw new Error('x-kennel.documents entries must be strings or objects');
+    }
+    const path = typeof spec.path === 'string' ? spec.path : null;
+    const glob = typeof spec.glob === 'string' ? spec.glob : null;
+    if (!path && !glob)
+        throw new Error('x-kennel.documents object entries require path or glob');
+    return {
+        path,
+        glob,
+        parser: typeof spec.parser === 'string' ? spec.parser : parserForPath(path ?? glob ?? ''),
+    };
+}
+export function documentConfig(schema) {
+    const config = schema['x-kennel'];
+    if (isObject(config) && Array.isArray(config.documents)) {
+        return {
+            specs: config.documents.map(normalizeDocumentSpec),
+            usingDefault: false,
+        };
+    }
+    return {
+        specs: DEFAULT_DOCUMENTS.map(normalizeDocumentSpec),
+        usingDefault: true,
+    };
+}
+export function globToRegex(glob) {
+    let pattern = '^';
+    for (let index = 0; index < glob.length; index += 1) {
+        const char = glob[index];
+        if (char === '*') {
+            pattern += '.*';
+        }
+        else if ('\\^$+.?()|{}[]'.includes(char)) {
+            pattern += `\\${char}`;
+        }
+        else {
+            pattern += char;
+        }
+    }
+    return new RegExp(`${pattern}$`);
+}
+export function matchesDocumentSpec(filePath, schemaPath, spec) {
+    const relativeToSchema = relative(schemaRoot(schemaPath), filePath);
+    const fileName = relativeToSchema.split('/').pop() ?? '';
+    if (spec.path) {
+        return spec.path.includes('/')
+            ? relativeToSchema === spec.path
+            : fileName === spec.path;
+    }
+    if (spec.glob) {
+        const target = spec.glob.includes('/') ? relativeToSchema : fileName;
+        return globToRegex(spec.glob).test(target);
+    }
+    return false;
+}
+export function matchesGlob(name, glob) {
+    return globToRegex(glob).test(name);
+}

package/dist/schema/pointers.d.ts

@@ -0,0 +1,5 @@
+export declare function decodePointerSegment(segment: string): string;
+export declare function valuesAtPointer(value: any, pointer: unknown): any[];
+export declare function pointerHasMinItems(document: any, condition: any): boolean;
+export declare function pointerValueIn(document: any, condition: any): boolean;
+export declare function shouldApplyRule(document: any, rule: any): boolean;

package/dist/schema/pointers.js

@@ -0,0 +1,48 @@
+import { isObject } from '../shared/object.js';
+export function decodePointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function valuesAtPointer(value, pointer) {
+    if (pointer === '')
+        return [value];
+    if (typeof pointer !== 'string' || !pointer.startsWith('/'))
+        return [];
+    const segments = pointer.slice(1).split('/').map(decodePointerSegment);
+    function walk(current, index) {
+        if (index === segments.length)
+            return [current];
+        if (current === undefined || current === null)
+            return [];
+        const segment = segments[index];
+        if (segment === '*') {
+            if (Array.isArray(current))
+                return current.flatMap((item) => walk(item, index + 1));
+            if (isObject(current))
+                return Object.values(current).flatMap((item) => walk(item, index + 1));
+            return [];
+        }
+        return walk(current[segment], index + 1);
+    }
+    return walk(value, 0);
+}
+export function pointerHasMinItems(document, condition) {
+    const pointer = typeof condition === 'string' ? condition : condition?.pointer;
+    const minItems = typeof condition === 'object' && Number.isInteger(condition.minItems)
+        ? condition.minItems
+        : 1;
+    return valuesAtPointer(document, pointer).some((value) => Array.isArray(value) && value.length >= minItems);
+}
+export function pointerValueIn(document, condition) {
+    if (!isObject(condition) || typeof condition.pointer !== 'string' || !Array.isArray(condition.values))
+        return false;
+    return valuesAtPointer(document, condition.pointer).some((value) => condition.values.includes(value));
+}
+export function shouldApplyRule(document, rule) {
+    if (rule.whenPointerMinItems !== undefined && !pointerHasMinItems(document, rule.whenPointerMinItems)) {
+        return false;
+    }
+    if (rule.whenPointerIn !== undefined && !pointerValueIn(document, rule.whenPointerIn)) {
+        return false;
+    }
+    return true;
+}

package/dist/schema/types.d.ts

@@ -0,0 +1,36 @@
+export type ParserName = 'yaml' | 'markdown-frontmatter' | string;
+export type DocumentSpec = {
+    path: string | null;
+    glob: string | null;
+    parser: ParserName;
+};
+export type DocumentConfig = {
+    specs: DocumentSpec[];
+    usingDefault: boolean;
+};
+export type KennelError = {
+    instancePath?: string;
+    message?: string;
+};
+export type Validator = {
+    (document: unknown): boolean;
+    errors?: KennelError[] | null;
+};
+export type SchemaEntry = {
+    schemaPath: string;
+    schema: any;
+    validate: Validator;
+    documentSpecs: DocumentSpec[];
+    usingDefaultDocuments: boolean;
+};
+export type CandidateFile = {
+    filePath: string;
+    schemaEntry: SchemaEntry;
+    parser: ParserName;
+};
+export type ValidationResult = {
+    filePath: string;
+    schemaPath: string;
+    valid: boolean;
+    errors: KennelError[];
+};

package/dist/schema/types.js

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

package/dist/schema/validation.d.ts

@@ -0,0 +1,8 @@
+import type { CandidateFile, KennelError, ParserName, SchemaEntry, ValidationResult, Validator } from './types.js';
+export declare function createAjv(schema: any): Validator;
+export declare function cachedSchemaFor(targetPath: string): SchemaEntry | null;
+export declare function validateFile(filePath: string, schemaPath: string, schema: any, validate: Validator, parser?: ParserName): ValidationResult;
+export declare function validateKennelRequirements(filePath: string, schema: any, document: any): KennelError[];
+export declare function candidateFiles(targetPath: string): CandidateFile[];
+export declare function validateTarget(targetPath: string): boolean;
+export declare function schemaFor(targetPath: string): void;