@omnidev-ai/core 0.9.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnidev-ai/core",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "type": "module",
   "license": "MIT",
   "repository": {

package/src/capability/index.ts

@@ -3,7 +3,7 @@ export { loadDocs } from "./docs";
 export { discoverCapabilities, loadCapability, loadCapabilityConfig } from "./loader";
 export type { CapabilityRegistry } from "./registry";
 export { buildCapabilityRegistry } from "./registry";
-export { loadRules, writeRules } from "./rules";
+export { loadRules } from "./rules";
 export { loadSkills } from "./skills";
 export {
 	fetchAllCapabilitySources,
@@ -15,6 +15,10 @@ export {
 	sourceToGitUrl,
 	getSourceCapabilityPath,
 	getLockFilePath,
+	isGitSource,
+	isFileSource,
+	parseFileSourcePath,
+	readCapabilityIdFromPath,
 } from "./sources";
 export type { FetchResult, SourceUpdateInfo, DiscoveredContent } from "./sources";
 export { loadSubagents } from "./subagents";

package/src/capability/loader.ts

@@ -1,7 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { validateEnv } from "../config/env";
 import { parseCapabilityConfig } from "../config/parser";
 import { loadCapabilityHooks } from "../hooks/loader.js";
 import type {
@@ -339,25 +338,14 @@ function convertCommandExports(commandExports: unknown[], capabilityId: string):
 
 /**
  * Loads a complete capability including config, skills, rules, docs, and exports.
- * Validates environment requirements before loading.
- *
  * @param capabilityPath - Path to the capability directory
- * @param env - Environment variables to validate against
  * @returns Fully loaded capability
- * @throws Error if validation fails or loading errors occur
+ * @throws Error if loading errors occur
  */
-export async function loadCapability(
-	capabilityPath: string,
-	env: Record<string, string>,
-): Promise<LoadedCapability> {
+export async function loadCapability(capabilityPath: string): Promise<LoadedCapability> {
 	const config = await loadCapabilityConfig(capabilityPath);
 	const id = config.capability.id;
 
-	// Validate environment
-	if (config.env) {
-		validateEnv(config.env, env, id);
-	}
-
 	// Load content - programmatic takes precedence
 	const exports = await importCapabilityExports(capabilityPath);
 

package/src/capability/registry.ts

@@ -1,5 +1,4 @@
 import { getEnabledCapabilities } from "../config/capabilities";
-import { loadEnvironment } from "../config/env";
 import { mergeHooksConfigs } from "../hooks/merger.js";
 import type { HooksConfig, CapabilityHooks, Doc, LoadedCapability, Rule, Skill } from "../types";
 import { discoverCapabilities, loadCapability } from "./loader";
@@ -27,7 +26,6 @@ export interface CapabilityRegistry {
  * @returns Capability registry with helper functions
  */
 export async function buildCapabilityRegistry(): Promise<CapabilityRegistry> {
-	const env = await loadEnvironment();
 	const enabledIds = await getEnabledCapabilities();
 
 	const capabilityPaths = await discoverCapabilities();
@@ -35,7 +33,7 @@ export async function buildCapabilityRegistry(): Promise<CapabilityRegistry> {
 
 	for (const path of capabilityPaths) {
 		try {
-			const cap = await loadCapability(path, env);
+			const cap = await loadCapability(path);
 
 			// Only add if enabled
 			if (enabledIds.includes(cap.id)) {

package/src/capability/rules.ts

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
-import type { Doc, Rule } from "../types";
+import type { Rule } from "../types";
 
 /**
  * Load rules from a capability's rules/ directory
@@ -36,101 +36,3 @@ export async function loadRules(capabilityPath: string, capabilityId: string): P
 
 	return rules;
 }
-
-/**
- * Write aggregated rules and docs to .omni/instructions.md
- * Updates the generated section between markers while preserving user content
- * @param rules Array of rules from all enabled capabilities
- * @param docs Array of docs from all enabled capabilities
- */
-export async function writeRules(rules: Rule[], docs: Doc[] = []): Promise<void> {
-	const instructionsPath = ".omni/instructions.md";
-
-	// Generate content from rules and docs
-	const rulesContent = generateRulesContent(rules, docs);
-
-	// Read existing content or create new file
-	let content: string;
-	if (existsSync(instructionsPath)) {
-		content = await readFile(instructionsPath, "utf-8");
-	} else {
-		// Create new file with basic template
-		content = `# OmniDev Instructions
-
-## Project Description
-<!-- TODO: Add 2-3 sentences describing your project -->
-[Describe what this project does and its main purpose]
-
-<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
-<!-- END OMNIDEV GENERATED CONTENT -->
-`;
-	}
-
-	// Replace content between markers
-	const beginMarker = "<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->";
-	const endMarker = "<!-- END OMNIDEV GENERATED CONTENT -->";
-
-	const beginIndex = content.indexOf(beginMarker);
-	const endIndex = content.indexOf(endMarker);
-
-	if (beginIndex === -1 || endIndex === -1) {
-		// Markers not found, append to end
-		content += `\n\n${beginMarker}\n${rulesContent}\n${endMarker}\n`;
-	} else {
-		// Replace content between markers
-		content =
-			content.substring(0, beginIndex + beginMarker.length) +
-			"\n" +
-			rulesContent +
-			"\n" +
-			content.substring(endIndex);
-	}
-
-	await writeFile(instructionsPath, content, "utf-8");
-}
-
-function generateRulesContent(rules: Rule[], docs: Doc[] = []): string {
-	if (rules.length === 0 && docs.length === 0) {
-		return `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
-	}
-
-	let content = `<!-- This section is automatically updated when capabilities change -->
-
-## Capabilities
-
-`;
-
-	// Add documentation section if there are docs
-	if (docs.length > 0) {
-		content += `### Documentation
-
-`;
-		for (const doc of docs) {
-			content += `#### ${doc.name} (from ${doc.capabilityId})
-
-${doc.content}
-
-`;
-		}
-	}
-
-	// Add rules section if there are rules
-	if (rules.length > 0) {
-		content += `### Rules
-
-`;
-		for (const rule of rules) {
-			content += `#### ${rule.name} (from ${rule.capabilityId})
-
-${rule.content}
-
-`;
-		}
-	}
-
-	return content.trim();
-}

package/src/capability/sources.ts

@@ -17,9 +17,11 @@ import type {
 	CapabilitiesLockFile,
 	CapabilityLockEntry,
 	CapabilitySourceConfig,
+	FileCapabilitySourceConfig,
 	GitCapabilitySourceConfig,
 	OmniConfig,
 } from "../types/index.js";
+import { isFileSourceConfig } from "../types/index.js";
 
 // Local path for .omni directory
 const OMNI_LOCAL = ".omni";
@@ -97,12 +99,62 @@ export function isGitSource(source: string): boolean {
 	);
 }
 
+/**
+ * Check if a source string is a file source
+ */
+export function isFileSource(source: string): boolean {
+	return source.startsWith("file://");
+}
+
+/**
+ * Parse a file:// source to get the actual file path
+ */
+export function parseFileSourcePath(source: string): string {
+	if (!source.startsWith("file://")) {
+		throw new Error(`Invalid file source: ${source}`);
+	}
+	return source.slice(7); // Remove "file://" prefix
+}
+
+/**
+ * Read the capability ID from a capability directory
+ * Tries to read from capability.toml first, then falls back to directory name
+ */
+export async function readCapabilityIdFromPath(capabilityPath: string): Promise<string | null> {
+	const tomlPath = join(capabilityPath, "capability.toml");
+
+	if (existsSync(tomlPath)) {
+		try {
+			const content = await readFile(tomlPath, "utf-8");
+			const parsed = parseToml(content) as Record<string, unknown>;
+			const capability = parsed["capability"] as Record<string, unknown> | undefined;
+			if (capability?.["id"] && typeof capability["id"] === "string") {
+				return capability["id"];
+			}
+		} catch {
+			// Fall through to directory name
+		}
+	}
+
+	// Fall back to directory name
+	const parts = capabilityPath.replace(/\\/g, "/").split("/");
+	const dirName = parts.pop() || parts.pop(); // Handle trailing slash
+	return dirName || null;
+}
+
 /**
  * Parse a capability source string or config into normalized form
- * Returns a GitCapabilitySourceConfig
+ * Returns a GitCapabilitySourceConfig or FileCapabilitySourceConfig
  */
-export function parseSourceConfig(source: CapabilitySourceConfig): GitCapabilitySourceConfig {
+export function parseSourceConfig(
+	source: CapabilitySourceConfig,
+): GitCapabilitySourceConfig | FileCapabilitySourceConfig {
 	if (typeof source === "string") {
+		// Check for file source
+		if (isFileSource(source)) {
+			return { source } as FileCapabilitySourceConfig;
+		}
+
 		// Git source shorthand formats:
 		// - "github:user/repo"
 		// - "github:user/repo#ref"
@@ -125,7 +177,13 @@ export function parseSourceConfig(source: CapabilitySourceConfig): GitCapability
 		}
 		return result;
 	}
-	return source;
+
+	// Check if the config object is a file source
+	if (isFileSourceConfig(source)) {
+		return source as FileCapabilitySourceConfig;
+	}
+
+	return source as GitCapabilitySourceConfig;
 }
 
 /**
@@ -769,7 +827,74 @@ async function fetchGitCapabilitySource(
 }
 
 /**
- * Fetch a single capability source from git
+ * Fetch a file-sourced capability (copy from local path)
+ */
+async function fetchFileCapabilitySource(
+	id: string,
+	config: FileCapabilitySourceConfig,
+	options?: { silent?: boolean },
+): Promise<FetchResult> {
+	const sourcePath = parseFileSourcePath(config.source);
+	const targetPath = getSourceCapabilityPath(id);
+
+	// Validate source exists
+	if (!existsSync(sourcePath)) {
+		throw new Error(`File source not found: ${sourcePath}`);
+	}
+
+	// Check if it's a directory
+	const sourceStats = await stat(sourcePath);
+	if (!sourceStats.isDirectory()) {
+		throw new Error(`File source must be a directory: ${sourcePath}`);
+	}
+
+	// Check if capability.toml exists in source
+	if (!existsSync(join(sourcePath, "capability.toml"))) {
+		throw new Error(`No capability.toml found in: ${sourcePath}`);
+	}
+
+	if (!options?.silent) {
+		console.log(`  Copying ${id} from ${sourcePath}...`);
+	}
+
+	// Remove old target if exists
+	if (existsSync(targetPath)) {
+		await rm(targetPath, { recursive: true });
+	}
+
+	// Create parent directory
+	await mkdir(join(targetPath, ".."), { recursive: true });
+
+	// Copy directory contents
+	await cp(sourcePath, targetPath, { recursive: true });
+
+	// Read version from capability.toml
+	let version = "local";
+	const capTomlPath = join(targetPath, "capability.toml");
+	if (existsSync(capTomlPath)) {
+		try {
+			const content = await readFile(capTomlPath, "utf-8");
+			const parsed = parseToml(content) as Record<string, unknown>;
+			const capability = parsed["capability"] as Record<string, unknown> | undefined;
+			if (capability?.["version"] && typeof capability["version"] === "string") {
+				version = capability["version"];
+			}
+		} catch {
+			// Ignore parse errors
+		}
+	}
+
+	return {
+		id,
+		path: targetPath,
+		version,
+		updated: true,
+		wrapped: false,
+	};
+}
+
+/**
+ * Fetch a single capability source (git or file)
  */
 export async function fetchCapabilitySource(
 	id: string,
@@ -777,7 +902,13 @@ export async function fetchCapabilitySource(
 	options?: { silent?: boolean },
 ): Promise<FetchResult> {
 	const config = parseSourceConfig(sourceConfig);
-	return fetchGitCapabilitySource(id, config, options);
+
+	// Check if it's a file source
+	if (isFileSourceConfig(sourceConfig) || isFileSource(config.source)) {
+		return fetchFileCapabilitySource(id, config as FileCapabilitySourceConfig, options);
+	}
+
+	return fetchGitCapabilitySource(id, config as GitCapabilitySourceConfig, options);
 }
 
 /**
@@ -969,12 +1100,15 @@ export async function fetchAllCapabilitySources(
 			};
 
 			// Git source: use commit and ref
-			const gitConfig = parseSourceConfig(source);
 			if (result.commit) {
 				lockEntry.commit = result.commit;
 			}
-			if (gitConfig.ref) {
-				lockEntry.ref = gitConfig.ref;
+			// Only access ref if it's a git source
+			if (!isFileSourceConfig(source)) {
+				const gitConfig = parseSourceConfig(source) as GitCapabilitySourceConfig;
+				if (gitConfig.ref) {
+					lockEntry.ref = gitConfig.ref;
+				}
 			}
 
 			// Check if lock entry changed
@@ -1029,8 +1163,20 @@ export async function checkForUpdates(config: OmniConfig): Promise<SourceUpdateI
 		const targetPath = getSourceCapabilityPath(id);
 		const existing = lockFile.capabilities[id];
 
+		// Skip file sources - they don't have update checking
+		if (isFileSourceConfig(source) || isFileSource(sourceConfig.source)) {
+			updates.push({
+				id,
+				source: sourceConfig.source,
+				currentVersion: existing?.version || "local",
+				latestVersion: "local",
+				hasUpdate: false,
+			});
+			continue;
+		}
+
 		// Handle git sources
-		const gitConfig = sourceConfig;
+		const gitConfig = sourceConfig as GitCapabilitySourceConfig;
 
 		if (!existsSync(join(targetPath, ".git"))) {
 			// Not yet cloned

package/src/config/AGENTS.md

@@ -11,7 +11,6 @@ Configuration loading and parsing system using TOML format with profile-based ca
 | Task | Location | Notes |
 |------|----------|-------|
 | Config merge logic | loader.ts | Merges config.toml + config.local.toml |
-| Environment loading | env.ts | Loads .omni/.env, validates declarations |
 | TOML parsing | parser.ts | Uses smol-toml, validates capability.toml |
 | Provider selection | provider.ts | Loads provider.toml, parses CLI flags |
 | Profile management | profiles.ts | Active profile tracking, resolves capabilities |
@@ -23,7 +22,6 @@ Configuration loading and parsing system using TOML format with profile-based ca
 - `.omni/config.toml` - main config (project name, default profile, profiles)
 - `.omni/config.local.toml` - local overrides (gitignored)
 - `.omni/provider.toml` - provider selection (claude/codex/both)
-- `.omni/.env` - secrets, always gitignored
 
 **Profile-Based Capability Management:**
 - Profiles define capability sets in `[profiles.name].capabilities`
@@ -31,16 +29,7 @@ Configuration loading and parsing system using TOML format with profile-based ca
 - `always_enabled_capabilities` list merged with profile capabilities
 - Use `enableCapability()` / `disableCapability()` to update active profile
 
-**Environment Variable Handling:**
-- capability.toml `[env]` section declares requirements
-- `required = true` → must be present or default
-- `secret = true` → masked in logs/error messages
-- `default = "value"` → optional with fallback
-
 ## ANTI-PATTERNS (THIS SUBSYSTEM)
 
 - **NEVER** edit config.toml directly for capability changes - use enableCapability()/disableCapability()
-- **NEVER** commit .omni/.env or config.local.toml - both gitignored
 - **NEVER** parse TOML manually - use parseOmniConfig() / parseCapabilityConfig()
-- **NEVER** ignore validateEnv() errors - required env vars block capability load
-- **NEVER** assume process.env is complete - merge with .omni/.env via loadEnvironment()

package/src/config/config.ts

@@ -15,9 +15,6 @@ const LOCAL_CONFIG = "omni.local.toml";
 function mergeConfigs(base: OmniConfig, override: OmniConfig): OmniConfig {
 	const merged: OmniConfig = { ...base, ...override };
 
-	// Deep merge env
-	merged.env = { ...base.env, ...override.env };
-
 	// Deep merge profiles
 	merged.profiles = { ...base.profiles };
 	for (const [name, profile] of Object.entries(override.profiles || {})) {
@@ -84,26 +81,6 @@ export async function writeConfig(config: OmniConfig): Promise<void> {
 function generateConfigToml(config: OmniConfig): string {
 	const lines: string[] = [];
 
-	lines.push("# =============================================================================");
-	lines.push("# OmniDev Configuration");
-	lines.push("# =============================================================================");
-	lines.push("# This file defines your project's capabilities, profiles, and settings.");
-	lines.push("#");
-	lines.push("# Files:");
-	lines.push("#   • omni.toml - Main config (commit to share with team)");
-	lines.push("#   • omni.local.toml - Local overrides (add to .gitignore)");
-	lines.push("#   • omni.lock.toml - Version lock file (commit for reproducibility)");
-	lines.push("#");
-	lines.push("# Quick start:");
-	lines.push("#   1. Add capability sources to [capabilities.sources]");
-	lines.push("#   2. Reference them in your profiles");
-	lines.push("#   3. Run: omnidev sync");
-	lines.push("#   4. Switch profiles: omnidev profile use <name>");
-	lines.push("");
-
-	// Note: active_profile is stored in .omni/state/active-profile, not in config.toml
-	// We still read it from config.toml for backwards compatibility, but don't write it here
-
 	// Providers
 	if (config.providers?.enabled && config.providers.enabled.length > 0) {
 		lines.push("# AI providers to enable (claude, codex, or both)");
@@ -112,28 +89,6 @@ function generateConfigToml(config: OmniConfig): string {
 		lines.push("");
 	}
 
-	// Environment variables
-	lines.push("# =============================================================================");
-	lines.push("# Environment Variables");
-	lines.push("# =============================================================================");
-	lines.push("# Global environment variables available to all capabilities.");
-	// biome-ignore lint/suspicious/noTemplateCurlyInString: Example of env var syntax
-	lines.push("# Use ${VAR_NAME} syntax to reference shell environment variables.");
-	lines.push("#");
-	if (config.env && Object.keys(config.env).length > 0) {
-		lines.push("[env]");
-		for (const [key, value] of Object.entries(config.env)) {
-			lines.push(`${key} = "${value}"`);
-		}
-	} else {
-		lines.push("# [env]");
-		// biome-ignore lint/suspicious/noTemplateCurlyInString: Example of env var syntax
-		lines.push('# DATABASE_URL = "${DATABASE_URL}"');
-		// biome-ignore lint/suspicious/noTemplateCurlyInString: Example of env var syntax
-		lines.push('# API_KEY = "${MY_API_KEY}"');
-	}
-	lines.push("");
-
 	// Capability sources
 	lines.push("# =============================================================================");
 	lines.push("# Capability Sources");
@@ -149,8 +104,8 @@ function generateConfigToml(config: OmniConfig): string {
 			if (typeof sourceConfig === "string") {
 				// Simple string source
 				lines.push(`${name} = "${sourceConfig}"`);
-			} else if (sourceConfig.path) {
-				// Full config object with path
+			} else if ("path" in sourceConfig && sourceConfig.path) {
+				// Full config object with path (git source)
 				lines.push(
 					`${name} = { source = "${sourceConfig.source}", path = "${sourceConfig.path}" }`,
 				);
@@ -235,12 +190,10 @@ function generateConfigToml(config: OmniConfig): string {
 				lines.push(`url = "${mcpConfig.url}"`);
 			}
 
-			// Environment variables (sub-table)
+			// Environment variables (inline table)
 			if (mcpConfig.env && Object.keys(mcpConfig.env).length > 0) {
-				lines.push(`[mcps.${name}.env]`);
-				for (const [key, value] of Object.entries(mcpConfig.env)) {
-					lines.push(`${key} = "${value}"`);
-				}
+				const entries = Object.entries(mcpConfig.env).map(([key, value]) => `${key} = "${value}"`);
+				lines.push(`env = { ${entries.join(", ")} }`);
 			}
 
 			// Headers (sub-table)
@@ -263,9 +216,8 @@ function generateConfigToml(config: OmniConfig): string {
 		lines.push('# command = "node"');
 		lines.push('# args = ["./servers/database.js"]');
 		lines.push('# cwd = "./mcp-servers"');
-		lines.push("# [mcps.database.env]");
 		// biome-ignore lint/suspicious/noTemplateCurlyInString: Example of env var syntax
-		lines.push('# DB_URL = "${DATABASE_URL}"');
+		lines.push('# env = { DB_URL = "${DATABASE_URL}" }');
 		lines.push("");
 	}
 

package/src/config/index.ts

@@ -1,5 +1,4 @@
 export * from "./capabilities";
-export * from "./env";
 export * from "./config";
 export * from "./parser";
 export * from "./profiles";

package/src/config/toml-patcher.ts

@@ -53,7 +53,7 @@ function formatCapabilitySource(name: string, source: CapabilitySourceConfig): s
 	if (typeof source === "string") {
 		return `${name} = "${source}"`;
 	}
-	if (source.path) {
+	if ("path" in source && source.path) {
 		return `${name} = { source = "${source.source}", path = "${source.path}" }`;
 	}
 	return `${name} = "${source.source}"`;
@@ -150,12 +150,10 @@ function formatMcpConfig(name: string, config: McpConfig): string[] {
 		lines.push(`url = "${config.url}"`);
 	}
 
-	// Environment variables
+	// Environment variables (inline table)
 	if (config.env && Object.keys(config.env).length > 0) {
-		lines.push(`[mcps.${name}.env]`);
-		for (const [key, value] of Object.entries(config.env)) {
-			lines.push(`${key} = "${value}"`);
-		}
+		const entries = Object.entries(config.env).map(([key, value]) => `${key} = "${value}"`);
+		lines.push(`env = { ${entries.join(", ")} }`);
 	}
 
 	// Headers

package/src/index.ts

@@ -32,6 +32,7 @@ export * from "./sync";
 
 // Export templates
 export * from "./templates/agents";
+export * from "./templates/capability";
 export * from "./templates/claude";
 export * from "./templates/omni";
 // Export core types

package/src/sync.ts

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process";
 import { mkdirSync } from "node:fs";
 import { buildCapabilityRegistry } from "./capability/registry";
-import { writeRules } from "./capability/rules";
 import { fetchAllCapabilitySources } from "./capability/sources";
 import { loadConfig } from "./config/config";
 import { hasAnyHooks } from "./hooks/merger.js";
@@ -142,7 +141,6 @@ export async function buildSyncBundle(options?: {
 		docs,
 		commands,
 		subagents,
-		instructionsPath: ".omni/instructions.md",
 		instructionsContent,
 	};
 
@@ -224,9 +222,6 @@ export async function syncAgentConfiguration(options?: SyncOptions): Promise<Syn
 	// Ensure core directories exist
 	mkdirSync(".omni", { recursive: true });
 
-	// Write rules and docs to .omni/instructions.md (provider-agnostic)
-	await writeRules(bundle.rules, bundle.docs);
-
 	// Sync .mcp.json with capability MCP servers (before saving manifest)
 	await syncMcpJson(capabilities, previousManifest, { silent });
 
@@ -256,9 +251,7 @@ export async function syncAgentConfiguration(options?: SyncOptions): Promise<Syn
 
 	if (!silent) {
 		console.log("✓ Synced:");
-		console.log(
-			`  - .omni/instructions.md (${bundle.docs.length} docs, ${bundle.rules.length} rules)`,
-		);
+		console.log(`  - ${bundle.docs.length} docs, ${bundle.rules.length} rules`);
 		if (adapters.length > 0) {
 			console.log(`  - Provider adapters: ${adapters.map((a) => a.displayName).join(", ")}`);
 		}

package/src/templates/agents.ts

@@ -1,6 +1,6 @@
 /**
  * Template for AGENTS.md (Codex provider)
- * Creates a minimal file with reference to OmniDev instructions
+ * Creates a minimal file - actual content is generated during sync from OMNI.md + instructions
  */
 export function generateAgentsTemplate(): string {
 	return `# Project Instructions
@@ -9,6 +9,6 @@ export function generateAgentsTemplate(): string {
 
 ## OmniDev
 
-@import .omni/instructions.md
+<!-- This section is populated during sync with capability rules and docs -->
 `;
 }