@gobing-ai/ts-rule-engine 0.2.1

package/src/evaluators/agent-detection-evaluator.ts

@@ -0,0 +1,37 @@
+import { AgentDetector, type AgentName, isAgentName } from '@gobing-ai/ts-ai-runner';
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+
+/** Evaluates local availability of configured coding agents. */
+export class AgentDetectionEvaluator implements RuleEvaluator {
+    constructor(private readonly detector = new AgentDetector()) {}
+
+    /** Probe required agents and emit findings for missing CLIs. */
+    async evaluate(rule: ConstraintRule, _context: RuleContext): Promise<RuleEvaluationResult> {
+        const agents = arrayConfig(rule.evaluator.config ?? {}, 'agents');
+        const findings = [];
+        for (const agent of agents) {
+            if (!isAgentName(agent)) {
+                findings.push(createFinding(rule, `Unknown agent: ${agent}`, null, { code: 'agent:unknown' }));
+                continue;
+            }
+            const detected = await this.detector.detectOne(agent as AgentName);
+            if (!detected.installed) {
+                findings.push(createFinding(rule, `Agent unavailable: ${agent}`, null, { code: 'agent:missing' }));
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+
+function arrayConfig(config: Record<string, unknown>, key: string): string[] {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
+    if (typeof value === 'string') return [value];
+    throw new Error(`agent-detection evaluator requires string[] config "${key}"`);
+}

package/src/evaluators/exit-code-evaluator.ts

@@ -0,0 +1,42 @@
+import { NodeProcessExecutor, type ProcessExecutor } from '@gobing-ai/ts-runtime';
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+
+/** Evaluates a rule by running a subprocess and checking its exit code. */
+export class ExitCodeEvaluator implements RuleEvaluator {
+    constructor(private readonly executor: ProcessExecutor = new NodeProcessExecutor()) {}
+
+    /** Run configured command and emit a finding on non-zero exit. */
+    async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
+        const config = rule.evaluator.config ?? {};
+        const command = stringConfig(config, 'command');
+        const args = arrayConfig(config, 'args', []);
+        const result = await this.executor.run({ command, args, cwd: context.workdir, rejectOnError: false });
+        if (result.exitCode === 0) return { findings: [], fixes: [] };
+        return {
+            findings: [
+                createFinding(rule, `Command failed: ${command} ${args.join(' ')}`.trim(), null, {
+                    code: 'exit-code:failed',
+                }),
+            ],
+            fixes: [],
+        };
+    }
+}
+
+function stringConfig(config: Record<string, unknown>, key: string): string {
+    const value = config[key];
+    if (typeof value === 'string') return value;
+    throw new Error(`exit-code evaluator requires string config "${key}"`);
+}
+
+function arrayConfig(config: Record<string, unknown>, key: string, fallback: string[]): string[] {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
+    return fallback;
+}

package/src/evaluators/file-utils.ts

@@ -0,0 +1,55 @@
+import { dirname, relative, resolve } from 'node:path';
+import { type FileSystem, NodeFileSystem, walkDir } from '@gobing-ai/ts-runtime';
+
+/** Options for source-file discovery. */
+export interface SourceDiscoveryOptions {
+    /** Working directory. */
+    workdir: string;
+    /** Include path fragments or suffixes. */
+    include?: string[];
+    /** Exclude path fragments. */
+    exclude?: string[];
+    /** Filesystem adapter. */
+    fs?: FileSystem;
+}
+
+const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', '.coverage', '.astro', '.wrangler']);
+
+/** Resolve source files for evaluators using conservative path-fragment matching. */
+export async function discoverFiles(options: SourceDiscoveryOptions): Promise<string[]> {
+    const fs = options.fs ?? new NodeFileSystem();
+    const allFiles = await walkDir(options.workdir, fs);
+    return allFiles
+        .map((path) => relative(options.workdir, path))
+        .filter((path) => !path.split('/').some((segment) => DEFAULT_EXCLUDES.has(segment)))
+        .filter(
+            (path) =>
+                matchesAny(path, options.include) &&
+                (options.exclude === undefined || !matchesAny(path, options.exclude)),
+        );
+}
+
+/** Read a file from a workdir-relative path. */
+export async function readWorkdirFile(workdir: string, filePath: string, fs = new NodeFileSystem()): Promise<string> {
+    return await fs.readFile(resolve(workdir, filePath));
+}
+
+/** Ensure a path is workdir-relative for findings. */
+export function relativeToWorkdir(workdir: string, path: string): string {
+    return relative(workdir, resolve(path));
+}
+
+/** Return parent directory for a workdir-relative path. */
+export function relativeParent(path: string): string {
+    const parent = dirname(path);
+    return parent === '.' ? '' : parent;
+}
+
+/** Return true when a path matches any supplied fragment or suffix. */
+export function matchesAny(path: string, patterns: string[] | undefined): boolean {
+    if (patterns === undefined || patterns.length === 0) return true;
+    return patterns.some((pattern) => {
+        const clean = pattern.replaceAll('\\', '/').replaceAll('**/', '').replaceAll('*', '');
+        return clean.length === 0 || path.includes(clean) || path.endsWith(clean);
+    });
+}

package/src/evaluators/forbidden-import-evaluator.ts

@@ -0,0 +1,50 @@
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+import { discoverFiles, readWorkdirFile } from './file-utils';
+
+/** Detects imports matching forbidden package or path prefixes. */
+export class ForbiddenImportEvaluator implements RuleEvaluator {
+    constructor() {}
+
+    /** Evaluate import declarations against configured forbidden prefixes. */
+    async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
+        const config = rule.evaluator.config ?? {};
+        const forbidden = arrayConfig(config, 'patterns');
+        const files = await discoverFiles({
+            workdir: context.workdir,
+            include: rule.include ?? ['.ts', '.tsx', '.js', '.jsx'],
+            exclude: rule.exclude,
+        });
+        const findings = [];
+        for (const file of files) {
+            const lines = (await readWorkdirFile(context.workdir, file)).split('\n');
+            for (const [index, line] of lines.entries()) {
+                const imported = /(?:from\s+|import\s*\(|^\s*import\s*)['"](?<specifier>[^'"]+)['"]/.exec(line)?.groups
+                    ?.specifier;
+                if (imported === undefined) continue;
+                const matched = forbidden.find((pattern) => imported.includes(pattern));
+                if (matched !== undefined) {
+                    findings.push(
+                        createFinding(rule, `Forbidden import "${imported}" matched "${matched}"`, file, {
+                            line: index + 1,
+                            code: 'import:forbidden',
+                        }),
+                    );
+                }
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+
+function arrayConfig(config: Record<string, unknown>, key: string): string[] {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
+    if (typeof value === 'string') return [value];
+    throw new Error(`forbidden-import evaluator requires string[] config "${key}"`);
+}

package/src/evaluators/path-evaluator.ts

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+
+/** Evaluates file or directory existence constraints. */
+export class PathEvaluator implements RuleEvaluator {
+    private readonly fs: NodeFileSystem;
+
+    constructor() {
+        this.fs = new NodeFileSystem();
+    }
+
+    /** Evaluate required or forbidden paths. */
+    async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
+        const config = rule.evaluator.config ?? {};
+        const paths = arrayConfig(config, 'paths');
+        const mode = stringConfig(config, 'mode', 'require');
+        const findings = [];
+        for (const path of paths) {
+            const exists = await this.fs.exists(resolve(context.workdir, path));
+            if (mode === 'forbid' && exists) {
+                findings.push(createFinding(rule, `Forbidden path exists: ${path}`, path, { code: 'path:forbidden' }));
+            }
+            if (mode !== 'forbid' && !exists) {
+                findings.push(createFinding(rule, `Required path missing: ${path}`, path, { code: 'path:missing' }));
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+
+function arrayConfig(config: Record<string, unknown>, key: string): string[] {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string')) return value;
+    if (typeof value === 'string') return [value];
+    throw new Error(`path evaluator requires string[] config "${key}"`);
+}
+
+function stringConfig(config: Record<string, unknown>, key: string, fallback: string): string {
+    const value = config[key];
+    return typeof value === 'string' ? value : fallback;
+}

package/src/evaluators/regex-evaluator.ts

@@ -0,0 +1,49 @@
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+import { discoverFiles, readWorkdirFile } from './file-utils';
+
+/** Evaluates whether source files match or avoid a regex pattern. */
+export class RegexEvaluator implements RuleEvaluator {
+    constructor() {}
+
+    /** Evaluate regex-based presence or absence constraints. */
+    async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
+        const config = rule.evaluator.config ?? {};
+        const pattern = stringConfig(config, 'pattern');
+        const mode = stringConfig(config, 'mode', 'forbid');
+        const flags = stringConfig(config, 'flags', 'm');
+        const regex = new RegExp(pattern, flags);
+        const files = await discoverFiles({ workdir: context.workdir, include: rule.include, exclude: rule.exclude });
+        const findings = [];
+
+        for (const file of files) {
+            const content = await readWorkdirFile(context.workdir, file);
+            regex.lastIndex = 0;
+            const match = regex.exec(content);
+            if (mode === 'require' && match === null) {
+                findings.push(
+                    createFinding(rule, `Required pattern not found: ${pattern}`, file, { code: 'regex:missing' }),
+                );
+            }
+            if (mode !== 'require' && match !== null) {
+                findings.push(
+                    createFinding(rule, `Forbidden pattern found: ${pattern}`, file, { code: 'regex:found' }),
+                );
+            }
+        }
+
+        return { findings, fixes: [] };
+    }
+}
+
+function stringConfig(config: Record<string, unknown>, key: string, fallback?: string): string {
+    const value = config[key];
+    if (typeof value === 'string') return value;
+    if (fallback !== undefined) return fallback;
+    throw new Error(`regex evaluator requires string config "${key}"`);
+}

package/src/evaluators/secrets-scanner-evaluator.ts

@@ -0,0 +1,34 @@
+import {
+    type ConstraintRule,
+    createFinding,
+    type RuleContext,
+    type RuleEvaluationResult,
+    type RuleEvaluator,
+} from '../types';
+import { discoverFiles, readWorkdirFile } from './file-utils';
+
+/** Scans text files for high-confidence secret-like tokens. */
+export class SecretsScannerEvaluator implements RuleEvaluator {
+    constructor() {}
+
+    /** Evaluate source files against bundled secret patterns. */
+    async evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult> {
+        const files = await discoverFiles({ workdir: context.workdir, include: rule.include, exclude: rule.exclude });
+        const findings = [];
+        const secretPattern = /(sk-[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|BEGIN (?:RSA |OPENSSH )?PRIVATE KEY)/;
+        for (const file of files) {
+            const lines = (await readWorkdirFile(context.workdir, file)).split('\n');
+            for (const [index, line] of lines.entries()) {
+                if (secretPattern.test(line)) {
+                    findings.push(
+                        createFinding(rule, 'Potential secret token found', file, {
+                            line: index + 1,
+                            code: 'secret:token',
+                        }),
+                    );
+                }
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}

package/src/formatters/json.ts

@@ -0,0 +1,11 @@
+import type { ResultFormatter, RuleEngineResult } from '../types';
+
+/** JSON formatter for rule-engine results. */
+export class JsonFormatter implements ResultFormatter {
+    constructor() {}
+
+    /** Format the full result as pretty JSON. */
+    format(result: RuleEngineResult): string {
+        return JSON.stringify(result, null, 2);
+    }
+}

package/src/formatters/text.ts

@@ -0,0 +1,20 @@
+import type { ResultFormatter, RuleEngineResult } from '../types';
+
+/** Text formatter for human CLI output. */
+export class TextFormatter implements ResultFormatter {
+    constructor() {}
+
+    /** Format findings as concise path-prefixed lines. */
+    format(result: RuleEngineResult): string {
+        if (result.findings.length === 0) return 'No rule findings.';
+        return result.findings
+            .map((finding) => {
+                const location =
+                    finding.filePath === null
+                        ? '<workspace>'
+                        : `${finding.filePath}${finding.line ? `:${finding.line}` : ''}`;
+                return `${finding.severity.toUpperCase()} ${finding.ruleId} ${location} ${finding.message}`;
+            })
+            .join('\n');
+    }
+}

package/src/host/builtins.ts

@@ -0,0 +1,26 @@
+import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import { AgentDetectionEvaluator } from '../evaluators/agent-detection-evaluator';
+import { ExitCodeEvaluator } from '../evaluators/exit-code-evaluator';
+import { ForbiddenImportEvaluator } from '../evaluators/forbidden-import-evaluator';
+import { PathEvaluator } from '../evaluators/path-evaluator';
+import { RegexEvaluator } from '../evaluators/regex-evaluator';
+import { SecretsScannerEvaluator } from '../evaluators/secrets-scanner-evaluator';
+import { JsonFormatter } from '../formatters/json';
+import { TextFormatter } from '../formatters/text';
+import type { RuleEngineHost } from './rule-engine-host';
+
+/** Register bundled evaluators and formatters on a host. */
+export function registerBuiltins(host: RuleEngineHost, executor?: ProcessExecutor): void {
+    const regex = new RegexEvaluator();
+    const path = new PathEvaluator();
+    host.evaluators.register('regex', regex, 'builtin');
+    host.evaluators.register('rg', regex, 'builtin');
+    host.evaluators.register('path', path, 'builtin');
+    host.evaluators.register('file-exist', path, 'builtin');
+    host.evaluators.register('forbidden-import', new ForbiddenImportEvaluator(), 'builtin');
+    host.evaluators.register('exit-code', new ExitCodeEvaluator(executor), 'builtin');
+    host.evaluators.register('secrets-scanner', new SecretsScannerEvaluator(), 'builtin');
+    host.evaluators.register('agent-detection', new AgentDetectionEvaluator(), 'builtin');
+    host.formatters.register('text', new TextFormatter(), 'builtin');
+    host.formatters.register('json', new JsonFormatter(), 'builtin');
+}

package/src/host/capability-registry.ts

@@ -0,0 +1,41 @@
+/** Registry origin for a host capability. */
+export type CapabilityOrigin = 'builtin' | 'extension';
+
+/** Registry entry metadata. */
+export interface CapabilityEntry<TCapability> {
+    /** Capability implementation. */
+    capability: TCapability;
+    /** Registration origin. */
+    origin: CapabilityOrigin;
+}
+
+/** Typed registry used by the rule engine host. */
+export class CapabilityRegistry<TCapability> {
+    private readonly capabilities = new Map<string, CapabilityEntry<TCapability>>();
+
+    constructor(private readonly kind: string) {}
+
+    /** Register or replace a capability. */
+    register(name: string, capability: TCapability, origin: CapabilityOrigin = 'extension'): void {
+        this.capabilities.set(name, { capability, origin });
+    }
+
+    /** Return true when a capability exists. */
+    has(name: string): boolean {
+        return this.capabilities.has(name);
+    }
+
+    /** Get a registered capability or throw a clear error. */
+    get(name: string): TCapability {
+        const entry = this.capabilities.get(name);
+        if (entry === undefined) {
+            throw new Error(`Unknown ${this.kind}: ${name}`);
+        }
+        return entry.capability;
+    }
+
+    /** List registered capability names. */
+    list(): string[] {
+        return [...this.capabilities.keys()];
+    }
+}

package/src/host/rule-engine-host.ts

@@ -0,0 +1,15 @@
+import type { ResultFormatter, RuleEvaluator } from '../types';
+import { CapabilityRegistry } from './capability-registry';
+
+/** Host container for rule-engine capabilities. */
+export class RuleEngineHost {
+    /** Evaluator registry keyed by evaluator type. */
+    readonly evaluators: CapabilityRegistry<RuleEvaluator>;
+    /** Formatter registry keyed by formatter name. */
+    readonly formatters: CapabilityRegistry<ResultFormatter>;
+
+    constructor() {
+        this.evaluators = new CapabilityRegistry<RuleEvaluator>('evaluator');
+        this.formatters = new CapabilityRegistry<ResultFormatter>('formatter');
+    }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './config/loader';
+export * from './engine';
+export * from './formatters/json';
+export * from './formatters/text';
+export * from './host/capability-registry';
+export * from './host/rule-engine-host';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,197 @@
+import { z } from 'zod';
+
+/** Finding severity emitted by the rule engine. */
+export type RuleSeverity = 'error' | 'warning' | 'info';
+
+/** Fix authority level for candidate fixes. */
+export type FixMode = 'none' | 'suggest' | 'auto';
+
+/** Structured configuration for a rule evaluator. */
+export interface RuleEvaluatorConfig {
+    /** Evaluator type key registered in the host. */
+    type: string;
+    /** Evaluator-specific options. */
+    config?: Record<string, unknown>;
+}
+
+/** Constraint rule definition loaded from YAML or JSON. */
+export interface ConstraintRule {
+    /** Stable rule identifier. */
+    id: string;
+    /** Human-readable description. */
+    description: string;
+    /** Whether this rule is active. */
+    enabled: boolean;
+    /** Finding severity emitted by this rule. */
+    severity: RuleSeverity;
+    /** Evaluator configuration. */
+    evaluator: RuleEvaluatorConfig;
+    /** Optional include globs or paths. */
+    include?: string[];
+    /** Optional exclude globs or paths. */
+    exclude?: string[];
+    /** Optional fix metadata. */
+    fix?: RuleFixConfig;
+}
+
+/** Fix configuration authored on a rule. */
+export interface RuleFixConfig {
+    /** Maximum fix mode allowed by the rule. */
+    mode: FixMode;
+    /** Optional replacement text used by simple fixers. */
+    replacement?: string;
+    /** Optional fixer-specific parameters. */
+    params?: Record<string, unknown>;
+}
+
+/** Rule file shape before normalization. */
+export interface ConstraintRuleFile {
+    /** File-level default include patterns. */
+    include?: string[];
+    /** File-level default exclude patterns. */
+    exclude?: string[];
+    /** File-level default severity. */
+    severity?: RuleSeverity;
+    /** Rule definitions. */
+    rules: ConstraintRule[];
+}
+
+/** Preset definition that composes category folders or other presets. */
+export interface PresetDefinition {
+    /** Preset name. */
+    name: string;
+    /** Category folders or preset names to compose. */
+    extends: string[];
+    /** Rule IDs to disable. */
+    disable?: string[];
+    /** Per-rule overrides. */
+    overrides?: Record<string, { fix?: { mode: FixMode } }>;
+}
+
+/** Candidate fix emitted by an evaluator or fixer. */
+export interface Fix {
+    /** Rule that produced this fix. */
+    ruleId: string;
+    /** Relative or absolute target file path. */
+    filePath: string;
+    /** Byte start offset. */
+    start: number;
+    /** Byte end offset. */
+    end: number;
+    /** Replacement content. */
+    replacement: string;
+    /** Whether this fix may be applied automatically. */
+    mode: Exclude<FixMode, 'none'>;
+}
+
+/** Finding emitted by a constraint rule. */
+export interface ConstraintFinding {
+    /** Rule identifier. */
+    ruleId: string;
+    /** Finding severity. */
+    severity: RuleSeverity;
+    /** Finding message. */
+    message: string;
+    /** Relative or absolute path involved in the finding. */
+    filePath: string | null;
+    /** Optional one-based line number. */
+    line?: number;
+    /** Optional column number. */
+    column?: number;
+    /** Machine-readable evaluator/source code. */
+    code?: string;
+}
+
+/** Aggregate result returned by a rule evaluator. */
+export interface RuleEvaluationResult {
+    /** Findings emitted by the evaluator. */
+    findings: ConstraintFinding[];
+    /** Candidate fixes emitted by the evaluator. */
+    fixes: Fix[];
+}
+
+/** Context passed to evaluator implementations. */
+export interface RuleContext {
+    /** Working directory being evaluated. */
+    workdir: string;
+    /** Rule being evaluated. */
+    rule: ConstraintRule;
+}
+
+/** Evaluator implementation contract. */
+export interface RuleEvaluator {
+    /** Evaluate a rule against the supplied context. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+
+/** Formatter implementation contract. */
+export interface ResultFormatter {
+    /** Format an engine result for CLI or machine output. */
+    format(result: RuleEngineResult): string;
+}
+
+/** Engine-level evaluation result. */
+export interface RuleEngineResult {
+    /** Findings emitted by enabled rules. */
+    findings: ConstraintFinding[];
+    /** Candidate fixes emitted by enabled rules. */
+    fixes: Fix[];
+}
+
+/** Create a finding with inherited rule severity. */
+export function createFinding(
+    rule: ConstraintRule,
+    message: string,
+    filePath: string | null,
+    extras: Omit<Partial<ConstraintFinding>, 'ruleId' | 'severity' | 'message' | 'filePath'> = {},
+): ConstraintFinding {
+    return {
+        ruleId: rule.id,
+        severity: rule.severity,
+        message,
+        filePath,
+        ...extras,
+    };
+}
+
+/** Zod schema for rule fix configuration. */
+export const RuleFixConfigSchema = z
+    .object({
+        mode: z.enum(['none', 'suggest', 'auto']).default('none'),
+        replacement: z.string().optional(),
+        params: z.record(z.string(), z.unknown()).optional(),
+    })
+    .default({ mode: 'none' });
+
+/** Zod schema for a single constraint rule. */
+export const ConstraintRuleSchema = z.object({
+    id: z.string().min(1),
+    description: z.string().default(''),
+    enabled: z.boolean().default(true),
+    severity: z.enum(['error', 'warning', 'info']).default('error'),
+    evaluator: z.object({
+        type: z.string().min(1),
+        config: z.record(z.string(), z.unknown()).optional(),
+    }),
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+    fix: RuleFixConfigSchema.optional(),
+});
+
+/** Zod schema for a constraint rule file. */
+export const ConstraintRuleFileSchema = z.object({
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+    severity: z.enum(['error', 'warning', 'info']).optional(),
+    rules: z.array(ConstraintRuleSchema),
+});
+
+/** Zod schema for a preset definition. */
+export const PresetDefinitionSchema = z.object({
+    name: z.string().min(1),
+    extends: z.array(z.string()).default([]),
+    disable: z.array(z.string()).optional(),
+    overrides: z
+        .record(z.string(), z.object({ fix: z.object({ mode: z.enum(['none', 'suggest', 'auto']) }).optional() }))
+        .optional(),
+});