@mortice/mapwright 0.8.0

package/dist/queries/lists.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Bounded, deterministically ordered list views for MCP list tools and static
+ * resources (Gate 2). Ordering comes from `../catalogue/ordering.js`; tool max
+ * limits and static resource windows are defined by the resource-continuation
+ * contract and enforced independently.
+ */
+import type { CapabilityRecord, CatalogueSnapshot, DiagnosticRecord, ExampleRecord, FileRecord, PackageRecord, PublicApiRecord, RelationshipRecord, SymbolRecord } from "../catalogue/schema.js";
+export type CollectionName = "files" | "symbols" | "packages" | "capabilities" | "publicApis" | "examples" | "relationships" | "diagnostics";
+export interface ListLimit {
+    default: number;
+    max: number;
+}
+/** Tool default/maximum page sizes from resource-continuation.md. */
+export declare const LIST_LIMITS: Record<CollectionName, ListLimit>;
+/** Fixed static-resource window sizes from resource-continuation.md. */
+export declare const RESOURCE_WINDOWS: Record<CollectionName, number>;
+/** Continuation tool per collection (Option A continuation). */
+export declare const CONTINUATION_TOOLS: Record<CollectionName, string>;
+/** Human-readable order key descriptions from semantic-ordering.md. */
+export declare const ORDER_DESCRIPTIONS: Record<CollectionName, string>;
+export interface ListEnvelope<T> {
+    total: number;
+    returned: number;
+    offset: number;
+    limit: number;
+    truncated: boolean;
+    order: string;
+    records: T[];
+}
+export interface ResourceEnvelope<T> {
+    total: number;
+    returned: number;
+    offset: 0;
+    limit: number;
+    truncated: boolean;
+    order: string;
+    continuation: {
+        tool: string;
+        nextOffset: number;
+    } | null;
+    records: T[];
+}
+/** Build a static-resource envelope over the fixed window (always offset 0). */
+export declare function toResourceEnvelope<T>(collection: CollectionName, sorted: T[]): ResourceEnvelope<T>;
+export interface ListFilesFilter {
+    language?: string;
+    kind?: FileRecord["kind"];
+}
+export declare function selectFiles(snapshot: CatalogueSnapshot, filter?: ListFilesFilter): FileRecord[];
+export interface ListSymbolsFilter {
+    language?: string;
+    kind?: SymbolRecord["kind"];
+    packageId?: string;
+}
+export declare function selectSymbols(snapshot: CatalogueSnapshot, filter?: ListSymbolsFilter): SymbolRecord[];
+export interface ListPackagesFilter {
+    ecosystem?: PackageRecord["ecosystem"];
+}
+export declare function selectPackages(snapshot: CatalogueSnapshot, filter?: ListPackagesFilter): PackageRecord[];
+export interface ListCapabilitiesFilter {
+    stability?: CapabilityRecord["stability"];
+}
+export declare function selectCapabilities(snapshot: CatalogueSnapshot, filter?: ListCapabilitiesFilter): CapabilityRecord[];
+export interface ListPublicApisFilter {
+    stability?: PublicApiRecord["stability"];
+    packageId?: string;
+}
+export declare function selectPublicApis(snapshot: CatalogueSnapshot, filter?: ListPublicApisFilter): PublicApiRecord[];
+export interface ListExamplesFilter {
+    capabilityId?: string;
+    publicApiId?: string;
+}
+export declare function selectExamples(snapshot: CatalogueSnapshot, filter?: ListExamplesFilter): ExampleRecord[];
+export interface ListRelationshipsFilter {
+    type?: RelationshipRecord["type"];
+}
+export declare function selectRelationships(snapshot: CatalogueSnapshot, filter?: ListRelationshipsFilter): RelationshipRecord[];
+export interface ListDiagnosticsFilter {
+    severity?: DiagnosticRecord["severity"];
+    category?: DiagnosticRecord["category"];
+}
+export declare function selectDiagnostics(snapshot: CatalogueSnapshot, filter?: ListDiagnosticsFilter): DiagnosticRecord[];
+export interface ListPaging {
+    offset?: number;
+    limit?: number;
+}
+export declare function listFilesPage(snapshot: CatalogueSnapshot, options?: ListFilesFilter & ListPaging): ListEnvelope<FileRecord>;
+export declare function listSymbolsPage(snapshot: CatalogueSnapshot, options?: ListSymbolsFilter & ListPaging): ListEnvelope<SymbolRecord>;
+export declare function listPackagesPage(snapshot: CatalogueSnapshot, options?: ListPackagesFilter & ListPaging): ListEnvelope<PackageRecord>;
+export declare function listCapabilitiesPage(snapshot: CatalogueSnapshot, options?: ListCapabilitiesFilter & ListPaging): ListEnvelope<CapabilityRecord>;
+export declare function listPublicApisPage(snapshot: CatalogueSnapshot, options?: ListPublicApisFilter & ListPaging): ListEnvelope<PublicApiRecord>;
+export declare function listExamplesPage(snapshot: CatalogueSnapshot, options?: ListExamplesFilter & ListPaging): ListEnvelope<ExampleRecord>;
+export declare function listRelationshipsPage(snapshot: CatalogueSnapshot, options?: ListRelationshipsFilter & ListPaging): ListEnvelope<RelationshipRecord>;
+export declare function listDiagnosticsPage(snapshot: CatalogueSnapshot, options?: ListDiagnosticsFilter & ListPaging): ListEnvelope<DiagnosticRecord>;

