@saluzi/codegraph 0.1.0

package/dist/resolution/frameworks/ruby.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Ruby Framework Resolver
+ *
+ * Handles Ruby on Rails patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.railsResolver = void 0;
+const strip_comments_1 = require("../strip-comments");
+exports.railsResolver = {
+    name: 'rails',
+    languages: ['ruby'],
+    detect(context) {
+        // Check for Gemfile with rails
+        const gemfile = context.readFile('Gemfile');
+        if (gemfile && gemfile.includes("'rails'")) {
+            return true;
+        }
+        // Check for config/application.rb (Rails signature)
+        if (context.fileExists('config/application.rb')) {
+            return true;
+        }
+        // Check for typical Rails directory structure
+        return (context.fileExists('app/controllers/application_controller.rb') ||
+            context.fileExists('config/routes.rb'));
+    },
+    resolve(ref, context) {
+        // Pattern 1: Model references (ActiveRecord)
+        if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
+            const result = resolveModel(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 2: Controller references
+        if (ref.referenceName.endsWith('Controller')) {
+            const result = resolveController(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.85,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 3: Helper references
+        if (ref.referenceName.endsWith('Helper')) {
+            const result = resolveHelper(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 4: Service/Job references
+        if (ref.referenceName.endsWith('Service') || ref.referenceName.endsWith('Job')) {
+            const result = resolveService(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.rb'))
+            return { nodes: [], references: [] };
+        const nodes = [];
+        const references = [];
+        const now = Date.now();
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'ruby');
+        // get/post/put/patch/delete/match '/path', to: 'controller#action'
+        // Also: get '/path' => 'controller#action'
+        const routeRegex = /\b(get|post|put|patch|delete|match)\s+['"]([^'"]+)['"]\s*(?:,\s*to:\s*|=>\s*)['"]([^#'"]+)#([^'"]+)['"]/g;
+        let match;
+        while ((match = routeRegex.exec(safe)) !== null) {
+            const [, method, routePath, _controller, action] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const upper = method.toUpperCase();
+            const routeNode = {
+                id: `route:${filePath}:${line}:${upper}:${routePath}`,
+                kind: 'route',
+                name: `${upper} ${routePath}`,
+                qualifiedName: `${filePath}::route:${routePath}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'ruby',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            references.push({
+                fromNodeId: routeNode.id,
+                referenceName: action,
+                referenceKind: 'references',
+                line,
+                column: 0,
+                filePath,
+                language: 'ruby',
+            });
+        }
+        return { nodes, references };
+    },
+};
+// Helper functions
+function resolveModel(name, context) {
+    // Try direct file path lookup first (Rails convention: CamelCase -> snake_case.rb)
+    const snakeName = name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
+    const possiblePaths = [
+        `app/models/${snakeName}.rb`,
+        `app/models/concerns/${snakeName}.rb`,
+    ];
+    for (const modelPath of possiblePaths) {
+        if (context.fileExists(modelPath)) {
+            const nodes = context.getNodesInFile(modelPath);
+            const modelNode = nodes.find((n) => n.kind === 'class' && n.name === name);
+            if (modelNode) {
+                return modelNode.id;
+            }
+        }
+    }
+    // Fall back to name-based lookup
+    const candidates = context.getNodesByName(name);
+    const modelNode = candidates.find((n) => n.kind === 'class' && n.filePath.includes('app/models/'));
+    if (modelNode)
+        return modelNode.id;
+    return null;
+}
+function resolveController(name, context) {
+    // Try direct file path lookup first
+    const snakeName = name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
+    const possiblePaths = [
+        `app/controllers/${snakeName}.rb`,
+        `app/controllers/api/${snakeName}.rb`,
+        `app/controllers/api/v1/${snakeName}.rb`,
+    ];
+    for (const controllerPath of possiblePaths) {
+        if (context.fileExists(controllerPath)) {
+            const nodes = context.getNodesInFile(controllerPath);
+            const controllerNode = nodes.find((n) => n.kind === 'class' && n.name === name);
+            if (controllerNode) {
+                return controllerNode.id;
+            }
+        }
+    }
+    // Fall back to name-based lookup
+    const candidates = context.getNodesByName(name);
+    const controllerNode = candidates.find((n) => n.kind === 'class' && n.filePath.includes('controllers/'));
+    if (controllerNode)
+        return controllerNode.id;
+    return null;
+}
+function resolveHelper(name, context) {
+    const snakeName = name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
+    const helperPath = `app/helpers/${snakeName}.rb`;
+    if (context.fileExists(helperPath)) {
+        const nodes = context.getNodesInFile(helperPath);
+        const helperNode = nodes.find((n) => n.kind === 'module' && n.name === name);
+        if (helperNode) {
+            return helperNode.id;
+        }
+    }
+    return null;
+}
+function resolveService(name, context) {
+    const snakeName = name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
+    const possiblePaths = [
+        `app/services/${snakeName}.rb`,
+        `app/jobs/${snakeName}.rb`,
+        `app/workers/${snakeName}.rb`,
+    ];
+    for (const servicePath of possiblePaths) {
+        if (context.fileExists(servicePath)) {
+            const nodes = context.getNodesInFile(servicePath);
+            const serviceNode = nodes.find((n) => n.kind === 'class' && n.name === name);
+            if (serviceNode) {
+                return serviceNode.id;
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=ruby.js.map

package/dist/resolution/frameworks/rust.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust Framework Resolver
+ *
+ * Handles Actix-web, Rocket, Axum, and common Rust patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const rustResolver: FrameworkResolver
+//# sourceMappingURL=rust.d.ts.map

package/dist/resolution/frameworks/rust.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Rust Framework Resolver
+ *
+ * Handles Actix-web, Rocket, Axum, and common Rust patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustResolver = void 0;
+const strip_comments_1 = require("../strip-comments");
+const cargo_workspace_1 = require("./cargo-workspace");
+const cargoWorkspaceMapCache = new WeakMap();
+function getCachedCargoWorkspaceCrateMap(context) {
+    const cached = cargoWorkspaceMapCache.get(context);
+    if (cached)
+        return cached;
+    const map = (0, cargo_workspace_1.getCargoWorkspaceCrateMap)(context);
+    cargoWorkspaceMapCache.set(context, map);
+    return map;
+}
+exports.rustResolver = {
+    name: 'rust',
+    languages: ['rust'],
+    detect(context) {
+        // Check for Cargo.toml (Rust project signature)
+        return context.fileExists('Cargo.toml');
+    },
+    resolve(ref, context) {
+        // Pattern 1: Handler references
+        if (ref.referenceName.endsWith('_handler') || ref.referenceName.startsWith('handle_')) {
+            const result = resolveByNameAndKind(ref.referenceName, FUNCTION_KINDS, HANDLER_DIRS, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 2: Service/Repository trait implementations
+        if (ref.referenceName.endsWith('Service') || ref.referenceName.endsWith('Repository')) {
+            const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, SERVICE_DIRS, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 3: Struct references (PascalCase)
+        if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {
+            const result = resolveByNameAndKind(ref.referenceName, STRUCT_KINDS, MODEL_DIRS, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.7,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 4: Module references
+        if (/^[a-z_]+$/.test(ref.referenceName)) {
+            const result = resolveModule(ref.referenceName, context);
+            if (result) {
+                // Workspace-manifest hits are an exact crate-name -> crate-root
+                // mapping straight from Cargo.toml, so we trust them above
+                // name-matcher self-file matches (which otherwise win at 0.7
+                // because every file containing `use foo::...` has its own
+                // import node named `foo`).
+                return {
+                    original: ref,
+                    targetNodeId: result.targetId,
+                    confidence: result.fromWorkspace ? 0.95 : 0.6,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.rs'))
+            return { nodes: [], references: [] };
+        const nodes = [];
+        const references = [];
+        const now = Date.now();
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'rust');
+        // Actix-web / Rocket attribute: #[get("/path")] fn handler(..)
+        // Capture the method, path, and the fn identifier that follows.
+        const attrRegex = /#\[(get|post|put|patch|delete|head|options)\s*\(\s*["']([^"']+)["'][^\]]*\)\]/g;
+        let match;
+        while ((match = attrRegex.exec(safe)) !== null) {
+            const [, method, routePath] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const upper = method.toUpperCase();
+            const routeNode = {
+                id: `route:${filePath}:${line}:${upper}:${routePath}`,
+                kind: 'route',
+                name: `${upper} ${routePath}`,
+                qualifiedName: `${filePath}::route:${routePath}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'rust',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            const tail = safe.slice(match.index + match[0].length);
+            const fnMatch = tail.match(/\n\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+            if (fnMatch) {
+                references.push({
+                    fromNodeId: routeNode.id,
+                    referenceName: fnMatch[1],
+                    referenceKind: 'references',
+                    line,
+                    column: 0,
+                    filePath,
+                    language: 'rust',
+                });
+            }
+        }
+        // Axum: .route("/path", get(handler))
+        const axumRegex = /\.route\s*\(\s*"([^"]+)"\s*,\s*(get|post|put|patch|delete)\s*\(\s*(\w+)/g;
+        while ((match = axumRegex.exec(safe)) !== null) {
+            const [, routePath, method, handler] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const upper = method.toUpperCase();
+            const routeNode = {
+                id: `route:${filePath}:${line}:${upper}:${routePath}`,
+                kind: 'route',
+                name: `${upper} ${routePath}`,
+                qualifiedName: `${filePath}::route:${routePath}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'rust',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            references.push({
+                fromNodeId: routeNode.id,
+                referenceName: handler,
+                referenceKind: 'references',
+                line,
+                column: 0,
+                filePath,
+                language: 'rust',
+            });
+        }
+        return { nodes, references };
+    },
+};
+// Directory patterns
+const HANDLER_DIRS = ['/handlers/', '/handler/', '/api/', '/routes/', '/controllers/'];
+const SERVICE_DIRS = ['/services/', '/service/', '/repository/', '/domain/'];
+const MODEL_DIRS = ['/models/', '/model/', '/entities/', '/entity/', '/domain/', '/types/'];
+const FUNCTION_KINDS = new Set(['function']);
+const SERVICE_KINDS = new Set(['struct', 'trait']);
+const STRUCT_KINDS = new Set(['struct']);
+/**
+ * Resolve a symbol by name using indexed queries instead of scanning all files.
+ */
+function resolveByNameAndKind(name, kinds, preferredDirPatterns, context) {
+    const candidates = context.getNodesByName(name);
+    if (candidates.length === 0)
+        return null;
+    const kindFiltered = candidates.filter((n) => kinds.has(n.kind));
+    if (kindFiltered.length === 0)
+        return null;
+    // Prefer candidates in framework-conventional directories
+    const preferred = kindFiltered.filter((n) => preferredDirPatterns.some((d) => n.filePath.includes(d)));
+    if (preferred.length > 0)
+        return preferred[0].id;
+    // Fall back to any match
+    return kindFiltered[0].id;
+}
+function resolveModule(name, context) {
+    // Rust modules can be either mod.rs in a directory or name.rs
+    const localPaths = [`src/${name}.rs`, `src/${name}/mod.rs`];
+    const workspaceCrates = getCachedCargoWorkspaceCrateMap(context);
+    const cratePath = workspaceCrates.get(name);
+    const workspacePaths = cratePath
+        ? [`${cratePath}/src/lib.rs`, `${cratePath}/src/main.rs`]
+        : [];
+    const candidates = [
+        ...localPaths.map((path) => ({ path, fromWorkspace: false })),
+        ...workspacePaths.map((path) => ({ path, fromWorkspace: true })),
+    ];
+    for (const { path: modPath, fromWorkspace } of candidates) {
+        if (!context.fileExists(modPath))
+            continue;
+        const nodes = context.getNodesInFile(modPath);
+        const modNode = nodes.find((n) => n.kind === 'module');
+        if (modNode)
+            return { targetId: modNode.id, fromWorkspace };
+        if (nodes.length > 0)
+            return { targetId: nodes[0].id, fromWorkspace };
+    }
+    return null;
+}
+//# sourceMappingURL=rust.js.map

package/dist/resolution/frameworks/svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Svelte / SvelteKit Framework Resolver
+ *
+ * Handles Svelte component references, Svelte 5 runes,
+ * store auto-subscriptions, and SvelteKit route/module patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const svelteResolver: FrameworkResolver
+//# sourceMappingURL=svelte.d.ts.map

package/dist/resolution/frameworks/svelte.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * Svelte / SvelteKit Framework Resolver
+ *
+ * Handles Svelte component references, Svelte 5 runes,
+ * store auto-subscriptions, and SvelteKit route/module patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.svelteResolver = void 0;
+/**
+ * Svelte 5 runes — compiler-provided, not user code
+ */
+const SVELTE_RUNES = new Set([
+    '$state',
+    '$state.raw',
+    '$state.snapshot',
+    '$derived',
+    '$derived.by',
+    '$effect',
+    '$effect.pre',
+    '$effect.root',
+    '$effect.tracking',
+    '$props',
+    '$bindable',
+    '$inspect',
+    '$host',
+]);
+/**
+ * SvelteKit framework-provided module prefixes
+ */
+const SVELTEKIT_MODULE_PREFIXES = [
+    '$app/navigation',
+    '$app/stores',
+    '$app/environment',
+    '$app/forms',
+    '$app/paths',
+    '$env/static/private',
+    '$env/static/public',
+    '$env/dynamic/private',
+    '$env/dynamic/public',
+];
+exports.svelteResolver = {
+    name: 'svelte',
+    languages: ['svelte'],
+    detect(context) {
+        // Check for svelte or @sveltejs/kit in package.json
+        const packageJson = context.readFile('package.json');
+        if (packageJson) {
+            try {
+                const pkg = JSON.parse(packageJson);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps.svelte || deps['@sveltejs/kit']) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid JSON
+            }
+        }
+        // Check for .svelte files in project
+        const allFiles = context.getAllFiles();
+        return allFiles.some((f) => f.endsWith('.svelte'));
+    },
+    resolve(ref, context) {
+        // Pattern 1: Svelte runes ($state, $derived, $effect, etc.)
+        if (isRuneReference(ref.referenceName)) {
+            // Runes are compiler-provided — return a high-confidence "framework" resolution
+            // so CodeGraph doesn't waste time searching for user-defined symbols.
+            // We use the fromNodeId as targetNodeId since runes don't have real targets.
+            return {
+                original: ref,
+                targetNodeId: ref.fromNodeId,
+                confidence: 1.0,
+                resolvedBy: 'framework',
+            };
+        }
+        // Pattern 2: Store auto-subscriptions ($storeName)
+        if (ref.referenceName.startsWith('$') && !ref.referenceName.startsWith('$$')) {
+            const storeName = ref.referenceName.substring(1);
+            const storeNode = context.getNodesByName(storeName).find((n) => n.kind === 'variable' || n.kind === 'constant');
+            if (storeNode) {
+                return {
+                    original: ref,
+                    targetNodeId: storeNode.id,
+                    confidence: 0.85,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 3: SvelteKit module imports ($app/*, $env/*, $lib/*)
+        if (ref.referenceKind === 'imports' && ref.referenceName.startsWith('$')) {
+            // $lib/* resolves to src/lib/* — try to find the target file
+            if (ref.referenceName.startsWith('$lib/')) {
+                const libPath = ref.referenceName.replace('$lib/', 'src/lib/');
+                // Try common extensions
+                for (const ext of ['', '.ts', '.js', '.svelte', '/index.ts', '/index.js']) {
+                    const fullPath = libPath + ext;
+                    if (context.fileExists(fullPath)) {
+                        const nodes = context.getNodesInFile(fullPath);
+                        if (nodes.length > 0) {
+                            return {
+                                original: ref,
+                                targetNodeId: nodes[0].id,
+                                confidence: 0.9,
+                                resolvedBy: 'framework',
+                            };
+                        }
+                    }
+                }
+            }
+            // $app/* and $env/* are framework-provided
+            if (SVELTEKIT_MODULE_PREFIXES.some((prefix) => ref.referenceName.startsWith(prefix))) {
+                return {
+                    original: ref,
+                    targetNodeId: ref.fromNodeId,
+                    confidence: 1.0,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 4: Component references (PascalCase) — resolve to .svelte files
+        if (isPascalCase(ref.referenceName) && ref.referenceKind === 'calls') {
+            const result = resolveComponent(ref.referenceName, ref.filePath, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, _content) {
+        const nodes = [];
+        const now = Date.now();
+        // Detect SvelteKit route files
+        const fileName = filePath.split(/[/\\]/).pop() || '';
+        const routeMatch = getSvelteKitRouteInfo(fileName);
+        if (routeMatch) {
+            // Extract route path from directory structure
+            // e.g., src/routes/blog/[slug]/+page.svelte -> /blog/:slug
+            const routePath = filePathToSvelteKitRoute(filePath);
+            if (routePath) {
+                nodes.push({
+                    id: `route:${filePath}:${routePath}:1`,
+                    kind: 'route',
+                    name: routePath,
+                    qualifiedName: `${filePath}::route:${routePath}`,
+                    filePath,
+                    startLine: 1,
+                    endLine: 1,
+                    startColumn: 0,
+                    endColumn: 0,
+                    language: filePath.endsWith('.svelte') ? 'svelte' : 'typescript',
+                    updatedAt: now,
+                });
+            }
+        }
+        return { nodes, references: [] };
+    },
+};
+/**
+ * Check if a reference name is a Svelte rune
+ */
+function isRuneReference(name) {
+    // Direct match (e.g. $state, $derived)
+    if (SVELTE_RUNES.has(name))
+        return true;
+    // Rune method calls come through as the base rune name
+    // e.g. $state.raw -> the call is to "$state" with ".raw" accessed as property
+    // Check if it's a base rune that has sub-methods
+    if (name === '$state' || name === '$derived' || name === '$effect')
+        return true;
+    return false;
+}
+/**
+ * Check if string is PascalCase
+ */
+function isPascalCase(str) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+/**
+ * Resolve a Svelte component reference using name-based lookup
+ */
+function resolveComponent(name, fromFile, context) {
+    // Look for component nodes by name
+    const candidates = context.getNodesByName(name);
+    const components = candidates.filter((n) => n.kind === 'component');
+    if (components.length === 0)
+        return null;
+    // Prefer same directory
+    const fromDir = fromFile.substring(0, fromFile.lastIndexOf('/'));
+    const sameDir = components.filter((n) => n.filePath.startsWith(fromDir));
+    if (sameDir.length > 0)
+        return sameDir[0].id;
+    return components[0].id;
+}
+/**
+ * SvelteKit route file patterns
+ */
+const SVELTEKIT_ROUTE_FILES = {
+    '+page.svelte': 'page',
+    '+page.ts': 'page-load',
+    '+page.js': 'page-load',
+    '+page.server.ts': 'page-server-load',
+    '+page.server.js': 'page-server-load',
+    '+layout.svelte': 'layout',
+    '+layout.ts': 'layout-load',
+    '+layout.js': 'layout-load',
+    '+layout.server.ts': 'layout-server-load',
+    '+layout.server.js': 'layout-server-load',
+    '+server.ts': 'api-endpoint',
+    '+server.js': 'api-endpoint',
+    '+error.svelte': 'error-page',
+};
+/**
+ * Check if filename is a SvelteKit route file
+ */
+function getSvelteKitRouteInfo(fileName) {
+    return SVELTEKIT_ROUTE_FILES[fileName] || null;
+}
+/**
+ * Convert a file path to a SvelteKit route path
+ */
+function filePathToSvelteKitRoute(filePath) {
+    // Normalize to forward slashes
+    const normalized = filePath.replace(/\\/g, '/');
+    // Find the routes directory
+    const routesIndex = normalized.indexOf('/routes/');
+    if (routesIndex === -1)
+        return null;
+    // Extract the path after routes/
+    const afterRoutes = normalized.substring(routesIndex + '/routes/'.length);
+    // Remove the file name
+    const lastSlash = afterRoutes.lastIndexOf('/');
+    const dirPath = lastSlash === -1 ? '' : afterRoutes.substring(0, lastSlash);
+    // Convert SvelteKit param syntax [param] to :param
+    let route = '/' + dirPath
+        .replace(/\[\.\.\.([^\]]+)\]/g, '*$1') // [...rest] -> *rest
+        .replace(/\[{2}([^\]]+)\]{2}/g, ':$1?') // [[optional]] -> :optional?
+        .replace(/\[([^\]]+)\]/g, ':$1'); // [param] -> :param
+    if (route === '/')
+        return '/';
+    // Remove trailing slash
+    return route.replace(/\/$/, '');
+}
+//# sourceMappingURL=svelte.js.map

package/dist/resolution/frameworks/swift.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Swift Framework Resolver
+ *
+ * Handles SwiftUI, UIKit, and Vapor (server-side Swift) patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const swiftUIResolver: FrameworkResolver
+export declare const uikitResolver: FrameworkResolver
+export declare const vaporResolver: FrameworkResolver
+//# sourceMappingURL=swift.d.ts.map