@optave/codegraph 3.12.0 → 3.15.0

package/src/presentation/queries-cli/overview.ts

@@ -1,5 +1,11 @@
 import path from 'node:path';
-import { kindIcon, moduleMapData, rolesData, statsData } from '../../domain/queries.js';
+import {
+  dynamicCallsData,
+  kindIcon,
+  moduleMapData,
+  rolesData,
+  statsData,
+} from '../../domain/queries.js';
 import { debug } from '../../infrastructure/logger.js';
 import { outputResult } from '../../infrastructure/result-formatter.js';
 import { toErrorMessage } from '../../shared/errors.js';
@@ -317,6 +323,34 @@ function printRoleGroup(role: string, symbols: RoleSymbol[]): void {
   console.log();
 }
 
+export function dynamicCalls(customDbPath: string, opts: OutputOpts = {}): void {
+  const rows = dynamicCallsData(customDbPath);
+  if (opts.json || opts.ndjson) {
+    outputResult(
+      { dynamic_calls: rows } as unknown as Record<string, unknown>,
+      'dynamic_calls',
+      opts,
+    );
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(
+      'No flagged dynamic calls found. Run "codegraph build" first, or add JavaScript files with eval/computed-key patterns.',
+    );
+    return;
+  }
+  console.log('\nFlagged dynamic calls (confidence=0.0 sink edges):\n');
+  const total = rows.reduce((s, r) => s + r.count, 0);
+  for (const { dynamic_kind, count } of rows) {
+    const bar = '█'.repeat(Math.min(30, Math.round((count / total) * 30)));
+    console.log(`  ${dynamic_kind.padEnd(20)} ${String(count).padStart(5)}  ${bar}`);
+  }
+  console.log(`\n  Total flagged: ${total}\n`);
+  console.log(
+    '  Kinds: eval — undecidable; computed-key — obj[var](); unresolved-dynamic — other\n',
+  );
+}
+
 export function roles(customDbPath: string, opts: OutputOpts = {}): void {
   const data = rolesData(customDbPath, opts) as RolesData;
   if (outputResult(data as unknown as Record<string, unknown>, 'symbols', opts)) return;

package/src/presentation/queries-cli.ts

@@ -12,6 +12,7 @@ export {
   children,
   context,
   diffImpact,
+  dynamicCalls,
   explain,
   fileDeps,
   fileExports,

package/src/presentation/structure.ts

@@ -53,15 +53,15 @@ interface HotspotsResult {
   metric: string;
   level: string;
   limit: number;
-  hotspots: any[];
+  items: any[];
 }
 
 export function formatHotspots(data: HotspotsResult): string {
-  if (data.hotspots.length === 0) return 'No hotspots found. Run "codegraph build" first.';
+  if (data.items.length === 0) return 'No hotspots found. Run "codegraph build" first.';
 
   const lines = [`\nHotspots by ${data.metric} (${data.level}-level, top ${data.limit}):\n`];
   let rank = 1;
-  for (const h of data.hotspots) {
+  for (const h of data.items) {
     const extra =
       h.kind === 'directory'
         ? `${h.fileCount} files, cohesion=${h.cohesion !== null ? h.cohesion!.toFixed(2) : 'n/a'}`

package/src/presentation/viewer.ts

@@ -150,80 +150,10 @@ export function buildLayoutOptions(cfg: PlotConfig): LayoutOptions {
   return opts;
 }
 
-// ─── HTML Renderer ───────────────────────────────────────────────────
-
-export interface ViewerNode {
-  id: number | string;
-  label: string;
-  kind: string;
-  file: string;
-  line: number;
-  role: string | null;
-  fanIn: number;
-  fanOut: number;
-  cognitive: number | null;
-  cyclomatic: number | null;
-  maintainabilityIndex: number | null;
-  community: number | null;
-  directory: string | null;
-  risk: string[];
-}
-
-export interface ViewerEdge {
-  id: number | string;
-  from: number | string;
-  to: number | string;
-}
-
-export interface ViewerData {
-  nodes: ViewerNode[];
-  edges: ViewerEdge[];
-  seedNodeIds: (number | string)[];
-}
-
-interface ResolvedPlotConfig {
-  layoutOpts: LayoutOptions;
-  title: string;
-  layoutAlgorithm: string;
-  layoutDirection: string;
-  physicsEnabled: boolean;
-  sizeBy: string;
-  clusterBy: string;
-  effectiveColorBy: string;
-  effectiveRisk: boolean;
-}
+// ─── HTML Section Renderers ──────────────────────────────────────────
 
-function resolvePlotConfig(cfg: PlotConfig): ResolvedPlotConfig {
-  return {
-    layoutOpts: buildLayoutOptions(cfg),
-    title: cfg.title || 'Codegraph',
-    layoutAlgorithm: cfg.layout?.algorithm || 'hierarchical',
-    layoutDirection: cfg.layout?.direction || 'LR',
-    physicsEnabled: cfg.physics?.enabled !== false,
-    sizeBy: cfg.sizeBy || 'uniform',
-    clusterBy: cfg.clusterBy || 'none',
-    effectiveColorBy:
-      cfg.overlays?.complexity && cfg.colorBy === 'kind' ? 'complexity' : cfg.colorBy || 'kind',
-    effectiveRisk: cfg.overlays?.risk || false,
-  };
-}
-
-export function renderPlotHTML(data: ViewerData, cfg: PlotConfig): string {
-  const {
-    layoutOpts,
-    title,
-    layoutAlgorithm,
-    layoutDirection,
-    physicsEnabled,
-    sizeBy,
-    clusterBy,
-    effectiveColorBy,
-    effectiveRisk,
-  } = resolvePlotConfig(cfg);
-
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
+function renderViewerHead(title: string): string {
+  return `<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>${escapeHtml(title)}</title>
@@ -257,9 +187,13 @@ export function renderPlotHTML(data: ViewerData, cfg: PlotConfig): string {
   #legend div { display: flex; align-items: center; gap: 6px; margin: 2px 0; }
   #legend span.swatch { width: 14px; height: 14px; border-radius: 3px; display: inline-block; flex-shrink: 0; }
 </style>
-</head>
-<body>
-<div id="controls">
+</head>`;
+}
+
+function renderViewerControls(resolved: ResolvedPlotConfig): string {
+  const { layoutAlgorithm, physicsEnabled, effectiveColorBy, sizeBy, clusterBy, effectiveRisk } =
+    resolved;
+  return `<div id="controls">
   <label>Layout:
     <select id="layoutSelect">
       <option value="hierarchical"${layoutAlgorithm === 'hierarchical' ? ' selected' : ''}>Hierarchical</option>
@@ -293,16 +227,16 @@ export function renderPlotHTML(data: ViewerData, cfg: PlotConfig): string {
     </select>
   </label>
   <label>Risk: <input type="checkbox" id="riskToggle"${effectiveRisk ? ' checked' : ''}></label>
-</div>
-<div id="main">
-  <div id="graph"></div>
-  <div id="detail">
-    <span id="detailClose">&times;</span>
-    <div id="detailContent"></div>
-  </div>
-</div>
-<div id="legend"></div>
-<script>
+</div>`;
+}
+
+function renderViewerScript(
+  data: ViewerData,
+  cfg: PlotConfig,
+  resolved: ResolvedPlotConfig,
+): string {
+  const { layoutOpts, layoutDirection, clusterBy, effectiveColorBy } = resolved;
+  return `<script>
 /* ── Data ──────────────────────────────────────────────────────────── */
 var allNodes = ${JSON.stringify(data.nodes)};
 var allEdges = ${JSON.stringify(data.edges)};
@@ -698,7 +632,84 @@ document.getElementById('detailClose').addEventListener('click', hideDetail);
 refreshNodeAppearance();
 updateLegend(${JSON.stringify(effectiveColorBy)});
 ${clusterBy !== 'none' ? `applyClusterBy(${JSON.stringify(clusterBy)});` : ''}
-</script>
+</script>`;
+}
+
+// ─── HTML Renderer ───────────────────────────────────────────────────
+
+export interface ViewerNode {
+  id: number | string;
+  label: string;
+  kind: string;
+  file: string;
+  line: number;
+  role: string | null;
+  fanIn: number;
+  fanOut: number;
+  cognitive: number | null;
+  cyclomatic: number | null;
+  maintainabilityIndex: number | null;
+  community: number | null;
+  directory: string | null;
+  risk: string[];
+}
+
+export interface ViewerEdge {
+  id: number | string;
+  from: number | string;
+  to: number | string;
+}
+
+export interface ViewerData {
+  nodes: ViewerNode[];
+  edges: ViewerEdge[];
+  seedNodeIds: (number | string)[];
+}
+
+interface ResolvedPlotConfig {
+  layoutOpts: LayoutOptions;
+  title: string;
+  layoutAlgorithm: string;
+  layoutDirection: string;
+  physicsEnabled: boolean;
+  sizeBy: string;
+  clusterBy: string;
+  effectiveColorBy: string;
+  effectiveRisk: boolean;
+}
+
+function resolvePlotConfig(cfg: PlotConfig): ResolvedPlotConfig {
+  return {
+    layoutOpts: buildLayoutOptions(cfg),
+    title: cfg.title || 'Codegraph',
+    layoutAlgorithm: cfg.layout?.algorithm || 'hierarchical',
+    layoutDirection: cfg.layout?.direction || 'LR',
+    physicsEnabled: cfg.physics?.enabled !== false,
+    sizeBy: cfg.sizeBy || 'uniform',
+    clusterBy: cfg.clusterBy || 'none',
+    effectiveColorBy:
+      cfg.overlays?.complexity && cfg.colorBy === 'kind' ? 'complexity' : cfg.colorBy || 'kind',
+    effectiveRisk: cfg.overlays?.risk || false,
+  };
+}
+
+export function renderPlotHTML(data: ViewerData, cfg: PlotConfig): string {
+  const resolved = resolvePlotConfig(cfg);
+  const { title } = resolved;
+  return `<!DOCTYPE html>
+<html lang="en">
+${renderViewerHead(title)}
+<body>
+${renderViewerControls(resolved)}
+<div id="main">
+  <div id="graph"></div>
+  <div id="detail">
+    <span id="detailClose">&times;</span>
+    <div id="detailContent"></div>
+  </div>
+</div>
+<div id="legend"></div>
+${renderViewerScript(data, cfg, resolved)}
 </body>
 </html>`;
 }

package/src/shared/constants.ts

@@ -34,8 +34,34 @@ export const IGNORE_DIRS: ArrayCompatSet<string> = withArrayCompat(
   ]),
 );
 
+/**
+ * Merge the global IGNORE_DIRS set with a per-repo additional list from config.
+ * Returns a new Set — does not mutate IGNORE_DIRS.
+ */
+export function buildIgnoreSet(additionalDirs?: string[]): ReadonlySet<string> {
+  if (!additionalDirs || additionalDirs.length === 0) return IGNORE_DIRS;
+  return new Set([...IGNORE_DIRS, ...additionalDirs]);
+}
+
 export const EXTENSIONS: ArrayCompatSet<string> = withArrayCompat(new Set(SUPPORTED_EXTENSIONS));
 
+/**
+ * Minimum confidence assigned to resolved `ts-native` call edges.
+ *
+ * The native engine's proximity heuristic returns 0.3 for cross-module calls
+ * where no import-path evidence is available.  For ts-native edges the engine
+ * performed actual name-based symbol lookup, which is stronger evidence than
+ * pure file-proximity.  Clamping to 0.5 (same-parent-directory level) avoids
+ * unfairly dragging down the call-confidence metric.  Sink edges
+ * (confidence = 0.0) are intentionally excluded and must remain at 0.0 so
+ * they stay below DEFAULT_MIN_CONFIDENCE and never surface in normal queries.
+ *
+ * Used in `build-edges.ts` (in-memory + `applyEdgeTechniquesAfterNativeInsert`)
+ * and `native-orchestrator.ts` (`backfillEdgeTechniquesAfterNativeOrchestrator`).
+ * Centralised here so all three insertion paths apply the same value.
+ */
+export const TS_NATIVE_CONFIDENCE_FLOOR = 0.5;
+
 export function shouldIgnore(dirName: string): boolean {
   return IGNORE_DIRS.has(dirName) || dirName.startsWith('.');
 }

package/src/shared/normalize.ts

@@ -29,29 +29,20 @@ export function toSymbolRef(row: { name: string; kind: string; file: string; lin
   return { name: row.name, kind: row.kind, file: row.file, line: row.line };
 }
 
+const KIND_ICONS: Readonly<Record<string, string>> = {
+  function: 'f',
+  class: '*',
+  method: 'o',
+  file: '#',
+  interface: 'I',
+  type: 'T',
+  parameter: 'p',
+  property: '.',
+  constant: 'C',
+};
+
 export function kindIcon(kind: string): string {
-  switch (kind) {
-    case 'function':
-      return 'f';
-    case 'class':
-      return '*';
-    case 'method':
-      return 'o';
-    case 'file':
-      return '#';
-    case 'interface':
-      return 'I';
-    case 'type':
-      return 'T';
-    case 'parameter':
-      return 'p';
-    case 'property':
-      return '.';
-    case 'constant':
-      return 'C';
-    default:
-      return '-';
-  }
+  return KIND_ICONS[kind] ?? '-';
 }
 
 export interface NormalizedSymbol {

package/src/shared/paginate.ts

@@ -5,23 +5,9 @@
  * change between pages; offset/limit is simpler and maps directly to SQL.
  */
 
-export interface PaginationMeta {
-  total: number;
-  offset: number;
-  limit: number;
-  hasMore: boolean;
-  returned: number;
-}
-
-export interface PaginatedResult<T> {
-  items: T[];
-  pagination?: PaginationMeta;
-}
+import type { PaginatedItems, PaginationMeta, PaginationOpts } from '../types.js';
 
-export interface PaginateOpts {
-  limit?: number;
-  offset?: number;
-}
+export type { PaginatedItems as PaginatedResult, PaginationMeta, PaginationOpts as PaginateOpts };
 
 /** Default limits applied by MCP tool handlers (not by the programmatic API). */
 export const MCP_DEFAULTS: Record<string, number> = {
@@ -65,7 +51,7 @@ export const MCP_MAX_LIMIT = 1000;
  *
  * When `limit` is undefined the input is returned unchanged (no-op).
  */
-export function paginate<T>(items: T[], { limit, offset }: PaginateOpts = {}): PaginatedResult<T> {
+export function paginate<T>(items: T[], { limit, offset }: PaginationOpts = {}): PaginatedItems<T> {
   if (limit === undefined) {
     return { items };
   }
@@ -94,7 +80,7 @@ export function paginate<T>(items: T[], { limit, offset }: PaginateOpts = {}): P
 export function paginateResult<T extends Record<string, unknown>>(
   result: T,
   field: string,
-  { limit, offset }: PaginateOpts = {},
+  { limit, offset }: PaginationOpts = {},
 ): T & { _pagination?: PaginationMeta } {
   if (limit === undefined) {
     return result;

package/src/types.ts

@@ -52,7 +52,13 @@ export type CoreEdgeKind =
 export type StructuralEdgeKind = 'parameter_of' | 'receiver';
 
 /** Dataflow-specific edge kinds. */
-export type DataflowEdgeKind = 'flows_to' | 'returns' | 'mutates';
+export type DataflowEdgeKind =
+  | 'flows_to'
+  | 'returns'
+  | 'mutates'
+  | 'def_use'
+  | 'arg_in'
+  | 'return_out';
 
 /** All edge kinds that can appear in the graph. */
 export type EdgeKind = CoreEdgeKind | StructuralEdgeKind;
@@ -180,6 +186,7 @@ export interface EdgeRow {
   kind: EdgeKind;
   confidence: number | null;
   dynamic: 0 | 1;
+  dynamic_kind?: string | null;
 }
 
 /** Callee/caller node shape (from findCallees / findCallers). */
@@ -469,12 +476,27 @@ export interface LOCMetrics {
   commentLines: number;
 }
 
+/**
+ * Taxonomy for dynamic/computed call sites — distinguishes resolvable kinds
+ * (computed-literal, reflection) from flag-only kinds (eval, computed-key,
+ * unresolved-dynamic) that cannot be resolved statically.
+ */
+export type DynamicKind =
+  | 'computed-literal' // obj["foo"]()    — resolvable; already emitted as normal edge
+  | 'computed-key' // obj[k]()        — potentially resolvable via pts; else flagged
+  | 'reflection' // .call/.apply/.bind / Reflect.* / callable-ref — resolved when target is in codebase; sink edge emitted if unresolved
+  | 'eval' // eval() / new Function() — undecidable; always flagged
+  | 'unresolved-dynamic'; // any other detected dynamic pattern; flagged
+
 /** A function/method call detected by an extractor. */
 export interface Call {
   name: string;
   line: number;
   receiver?: string;
   dynamic?: boolean;
+  dynamicKind?: DynamicKind;
+  /** Raw key/arg text — used for diagnostics and future RES-1 const-string resolution. */
+  keyExpr?: string;
 }
 
 /** An import statement detected by an extractor. */
@@ -707,6 +729,14 @@ export interface ExtractorOutput {
    * `definePropertyReceivers.set("getter", "obj")`.
    */
   definePropertyReceivers?: Map<string, string>;
+  /**
+   * CJS require bindings from `const { X, Y } = require('./path')` patterns.
+   * Used by buildImportedNamesMap to classify X and Y as import artifacts so
+   * receiver-edge resolution falls back to the global class lookup rather than
+   * treating the destructured-binding function node as a local definition (#1661).
+   * Does NOT cause DB import edges — use `imports` for that.
+   */
+  cjsRequireBindings?: Array<{ names: string[]; source: string }>;
   /** WASM tree retained for downstream analysis (complexity, CFG, dataflow). */
   _tree?: TreeSitterTree;
   /** Language identifier. */
@@ -954,10 +984,14 @@ export interface CfgRulesConfig {
 export interface DataflowRulesConfig {
   functionNodes: Set<string>;
   nameField: string;
+  /** Override for languages with nested function name structures (e.g. C/C++). */
+  nameExtractor: ((node: TreeSitterNode) => string | null) | null;
   varAssignedFnParent: string | null;
   assignmentFnParent: string | null;
   pairFnParent: string | null;
   paramListField: string;
+  /** Override for languages where the param list is nested (e.g. C: function_definition → declarator → parameters). */
+  getParamListNode: ((funcNode: TreeSitterNode) => TreeSitterNode | null) | null;
   paramIdentifier: string;
   paramWrapperTypes: Set<string>;
   defaultParamType: string | null;
@@ -1018,6 +1052,20 @@ export interface CfgEdge {
   label?: string;
 }
 
+/**
+ * A dataflow vertex: an addressable data location within a function.
+ * Populated during extraction (P1+); persisted to `dataflow_vertices`.
+ */
+export interface DataflowVertex {
+  /** Name of the enclosing function (used to resolve func_id at insert time). */
+  funcName: string;
+  /** Vertex kind: 'param' | 'local' | 'return' | 'receiver'. */
+  kind: 'param' | 'local' | 'return' | 'receiver';
+  name?: string;
+  paramIndex?: number;
+  line?: number;
+}
+
 /** Dataflow extraction result. */
 export interface DataflowResult {
   parameters: DataflowParam[];
@@ -1254,6 +1302,20 @@ export interface BuildGraphOpts {
    * `findDbPath` for every other DB-scoped command.
    */
   dbPath?: string;
+  /**
+   * User-config override for this build (from --user-config / --no-user-config).
+   * - false          → --no-user-config: skip global layer for this run
+   * - string         → --user-config <path>: apply the given file
+   * - true           → --user-config (bare): apply the default global file
+   * - undefined      → honour per-repo consent from the registry (normal)
+   */
+  userConfig?: string | boolean;
+  /**
+   * When true, an interactive consent prompt may fire on first build for
+   * repos whose global-config consent is undecided. Only set by the CLI
+   * build command when stdin/stdout are TTYs and CI is not set.
+   */
+  promptForConsent?: boolean;
 }
 
 /** Build timing result from buildGraph. */
@@ -1268,8 +1330,16 @@ export interface BuildResult {
     edgesMs: number;
     structureMs: number;
     rolesMs: number;
+    /** Wall-clock time for the CHA expansion post-pass (native path only). */
+    chaMs?: number;
     /** Wall-clock time for the this/super dispatch WASM post-pass (native path only). */
     thisDispatchMs?: number;
+    /** Wall-clock time for the dropped-language gap detection + backfill (native path only). */
+    gapDetectMs?: number;
+    /** Wall-clock time for role re-classification after JS edge-writing post-passes (native path only). */
+    reclassifyMs?: number;
+    /** Wall-clock time for the technique-column backfill on native-written edges (native path only). */
+    techniqueBackfillMs?: number;
     astMs: number;
     complexityMs: number;
     cfgMs: number;
@@ -1289,6 +1359,8 @@ export interface CodegraphConfig {
   include: string[];
   exclude: string[];
   ignoreDirs: string[];
+  /** Additional directory names to ignore on top of the built-in IGNORE_DIRS set. */
+  ignoreAdditionalDirs: string[];
   extensions: string[];
   aliases: Record<string, unknown>;
 
@@ -1305,6 +1377,26 @@ export interface CodegraphConfig {
      * Default: false.
      */
     typescriptResolver: boolean;
+    /**
+     * Engine selection override. Values: `'auto'` (default), `'native'`, `'wasm'`.
+     *
+     * **Current wiring (partial):** This field is populated by `applyEnvOverrides`
+     * from `CODEGRAPH_ENGINE` env var — env var → `config.build.engine`. The
+     * `--engine` CLI flag is also forwarded. However, `connection.ts` and
+     * `pipeline.ts` still read `process.env.CODEGRAPH_ENGINE` / `ctx.opts.engine`
+     * directly, so a value set only in `.codegraphrc.json` (not via env var or CLI)
+     * is silently ignored by the pipeline.
+     *
+     * Full config-file wiring is tracked in issue #1596.
+     */
+    engine: 'auto' | 'native' | 'wasm';
+    /**
+     * Enable diagnostic logging for the native fast-skip pre-flight check.
+     * Equivalent to `CODEGRAPH_FAST_SKIP_DIAG=1`. When true, logs why the
+     * fast-skip gate was skipped (e.g. forceFullRebuild, engineName mismatch).
+     * Default: false.
+     */
+    fastSkipDiag: boolean;
   };
 
   query: {
@@ -1383,6 +1475,13 @@ export interface CodegraphConfig {
      * constant of 50.  See TODO in `src/infrastructure/config.ts`.
      */
     pointsToMaxIterations: number;
+    /**
+     * Confidence score for a return type inferred from `return new Constructor()`
+     * with no explicit TypeScript annotation.
+     * Mirrors `INFERRED_RETURN_TYPE_CONFIDENCE` in `src/extractors/javascript.ts`.
+     * @reserved — not yet wired; see TODO in `src/infrastructure/config.ts`.
+     */
+    typeInferenceConfidence: number;
   };
 
   community: {
@@ -1469,6 +1568,25 @@ export interface McpDefaults {
   interfaces: number;
 }
 
+/** Per-repo consent decision for the user-level global config. */
+export type ConsentDecision = 'enabled' | 'disabled';
+
+/** Which layer contributed a resolved config value. */
+export type ConfigSource = 'default' | 'user' | 'project' | 'env';
+
+/** Maps config key paths (dot notation) to the layer that supplied the value. */
+export type ConfigProvenance = Record<string, ConfigSource>;
+
+/** Result of loadConfigWithProvenance. */
+export interface ConfigWithProvenance {
+  config: CodegraphConfig;
+  provenance: ConfigProvenance;
+  /** Absolute path of the applied global file, or null if none was applied. */
+  appliedGlobalPath: string | null;
+  /** This repo's recorded consent decision (may be undefined if undecided). */
+  consentDecision: ConsentDecision | undefined;
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // §12  Pagination
 // ════════════════════════════════════════════════════════════════════════
@@ -2168,6 +2286,14 @@ export interface NativeAddon {
     filePath: string,
     langId?: string | null,
   ): DataflowResult | null;
+  /**
+   * Batch counterpart to {@link extractDataflowAnalysis}: read and analyse many
+   * files in parallel (rayon) in a single NAPI call. Results are positional —
+   * `null` where the file could not be read or has no dataflow rules. Optional:
+   * older published addons predate this export, so callers must feature-detect
+   * and fall back to per-file `extractDataflowAnalysis`.
+   */
+  extractDataflowAnalysisBatch?(filePaths: string[]): (DataflowResult | null)[];
   ParseTreeCache: new () => NativeParseTreeCache;
   NativeDatabase: {
     openReadWrite(dbPath: string): NativeDatabase;