package/dist/queries/lists.js

@@ -0,0 +1,184 @@
+import { sortCapabilities, sortDiagnostics, sortExamples, sortFiles, sortPackages, sortPublicApis, sortRelationships, sortSymbols } from "../catalogue/ordering.js";
+/** Tool default/maximum page sizes from resource-continuation.md. */
+export const LIST_LIMITS = {
+    files: { default: 100, max: 1000 },
+    symbols: { default: 100, max: 1000 },
+    packages: { default: 50, max: 500 },
+    capabilities: { default: 50, max: 500 },
+    publicApis: { default: 100, max: 1000 },
+    examples: { default: 50, max: 500 },
+    relationships: { default: 100, max: 1000 },
+    diagnostics: { default: 50, max: 500 }
+};
+/** Fixed static-resource window sizes from resource-continuation.md. */
+export const RESOURCE_WINDOWS = {
+    files: 250,
+    symbols: 250,
+    packages: 100,
+    capabilities: 100,
+    publicApis: 250,
+    examples: 100,
+    relationships: 250,
+    diagnostics: 100
+};
+/** Continuation tool per collection (Option A continuation). */
+export const CONTINUATION_TOOLS = {
+    files: "list_files",
+    symbols: "list_symbols",
+    packages: "list_packages",
+    capabilities: "list_capabilities",
+    publicApis: "list_public_apis",
+    examples: "list_examples",
+    relationships: "list_relationships",
+    diagnostics: "list_diagnostics"
+};
+/** Human-readable order key descriptions from semantic-ordering.md. */
+export const ORDER_DESCRIPTIONS = {
+    files: "package, file path, id",
+    symbols: "package, module path, qualified name, symbol kind, id",
+    packages: "ecosystem, package name, package root, id",
+    capabilities: "package, capability name, id",
+    publicApis: "package, canonical consumer import path, exported name, export kind, id",
+    examples: "package, example name or path, id",
+    relationships: "type, from id, to id, semantic discriminator, id",
+    diagnostics: "severity order, category, file path, diagnostic code, id"
+};
+function clampLimit(collection, requested) {
+    const limits = LIST_LIMITS[collection];
+    if (typeof requested !== "number" || !Number.isFinite(requested)) {
+        return limits.default;
+    }
+    const floored = Math.floor(requested);
+    if (floored <= 0) {
+        return limits.default;
+    }
+    return Math.min(floored, limits.max);
+}
+function clampOffset(offset) {
+    if (typeof offset !== "number" || !Number.isFinite(offset)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(offset));
+}
+function toListEnvelope(collection, sorted, offset, limit) {
+    const safeOffset = clampOffset(offset);
+    const safeLimit = clampLimit(collection, limit);
+    const records = sorted.slice(safeOffset, safeOffset + safeLimit);
+    return {
+        total: sorted.length,
+        returned: records.length,
+        offset: safeOffset,
+        limit: safeLimit,
+        truncated: safeOffset + records.length < sorted.length,
+        order: ORDER_DESCRIPTIONS[collection],
+        records
+    };
+}
+/** Build a static-resource envelope over the fixed window (always offset 0). */
+export function toResourceEnvelope(collection, sorted) {
+    const window = RESOURCE_WINDOWS[collection];
+    const records = sorted.slice(0, window);
+    const truncated = records.length < sorted.length;
+    return {
+        total: sorted.length,
+        returned: records.length,
+        offset: 0,
+        limit: window,
+        truncated,
+        order: ORDER_DESCRIPTIONS[collection],
+        continuation: truncated ? { tool: CONTINUATION_TOOLS[collection], nextOffset: records.length } : null,
+        records
+    };
+}
+export function selectFiles(snapshot, filter = {}) {
+    return sortFiles(snapshot.files.filter((file) => {
+        if (filter.language && file.language !== filter.language)
+            return false;
+        if (filter.kind && file.kind !== filter.kind)
+            return false;
+        return true;
+    }));
+}
+export function selectSymbols(snapshot, filter = {}) {
+    return sortSymbols(snapshot.symbols.filter((symbol) => {
+        if (filter.language && symbol.language !== filter.language)
+            return false;
+        if (filter.kind && symbol.kind !== filter.kind)
+            return false;
+        if (filter.packageId && symbol.packageId !== filter.packageId)
+            return false;
+        return true;
+    }));
+}
+export function selectPackages(snapshot, filter = {}) {
+    return sortPackages(snapshot.packages.filter((pkg) => {
+        if (filter.ecosystem && (pkg.ecosystem ?? "unknown") !== filter.ecosystem)
+            return false;
+        return true;
+    }));
+}
+export function selectCapabilities(snapshot, filter = {}) {
+    return sortCapabilities(snapshot.capabilities.filter((capability) => {
+        if (filter.stability && capability.stability !== filter.stability)
+            return false;
+        return true;
+    }));
+}
+export function selectPublicApis(snapshot, filter = {}) {
+    return sortPublicApis(snapshot.publicApis.filter((api) => {
+        if (filter.stability && api.stability !== filter.stability)
+            return false;
+        if (filter.packageId && api.packageId !== filter.packageId)
+            return false;
+        return true;
+    }));
+}
+export function selectExamples(snapshot, filter = {}) {
+    return sortExamples(snapshot.examples.filter((example) => {
+        if (filter.capabilityId && !example.capabilityIds.includes(filter.capabilityId))
+            return false;
+        if (filter.publicApiId && !example.publicApiIds.includes(filter.publicApiId))
+            return false;
+        return true;
+    }));
+}
+export function selectRelationships(snapshot, filter = {}) {
+    return sortRelationships(snapshot.relationships.filter((relationship) => {
+        if (filter.type && relationship.type !== filter.type)
+            return false;
+        return true;
+    }));
+}
+export function selectDiagnostics(snapshot, filter = {}) {
+    return sortDiagnostics(snapshot.diagnostics.filter((diagnostic) => {
+        if (filter.severity && diagnostic.severity !== filter.severity)
+            return false;
+        if (filter.category && diagnostic.category !== filter.category)
+            return false;
+        return true;
+    }));
+}
+export function listFilesPage(snapshot, options = {}) {
+    return toListEnvelope("files", selectFiles(snapshot, options), options.offset, options.limit);
+}
+export function listSymbolsPage(snapshot, options = {}) {
+    return toListEnvelope("symbols", selectSymbols(snapshot, options), options.offset, options.limit);
+}
+export function listPackagesPage(snapshot, options = {}) {
+    return toListEnvelope("packages", selectPackages(snapshot, options), options.offset, options.limit);
+}
+export function listCapabilitiesPage(snapshot, options = {}) {
+    return toListEnvelope("capabilities", selectCapabilities(snapshot, options), options.offset, options.limit);
+}
+export function listPublicApisPage(snapshot, options = {}) {
+    return toListEnvelope("publicApis", selectPublicApis(snapshot, options), options.offset, options.limit);
+}
+export function listExamplesPage(snapshot, options = {}) {
+    return toListEnvelope("examples", selectExamples(snapshot, options), options.offset, options.limit);
+}
+export function listRelationshipsPage(snapshot, options = {}) {
+    return toListEnvelope("relationships", selectRelationships(snapshot, options), options.offset, options.limit);
+}
+export function listDiagnosticsPage(snapshot, options = {}) {
+    return toListEnvelope("diagnostics", selectDiagnostics(snapshot, options), options.offset, options.limit);
+}

