@intellectronica/ruler 0.3.41 → 0.3.42

package/dist/core/ConfigLoader.d.ts

@@ -0,0 +1,57 @@
+import { McpConfig, GlobalMcpConfig, GitignoreConfig, BackupConfig, SkillsConfig, SubagentsConfig } from '../types';
+/** Test helper — re-arms the deprecation guard so suites can assert it fires. */
+export declare function _resetLegacySubagentsWarningForTests(): void;
+/**
+ * Configuration for a specific agent as defined in ruler.toml.
+ */
+export interface IAgentConfig {
+    enabled?: boolean;
+    outputPath?: string;
+    outputPathInstructions?: string;
+    outputPathConfig?: string;
+    /** MCP propagation config for this agent. */
+    mcp?: McpConfig;
+}
+/**
+ * Parsed ruler configuration values.
+ */
+export interface LoadedConfig {
+    /** Agents to run by default, as specified by default_agents. */
+    defaultAgents?: string[];
+    /** Per-agent configuration overrides. */
+    agentConfigs: Record<string, IAgentConfig>;
+    /** Command-line agent filters (--agents), if provided. */
+    cliAgents?: string[];
+    /** Global MCP servers configuration section. */
+    mcp?: GlobalMcpConfig;
+    /** Gitignore configuration section. */
+    gitignore?: GitignoreConfig;
+    /** Backup configuration section. */
+    backup?: BackupConfig;
+    /** Skills configuration section. */
+    skills?: SkillsConfig;
+    /** Subagents configuration section. */
+    subagents?: SubagentsConfig;
+    /** Whether to enable nested rule loading from nested .ruler directories. */
+    nested?: boolean;
+    /** Whether the nested option was explicitly provided in the config. */
+    nestedDefined?: boolean;
+}
+/**
+ * Options for loading the ruler configuration.
+ */
+export interface ConfigOptions {
+    projectRoot: string;
+    /** Path to a custom TOML config file. */
+    configPath?: string;
+    /** CLI filters from --agents option. */
+    cliAgents?: string[];
+    /** Whether implicit config discovery may fall back to XDG_CONFIG_HOME/ruler. */
+    checkGlobal?: boolean;
+}
+/**
+ * Loads and parses the ruler TOML configuration file, applying defaults.
+ * Missing implicit configs return defaults. Explicit configs and existing
+ * implicit configs fail fast when missing, unreadable, or invalid.
+ */
+export declare function loadConfig(options: ConfigOptions): Promise<LoadedConfig>;

package/dist/core/ConfigLoader.js

@@ -103,6 +103,11 @@ const rulerConfigSchema = zod_1.z.object({
         local: zod_1.z.boolean().optional(),
     })
         .optional(),