package/dist/queries/overview.d.ts

@@ -0,0 +1,2 @@
+import type { CatalogueSnapshot } from "../catalogue/schema.js";
+export declare function getWorkspaceOverview(snapshot: CatalogueSnapshot): Record<string, unknown>;

package/dist/queries/overview.js

@@ -0,0 +1,8 @@
+export function getWorkspaceOverview(snapshot) {
+    return {
+        catalogueId: snapshot.catalogueId,
+        stats: snapshot.stats,
+        packages: snapshot.packages.map((pkg) => ({ id: pkg.id, name: pkg.name, capabilityCount: pkg.capabilities.length })),
+        capabilities: snapshot.capabilities.map((cap) => ({ id: cap.id, name: cap.name, stability: cap.stability }))
+    };
+}

package/dist/queries/publicApis.d.ts

@@ -0,0 +1,60 @@
+import type { CapabilityRecord, CatalogueSnapshot, DiagnosticRecord, ExampleRecord, PackageRecord, PublicApiRecord, SymbolRecord, TestRecord } from "../catalogue/schema.js";
+import { type RankedEnvelope } from "./ranking.js";
+import { type EditingContext } from "./editingContext.js";
+export interface SearchPublicApisOptions {
+    query: string;
+    stability?: PublicApiRecord["stability"];
+    packageId?: string;
+    language?: string;
+    capabilityId?: string;
+    hasExamples?: boolean;
+    hasTests?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface PublicApiCompact {
+    id: string;
+    symbolId: string;
+    name: string;
+    importPath?: string;
+    exportKind?: PublicApiRecord["exportKind"];
+    packageId?: string;
+    stability: PublicApiRecord["stability"];
+}
+export declare function toPublicApiCompact(api: PublicApiRecord): PublicApiCompact;
+export declare function searchPublicApis(snapshot: CatalogueSnapshot, options: SearchPublicApisOptions): RankedEnvelope<PublicApiCompact>;
+export interface PublicApiContextResult {
+    publicApi: PublicApiRecord;
+    symbol?: SymbolRecord;
+    capabilities: CapabilityRecord[];
+    owningPackage?: PackageRecord;
+    examples: ExampleRecord[];
+    tests: TestRecord[];
+    contracts: string[];
+    limitations: string[];
+    importPath?: string;
+    diagnostics: DiagnosticRecord[];
+    truncated: {
+        capabilities: boolean;
+        capabilitiesTotal: number;
+        examples: boolean;
+        examplesTotal: number;
+        tests: boolean;
+        testsTotal: number;
+        diagnostics: boolean;
+        diagnosticsTotal: number;
+    };
+    /** Bounded, advisory editing context; present only when opted in. */
+    editingContext?: EditingContext;
+}
+export interface PublicApiContextOptions {
+    maxCapabilities?: number;
+    maxExamples?: number;
+    maxTests?: number;
+    maxDiagnostics?: number;
+    /** Opt-in bounded editing context (Gate 4). Default false. */
+    includeEditingContext?: boolean;
+    /** Per-section budget for editing context when included. */
+    editingContextLimit?: number;
+}
+export declare function getPublicApiContext(snapshot: CatalogueSnapshot, publicApiId: string, options?: PublicApiContextOptions): PublicApiContextResult | undefined;

package/dist/queries/publicApis.js

@@ -0,0 +1,120 @@
+import { buildRankedEnvelope, rankPublicApis } from "./ranking.js";
+import { buildEditingContext } from "./editingContext.js";
+export function toPublicApiCompact(api) {
+    return {
+        id: api.id,
+        symbolId: api.symbolId,
+        name: api.name,
+        importPath: api.importPath,
+        exportKind: api.exportKind,
+        packageId: api.packageId,
+        stability: api.stability
+    };
+}
+export function searchPublicApis(snapshot, options) {
+    const filters = {
+        stability: options.stability,
+        packageId: options.packageId,
+        language: options.language,
+        capabilityId: options.capabilityId,
+        hasExamples: options.hasExamples,
+        hasTests: options.hasTests
+    };
+    const ranked = rankPublicApis(options.query, snapshot.publicApis, filters, snapshot);
+    return buildRankedEnvelope(options.query, ranked, toPublicApiCompact, filters, {
+        offset: options.offset,
+        limit: options.limit
+    });
+}
+const DEFAULT_PUBLIC_API_CONTEXT_LIMITS = {
+    maxCapabilities: 100,
+    maxExamples: 100,
+    maxTests: 100,
+    maxDiagnostics: 200
+};
+export function getPublicApiContext(snapshot, publicApiId, options = {}) {
+    const limits = {
+        maxCapabilities: normalizeLimit(options.maxCapabilities, DEFAULT_PUBLIC_API_CONTEXT_LIMITS.maxCapabilities),
+        maxExamples: normalizeLimit(options.maxExamples, DEFAULT_PUBLIC_API_CONTEXT_LIMITS.maxExamples),
+        maxTests: normalizeLimit(options.maxTests, DEFAULT_PUBLIC_API_CONTEXT_LIMITS.maxTests),
+        maxDiagnostics: normalizeLimit(options.maxDiagnostics, DEFAULT_PUBLIC_API_CONTEXT_LIMITS.maxDiagnostics)
+    };
+    const publicApi = snapshot.publicApis.find((api) => api.id === publicApiId);
+    if (!publicApi) {
+        return undefined;
+    }
+    const symbol = snapshot.symbols.find((item) => item.id === publicApi.symbolId);
+    const allCapabilities = snapshot.capabilities.filter((capability) => publicApi.capabilityIds.includes(capability.id)).sort((a, b) => a.id.localeCompare(b.id));
+    const capabilities = allCapabilities.slice(0, limits.maxCapabilities);
+    const allExamples = snapshot.examples.filter((example) => example.publicApiIds.includes(publicApi.id)).sort((a, b) => a.id.localeCompare(b.id));
+    const examples = allExamples.slice(0, limits.maxExamples);
+    const allTests = snapshot.tests
+        .filter((test) => publicApi.tests.includes(test.filePath)
+        || publicApi.tests.includes(test.id)
+        || test.coversPublicApis.includes(publicApi.id)
+        || (symbol ? test.coversSymbols.includes(symbol.id) : false))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const tests = allTests.slice(0, limits.maxTests);
+    const owningPackage = symbol ? findOwningPackage(snapshot, symbol.filePath) : undefined;
+    const allDiagnostics = snapshot.diagnostics
+        .filter((diagnostic) => {
+        if (diagnostic.target?.kind === "publicApi" && diagnostic.target.id === publicApi.id) {
+            return true;
+        }
+        if (symbol && diagnostic.target?.kind === "symbol" && diagnostic.target.id === symbol.id) {
+            return true;
+        }
+        if (symbol?.filePath && diagnostic.filePath === symbol.filePath) {
+            return true;
+        }
+        return false;
+    })
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const diagnostics = allDiagnostics.slice(0, limits.maxDiagnostics);
+    const editingContext = options.includeEditingContext
+        ? buildEditingContext(snapshot, { publicApi, symbol }, { perSectionLimit: options.editingContextLimit })
+        : undefined;
+    return {
+        publicApi,
+        symbol,
+        capabilities,
+        owningPackage,
+        examples,
+        tests,
+        contracts: [...new Set([...publicApi.contracts, ...capabilities.flatMap((capability) => capability.contracts)])].sort(),
+        limitations: [...new Set(capabilities.flatMap((capability) => capability.limitations))].sort(),
+        importPath: publicApi.importPath,
+        diagnostics,
+        editingContext,
+        truncated: {
+            capabilities: capabilities.length < allCapabilities.length,
+            capabilitiesTotal: allCapabilities.length,
+            examples: examples.length < allExamples.length,
+            examplesTotal: allExamples.length,
+            tests: tests.length < allTests.length,
+            testsTotal: allTests.length,
+            diagnostics: diagnostics.length < allDiagnostics.length,
+            diagnosticsTotal: allDiagnostics.length
+        }
+    };
+}
+function findOwningPackage(snapshot, filePath) {
+    const candidates = snapshot.packages.filter((pkg) => {
+        if (pkg.path === ".") {
+            return true;
+        }
+        return filePath === pkg.path || filePath.startsWith(`${pkg.path}/`);
+    });
+    candidates.sort((a, b) => b.path.length - a.path.length || a.id.localeCompare(b.id));
+    return candidates[0];
+}
+function normalizeLimit(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return fallback;
+    }
+    return normalized;
+}

package/dist/queries/ranking.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Deterministic retrieval ranking for public API and symbol searches (Gate 2).
+ *
+ * Hard filters are applied as eligibility conditions *before* ranking. Ranking
+ * then operates only within the eligible set and produces a closed, versioned
+ * set of `MatchReason` values per result. Reasons are emitted in a fixed
+ * canonical order and never include unregistered strings.
+ */
+import type { CatalogueSnapshot, PublicApiRecord, SymbolKind, SymbolRecord } from "../catalogue/schema.js";
+/** Version of the ranking + match-reason contract exposed to MCP callers. */
+export declare const RANKING_CONTRACT_VERSION = "1";
+/**
+ * Closed vocabulary of match reasons. Order here is also the canonical
+ * emission order for a single result's `matchReasons`.
+ */
+export declare const MATCH_REASONS: readonly ["exact_exported_name", "exact_declared_name", "exact_qualified_name", "exact_import_path", "case_insensitive_exact", "whole_token", "prefix", "substring", "public_export", "package_root_export", "subpath_export", "canonical_source", "explicit_documentation", "explicit_public_api", "has_explicit_example", "has_explicit_test", "has_direct_usage"];
+export type MatchReason = (typeof MATCH_REASONS)[number];
+export interface RankingFilters {
+    packageId?: string;
+    language?: string;
+    kind?: SymbolKind;
+    publicOnly?: boolean;
+    capabilityId?: string;
+    hasExamples?: boolean;
+    hasTests?: boolean;
+    stability?: PublicApiRecord["stability"];
+}
+export interface RankedResult<T> {
+    record: T;
+    matchReasons: MatchReason[];
+}
+export interface RankedEnvelope<C> {
+    total: number;
+    returned: number;
+    offset: number;
+    limit: number;
+    truncated: boolean;
+    rankingContractVersion: string;
+    filtersApplied: Record<string, unknown>;
+    normalizedQuery: string;
+    records: Array<C & {
+        matchReasons: MatchReason[];
+    }>;
+}
+/** NFC-normalize and trim a raw query. */
+export declare function normalizeQuery(query: string): string;
+/** Lowercase alphanumeric tokens, splitting on separators and camelCase boundaries. */
+export declare function tokenize(value: string): string[];
+/**
+ * Public helper: compute the ordered string-oriented match reasons for a
+ * candidate name against a raw query. Used by lighter-weight rankers (e.g.
+ * reuse candidates) that want explanatory reasons without full scoring.
+ */
+export declare function nameMatchReasons(candidate: string, query: string, exactReason?: "exact_exported_name" | "exact_declared_name"): MatchReason[];
+export declare function rankPublicApis(query: string, records: PublicApiRecord[], filters: RankingFilters, snapshot: CatalogueSnapshot): RankedResult<PublicApiRecord>[];
+export declare function rankSymbols(query: string, records: SymbolRecord[], filters: RankingFilters, snapshot: CatalogueSnapshot): RankedResult<SymbolRecord>[];
+/** Generic pagination + compaction helper for ranked results. */
+export declare function paginateRanked<T, C>(ranked: RankedResult<T>[], toCompact: (record: T) => C, params: {
+    offset?: number;
+    limit?: number;
+    normalizedQuery: string;
+    filtersApplied: Record<string, unknown>;
+}): RankedEnvelope<C>;
+export declare function buildRankedEnvelope<T, C>(query: string, ranked: RankedResult<T>[], toCompact: (record: T) => C, filters: RankingFilters, paging: {
+    offset?: number;
+    limit?: number;
+}): RankedEnvelope<C>;