+    backup: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+    })
+        .optional(),
     skills: zod_1.z
         .object({
         enabled: zod_1.z.boolean().optional(),
@@ -144,48 +149,16 @@ function stripSymbols(obj) {
 }
 /**
  * Loads and parses the ruler TOML configuration file, applying defaults.
- * If the file is missing or invalid, returns empty/default config.
+ * Missing implicit configs return defaults. Explicit configs and existing
+ * implicit configs fail fast when missing, unreadable, or invalid.
  */
 async function loadConfig(options) {
     const { projectRoot, configPath, cliAgents } = options;
-    let configFile;
-    if (configPath) {
-        configFile = path.resolve(configPath);
-    }
-    else {
-        // Try local .ruler/ruler.toml first
-        const localConfigFile = path.join(projectRoot, '.ruler', 'ruler.toml');
-        try {
-            await fs_1.promises.access(localConfigFile);
-            configFile = localConfigFile;
-        }
-        catch {
-            // If local config doesn't exist, try global config
-            const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-            configFile = path.join(xdgConfigDir, 'ruler', 'ruler.toml');
-        }
-    }
-    let raw = {};
-    try {
-        const text = await fs_1.promises.readFile(configFile, 'utf8');
-        const parsed = text.trim() ? (0, toml_1.parse)(text) : {};
-        // Strip Symbol properties added by @iarna/toml (required for Zod v4+)
-        raw = stripSymbols(parsed);
-        // Validate the configuration with zod
-        const validationResult = rulerConfigSchema.safeParse(raw);
-        if (!validationResult.success) {
-            throw (0, constants_1.createRulerError)('Invalid configuration file format', `File: ${configFile}, Errors: ${validationResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ')}`);
-        }
-    }
-    catch (err) {
-        if (err instanceof Error && err.code !== 'ENOENT') {
-            if (err.message.includes('[ruler]')) {
-                throw err; // Re-throw validation errors
-            }
-            console.warn(`[ruler] Warning: could not read config file at ${configFile}: ${err.message}`);
-        }
-        raw = {};
-    }
+    const checkGlobal = options.checkGlobal ?? true;
+    const configFile = configPath
+        ? path.resolve(configPath)
+        : await resolveImplicitConfigFile(projectRoot, checkGlobal);
+    const raw = configFile ? await readConfigFile(configFile) : {};
     const defaultAgents = Array.isArray(raw.default_agents)
         ? raw.default_agents.map((a) => String(a))
         : undefined;
@@ -256,6 +229,13 @@ async function loadConfig(options) {
     if (typeof rawGitignoreSection.local === 'boolean') {
         gitignoreConfig.local = rawGitignoreSection.local;
     }
+    const rawBackupSection = raw.backup && typeof raw.backup === 'object' && !Array.isArray(raw.backup)
+        ? raw.backup
+        : {};
+    const backupConfig = {};
+    if (typeof rawBackupSection.enabled === 'boolean') {
+        backupConfig.enabled = rawBackupSection.enabled;
+    }
     const rawSkillsSection = raw.skills && typeof raw.skills === 'object' && !Array.isArray(raw.skills)
         ? raw.skills
         : {};
@@ -314,9 +294,96 @@ async function loadConfig(options) {
         cliAgents,
         mcp: globalMcpConfig,
         gitignore: gitignoreConfig,
+        backup: backupConfig,
         skills: skillsConfig,
         subagents: subagentsConfig,
         nested,
         nestedDefined,
     };
 }
+async function resolveImplicitConfigFile(projectRoot, checkGlobal) {
+    const localRulerDir = await findNearestLocalRulerDir(projectRoot);
+    const localConfigFile = localRulerDir
+        ? path.join(localRulerDir, 'ruler.toml')
+        : path.join(projectRoot, '.ruler', 'ruler.toml');
+    if (await configFileExists(localConfigFile)) {
+        return localConfigFile;
+    }
+    if (!checkGlobal) {
+        return undefined;
+    }
+    const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const globalConfigFile = path.join(xdgConfigDir, 'ruler', 'ruler.toml');
+    if (await configFileExists(globalConfigFile)) {
+        return globalConfigFile;
+    }
+    return undefined;
+}
+async function findNearestLocalRulerDir(startPath) {
+    let current = path.resolve(startPath);
+    while (current) {
+        const candidate = path.join(current, '.ruler');
+        try {
+            const stat = await fs_1.promises.stat(candidate);
+            if (stat.isDirectory()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Keep walking; missing or inaccessible candidates simply do not match.
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+    return undefined;
+}
+async function configFileExists(configFile) {
+    try {
+        await fs_1.promises.access(configFile);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return false;
+        }
+        throw (0, constants_1.createRulerError)('Could not access configuration file', `File: ${configFile}, Error: ${errorMessage(err)}`);
+    }
+}
+async function readConfigFile(configFile) {
+    const text = await readConfigText(configFile);
+    const parsed = parseConfigText(text, configFile);
+    const raw = stripSymbols(parsed);
+    validateConfig(raw, configFile);
+    return raw;
+}
+async function readConfigText(configFile) {
+    try {
+        return await fs_1.promises.readFile(configFile, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            throw (0, constants_1.createRulerError)('Configuration file not found', `File: ${configFile}`);
+        }
+        throw (0, constants_1.createRulerError)('Could not read configuration file', `File: ${configFile}, Error: ${errorMessage(err)}`);
+    }
+}
+function parseConfigText(text, configFile) {
+    try {
+        return text.trim() ? (0, toml_1.parse)(text) : {};
+    }
+    catch (err) {
+        throw (0, constants_1.createRulerError)('Invalid configuration file', `File: ${configFile}, Error: ${errorMessage(err)}`);
+    }
+}
+function validateConfig(raw, configFile) {
+    const validationResult = rulerConfigSchema.safeParse(raw);
+    if (!validationResult.success) {
+        throw (0, constants_1.createRulerError)('Invalid configuration file format', `File: ${configFile}, Errors: ${validationResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ')}`);
+    }
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/core/FileSystemUtils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Searches upwards from startPath to find a directory named .ruler.
+ * If not found locally and checkGlobal is true, checks for global config at XDG_CONFIG_HOME/ruler.
+ * Returns the path to the .ruler directory, or null if not found.
+ */
+export declare function findRulerDir(startPath: string, checkGlobal?: boolean): Promise<string | null>;
+/**
+ * Options for {@link readMarkdownFiles}.
+ */
+export interface ReadMarkdownFilesOptions {
+    /**
+     * When true, include `.ruler/agents/*.md` in the returned set so they are
+     * concatenated into the top-level generated rule files. When false or
+     * omitted, `.ruler/agents/` is skipped, mirroring `.ruler/skills/`.
+     */
+    includeAgents?: boolean;
+}
+/**
+ * Recursively reads all Markdown (.md) files in rulerDir, returning their paths and contents.
+ * Files are sorted alphabetically by path.
+ *
+ * `.ruler/skills/` is always skipped (skills are propagated separately).
+ * `.ruler/agents/` is skipped unless `options.includeAgents` is `true`.
+ */
+export declare function readMarkdownFiles(rulerDir: string, options?: ReadMarkdownFilesOptions): Promise<{
+    path: string;
+    content: string;
+}[]>;
+/**
+ * Writes content to filePath, creating parent directories if necessary.
+ */
+export declare function writeGeneratedFile(filePath: string, content: string): Promise<void>;
+/**
+ * Creates a backup of the given filePath by copying it to filePath.bak if it exists.
+ * Keeps an existing backup intact so repeated applies preserve the original file.
+ */
+export declare function backupFile(filePath: string): Promise<void>;
+/**
+ * Ensures that the given directory exists by creating it recursively.
+ */
+export declare function ensureDirExists(dirPath: string): Promise<void>;
+/**
+ * Finds the global ruler configuration directory at XDG_CONFIG_HOME/ruler.
+ * Returns the path if it exists, null otherwise.
+ */
+export declare function findGlobalRulerDir(): Promise<string | null>;
+/**
+ * Searches the entire directory tree from startPath to find all .ruler directories.
+ * Returns an array of .ruler directory paths from most specific to least specific.
+ */
+export declare function findAllRulerDirs(startPath: string): Promise<string[]>;

package/dist/core/FileSystemUtils.js

@@ -45,12 +45,27 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const constants_1 = require("../constants");
 const SUBAGENTS_DIR_NAME = path.basename(constants_1.RULER_SUBAGENTS_PATH);
+const DEFAULT_NESTED_DISCOVERY_IGNORES = new Set([
+    '__fixtures__',
+    '__generated__',
+    'build',
+    'coverage',
+    'dist',
+    'fixtures',
+    'generated',
+    'node_modules',
+    'temp',
+    'tmp',
+]);
 /**
  * Gets the XDG config directory path, falling back to ~/.config if XDG_CONFIG_HOME is not set.
  */
 function getXdgConfigDir() {
     return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
 }
+function shouldSkipNestedDiscoveryDir(dirName) {
+    return (dirName.startsWith('.') || DEFAULT_NESTED_DISCOVERY_IGNORES.has(dirName));
+}
 /**
  * Searches upwards from startPath to find a directory named .ruler.
  * If not found locally and checkGlobal is true, checks for global config at XDG_CONFIG_HOME/ruler.
@@ -222,11 +237,19 @@ async function writeGeneratedFile(filePath, content) {
 }
 /**
  * Creates a backup of the given filePath by copying it to filePath.bak if it exists.
+ * Keeps an existing backup intact so repeated applies preserve the original file.
  */
 async function backupFile(filePath) {
+    const backupPath = `${filePath}.bak`;
     try {
-        await fs_1.promises.access(filePath);
-        await fs_1.promises.copyFile(filePath, `${filePath}.bak`);
+        await fs_1.promises.access(backupPath);
+        return;
+    }
+    catch {
+        // continue if no backup exists yet
+    }
+    try {
+        await fs_1.promises.copyFile(filePath, backupPath);
     }
     catch {
         // ignore if file does not exist
@@ -272,23 +295,20 @@ async function findAllRulerDirs(startPath) {
                     if (entry.name === '.ruler') {
                         rulerDirs.push(fullPath);
                     }
-                    else {
-                        // Recursively search subdirectories (but skip hidden directories like .git)
-                        if (!entry.name.startsWith('.')) {
-                            // Do not cross git repository boundaries (except the starting root)
-                            const gitDir = path.join(fullPath, '.git');
-                            try {
-                                const gitStat = await fs_1.promises.stat(gitDir);
-                                if (gitStat.isDirectory() &&
-                                    path.resolve(fullPath) !== rootPath) {
-                                    continue;
-                                }
-                            }
-                            catch {
-                                // no .git boundary, continue traversal
+                    else if (!shouldSkipNestedDiscoveryDir(entry.name)) {
+                        // Do not cross git repository boundaries (except the starting root)
+                        const gitDir = path.join(fullPath, '.git');
+                        try {
+                            const gitStat = await fs_1.promises.stat(gitDir);
+                            if (gitStat.isDirectory() &&
+                                path.resolve(fullPath) !== rootPath) {
+                                continue;
                             }
-                            await findRulerDirs(fullPath);
                         }
+                        catch {
+                            // no .git boundary, continue traversal
+                        }
+                        await findRulerDirs(fullPath);
                     }
                 }
             }

package/dist/core/GitignoreUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Updates an ignore file in the project root with paths in a managed Ruler block.
+ * Creates the file if it doesn't exist, and creates or updates the Ruler-managed block.
+ *
+ * @param projectRoot The project root directory
+ * @param paths Array of file paths to add to the ignore file (can be absolute or relative)
+ * @param ignoreFile Relative path to the ignore file from project root (defaults to .gitignore)
+ */
+export declare function updateGitignore(projectRoot: string, paths: string[], ignoreFile?: string): Promise<void>;
+/**
+ * Resolves ignore files Ruler manages. Linked worktrees store `.git` as a
+ * file containing a `gitdir:` pointer, so `.git/info/exclude` must be resolved
+ * through that pointer.
+ */
+export declare function resolveIgnoreFilePath(projectRoot: string, ignoreFile: string): Promise<string>;

package/dist/core/GitignoreUtils.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateGitignore = updateGitignore;
+exports.resolveIgnoreFilePath = resolveIgnoreFilePath;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const RULER_START_MARKER = '# START Ruler Generated Files';
@@ -47,7 +48,7 @@ const RULER_END_MARKER = '# END Ruler Generated Files';
  * @param ignoreFile Relative path to the ignore file from project root (defaults to .gitignore)
  */
 async function updateGitignore(projectRoot, paths, ignoreFile = '.gitignore') {
-    const gitignorePath = path.join(projectRoot, ignoreFile);
+    const gitignorePath = await resolveIgnoreFilePath(projectRoot, ignoreFile);
     // Read existing .gitignore or start with empty content
     let existingContent = '';
     try {
@@ -101,6 +102,36 @@ async function updateGitignore(projectRoot, paths, ignoreFile = '.gitignore') {
     await fs_1.promises.mkdir(path.dirname(gitignorePath), { recursive: true });
     await fs_1.promises.writeFile(gitignorePath, newContent);
 }
+/**
+ * Resolves ignore files Ruler manages. Linked worktrees store `.git` as a
+ * file containing a `gitdir:` pointer, so `.git/info/exclude` must be resolved
+ * through that pointer.
+ */
+async function resolveIgnoreFilePath(projectRoot, ignoreFile) {
+    if (ignoreFile !== '.git/info/exclude') {
+        return path.join(projectRoot, ignoreFile);
+    }
+    const dotGitPath = path.join(projectRoot, '.git');
+    try {
+        const dotGitStat = await fs_1.promises.lstat(dotGitPath);
+        if (dotGitStat.isFile()) {
+            const dotGitContent = await fs_1.promises.readFile(dotGitPath, 'utf8');
+            const gitDirMatch = dotGitContent.match(/^gitdir:\s*(.+)\s*$/m);
+            if (gitDirMatch) {
+                const gitDir = gitDirMatch[1];
+                const resolvedGitDir = path.isAbsolute(gitDir)
+                    ? gitDir
+                    : path.resolve(projectRoot, gitDir);
+                return path.join(resolvedGitDir, 'info', 'exclude');
+            }
+        }
+    }
+    catch {
+        // Fall back to the historical project-root path for non-git test fixtures
+        // and unusual repositories where `.git` cannot be inspected.
+    }
+    return path.join(projectRoot, ignoreFile);
+}
 /**
  * Gets all paths from .gitignore content excluding those in the Ruler block.
  */

package/dist/core/RuleProcessor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Concatenates markdown rule files into a single string,
+ * marking each section with its source filename.
+ */
+export declare function concatenateRules(files: {
+    path: string;
+    content: string;
+}[], baseDir?: string): string;

package/dist/core/SkillsProcessor.d.ts

@@ -0,0 +1,127 @@
+import * as fs from 'fs/promises';
+import { SkillInfo } from '../types';
+import type { IAgent } from '../agents/IAgent';
+/**
+ * Discovers skills in the project's .ruler/skills directory.
+ * Returns discovered skills and any validation warnings.
+ */
+export declare function discoverSkills(projectRoot: string): Promise<{
+    skills: SkillInfo[];
+    warnings: string[];
+}>;
+/**
+ * Gets the paths that skills will generate, for gitignore purposes.
+ * Returns empty array if skills directory doesn't exist.
+ */
+export declare function getSkillsGitignorePaths(projectRoot: string, agents: IAgent[]): Promise<string[]>;
+type ReplaceSkillsFsOps = Pick<typeof fs, 'rename' | 'cp' | 'rm'>;
+export declare function replaceSkillsDirectory(tempDir: string, targetDir: string, fsOps?: ReplaceSkillsFsOps): Promise<void>;
+/**
+ * Propagates skills for agents that need them.
+ */
+export declare function propagateSkills(projectRoot: string, agents: IAgent[], skillsEnabled: boolean, verbose: boolean, dryRun: boolean): Promise<void>;
+/**
+ * Propagates skills for Claude Code by copying .ruler/skills to .claude/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForClaude(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for OpenAI Codex CLI by copying .ruler/skills to .codex/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForCodex(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for OpenCode by copying .ruler/skills to .opencode/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForOpenCode(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Pi Coding Agent by copying .ruler/skills to .pi/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForPi(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Goose by copying .ruler/skills to .agents/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForGoose(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Mistral Vibe by copying .ruler/skills to .vibe/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForVibe(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Roo Code by copying .ruler/skills to .roo/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForRoo(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Gemini CLI by copying .ruler/skills to .gemini/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForGemini(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Junie by copying .ruler/skills to .junie/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForJunie(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Cursor by copying .ruler/skills to .cursor/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForCursor(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Windsurf by copying .ruler/skills to .windsurf/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForWindsurf(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Factory Droid by copying .ruler/skills to .factory/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForFactory(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+/**
+ * Propagates skills for Antigravity by copying .ruler/skills to .agent/skills.
+ * Uses atomic replace to ensure safe overwriting of existing skills.
+ * Returns dry-run steps if dryRun is true, otherwise returns empty array.
+ */
+export declare function propagateSkillsForAntigravity(projectRoot: string, options: {
+    dryRun: boolean;
+}): Promise<string[]>;
+export {};