@living-architecture/riviere-builder 0.2.1

package/dist/component-suggestion.d.ts

@@ -0,0 +1,35 @@
+import type { Component, ComponentId } from '@living-architecture/riviere-schema';
+import { ComponentNotFoundError } from './errors';
+import type { NearMatchOptions, NearMatchQuery, NearMatchResult } from './types';
+/**
+ * Finds components similar to a query using fuzzy matching.
+ *
+ * Used for error recovery to suggest alternatives when exact matches fail.
+ *
+ * @param components - Array of components to search
+ * @param query - Search criteria with name and optional type/domain filters
+ * @param options - Optional threshold and limit settings
+ * @returns Array of matching components with similarity scores
+ *
+ * @example
+ * ```typescript
+ * const matches = findNearMatches(components, { name: 'Create Ordr' })
+ * // [{ component: {...}, score: 0.9, mismatch: undefined }]
+ * ```
+ */
+export declare function findNearMatches(components: Component[], query: NearMatchQuery, options?: NearMatchOptions): NearMatchResult[];
+/**
+ * Creates a typed error with suggestions for a missing source component.
+ *
+ * @param components - Array of existing components to search for suggestions
+ * @param id - The ComponentId that was not found
+ * @returns ComponentNotFoundError with suggestions array for programmatic access
+ *
+ * @example
+ * ```typescript
+ * const error = createSourceNotFoundError(components, ComponentId.parse('orders:checkout:api:create-ordr'))
+ * // ComponentNotFoundError with suggestions: ['orders:checkout:api:create-order']
+ * ```
+ */
+export declare function createSourceNotFoundError(components: Component[], id: ComponentId): ComponentNotFoundError;
+//# sourceMappingURL=component-suggestion.d.ts.map

package/dist/component-suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-suggestion.d.ts","sourceRoot":"","sources":["../src/component-suggestion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEjD,OAAO,KAAK,EAAqB,gBAAgB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAoBnG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,SAAS,EAAE,EACvB,KAAK,EAAE,cAAc,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,eAAe,EAAE,CAmBnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,WAAW,GAAG,sBAAsB,CAI1G"}

package/dist/component-suggestion.js

@@ -0,0 +1,66 @@
+import { ComponentNotFoundError } from './errors';
+import { similarityScore } from './string-similarity';
+function detectMismatch(query, component) {
+    const nameMatches = query.name.toLowerCase() === component.name.toLowerCase();
+    if (!nameMatches) {
+        return undefined;
+    }
+    if (query.type !== undefined && query.type !== component.type) {
+        return { field: 'type', expected: query.type, actual: component.type };
+    }
+    if (query.domain !== undefined && query.domain !== component.domain) {
+        return { field: 'domain', expected: query.domain, actual: component.domain };
+    }
+    return undefined;
+}
+/**
+ * Finds components similar to a query using fuzzy matching.
+ *
+ * Used for error recovery to suggest alternatives when exact matches fail.
+ *
+ * @param components - Array of components to search
+ * @param query - Search criteria with name and optional type/domain filters
+ * @param options - Optional threshold and limit settings
+ * @returns Array of matching components with similarity scores
+ *
+ * @example
+ * ```typescript
+ * const matches = findNearMatches(components, { name: 'Create Ordr' })
+ * // [{ component: {...}, score: 0.9, mismatch: undefined }]
+ * ```
+ */
+export function findNearMatches(components, query, options) {
+    if (query.name === '') {
+        return [];
+    }
+    const threshold = options?.threshold ?? 0.6;
+    const limit = options?.limit ?? 10;
+    const results = components
+        .map((component) => {
+        const score = similarityScore(query.name, component.name);
+        const mismatch = detectMismatch(query, component);
+        return { component, score, mismatch };
+    })
+        .filter((result) => result.score >= threshold || result.mismatch !== undefined)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return results;
+}
+/**
+ * Creates a typed error with suggestions for a missing source component.
+ *
+ * @param components - Array of existing components to search for suggestions
+ * @param id - The ComponentId that was not found
+ * @returns ComponentNotFoundError with suggestions array for programmatic access
+ *
+ * @example
+ * ```typescript
+ * const error = createSourceNotFoundError(components, ComponentId.parse('orders:checkout:api:create-ordr'))
+ * // ComponentNotFoundError with suggestions: ['orders:checkout:api:create-order']
+ * ```
+ */
+export function createSourceNotFoundError(components, id) {
+    const matches = findNearMatches(components, { name: id.name() }, { limit: 3 });
+    const suggestions = matches.map((s) => s.component.id);
+    return new ComponentNotFoundError(id.toString(), suggestions);
+}

package/dist/errors.d.ts

@@ -0,0 +1,28 @@
+export declare class DuplicateDomainError extends Error {
+    readonly domainName: string;
+    constructor(domainName: string);
+}
+export declare class DomainNotFoundError extends Error {
+    readonly domainName: string;
+    constructor(domainName: string);
+}
+export declare class CustomTypeNotFoundError extends Error {
+    readonly customTypeName: string;
+    readonly definedTypes: string[];
+    constructor(customTypeName: string, definedTypes: string[]);
+}
+export declare class DuplicateComponentError extends Error {
+    readonly componentId: string;
+    constructor(componentId: string);
+}
+export declare class ComponentNotFoundError extends Error {
+    readonly componentId: string;
+    readonly suggestions: string[];
+    constructor(componentId: string, suggestions?: string[]);
+}
+export declare class InvalidEnrichmentTargetError extends Error {
+    readonly componentId: string;
+    readonly componentType: string;
+    constructor(componentId: string, componentType: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;gBAEf,UAAU,EAAE,MAAM;CAK/B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;gBAEf,UAAU,EAAE,MAAM;CAK/B;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAA;gBAEnB,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE;CAU3D;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;gBAEhB,WAAW,EAAE,MAAM;CAKhC;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAA;gBAElB,WAAW,EAAE,MAAM,EAAE,WAAW,GAAE,MAAM,EAAO;CAS5D;AAED,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;gBAElB,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;CAMvD"}

package/dist/errors.js

@@ -0,0 +1,59 @@
+export class DuplicateDomainError extends Error {
+    domainName;
+    constructor(domainName) {
+        super(`Domain '${domainName}' already exists`);
+        this.name = 'DuplicateDomainError';
+        this.domainName = domainName;
+    }
+}
+export class DomainNotFoundError extends Error {
+    domainName;
+    constructor(domainName) {
+        super(`Domain '${domainName}' does not exist`);
+        this.name = 'DomainNotFoundError';
+        this.domainName = domainName;
+    }
+}
+export class CustomTypeNotFoundError extends Error {
+    customTypeName;
+    definedTypes;
+    constructor(customTypeName, definedTypes) {
+        const suffix = definedTypes.length === 0
+            ? 'No custom types have been defined.'
+            : `Defined types: ${definedTypes.join(', ')}`;
+        super(`Custom type '${customTypeName}' not defined. ${suffix}`);
+        this.name = 'CustomTypeNotFoundError';
+        this.customTypeName = customTypeName;
+        this.definedTypes = definedTypes;
+    }
+}
+export class DuplicateComponentError extends Error {
+    componentId;
+    constructor(componentId) {
+        super(`Component with ID '${componentId}' already exists`);
+        this.name = 'DuplicateComponentError';
+        this.componentId = componentId;
+    }
+}
+export class ComponentNotFoundError extends Error {
+    componentId;
+    suggestions;
+    constructor(componentId, suggestions = []) {
+        const baseMessage = `Source component '${componentId}' not found`;
+        const message = suggestions.length > 0 ? `${baseMessage}. Did you mean: ${suggestions.join(', ')}?` : baseMessage;
+        super(message);
+        this.name = 'ComponentNotFoundError';
+        this.componentId = componentId;
+        this.suggestions = suggestions;
+    }
+}
+export class InvalidEnrichmentTargetError extends Error {
+    componentId;
+    componentType;
+    constructor(componentId, componentType) {
+        super(`Only DomainOp components can be enriched. '${componentId}' is type '${componentType}'`);
+        this.name = 'InvalidEnrichmentTargetError';
+        this.componentId = componentId;
+        this.componentType = componentType;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './builder';
+export { ComponentId, type ComponentIdParts } from '@living-architecture/riviere-schema';
+export * from './errors';
+export { findNearMatches } from './component-suggestion';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACzF,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './builder';
+export { ComponentId } from '@living-architecture/riviere-schema';
+export * from './errors';
+export { findNearMatches } from './component-suggestion';

package/dist/inspection.d.ts

@@ -0,0 +1,90 @@
+import type { Component, CustomTypeDefinition, DomainMetadata, ExternalLink, Link, RiviereGraph, SourceInfo } from '@living-architecture/riviere-schema';
+import { type ValidationResult } from '@living-architecture/riviere-query';
+import type { BuilderStats, BuilderWarning } from './types';
+interface InspectionGraph {
+    version: string;
+    metadata: {
+        name?: string;
+        description?: string;
+        generated?: string;
+        sources: SourceInfo[];
+        domains: Record<string, DomainMetadata>;
+        customTypes: Record<string, CustomTypeDefinition>;
+    };
+    components: Component[];
+    links: Link[];
+    externalLinks: ExternalLink[];
+}
+/**
+ * Finds components with no incoming or outgoing links.
+ *
+ * @param graph - The graph to inspect
+ * @returns Array of orphaned component IDs
+ *
+ * @example
+ * ```typescript
+ * const orphans = findOrphans(graph)
+ * // ['orders:checkout:api:unused-endpoint']
+ * ```
+ */
+export declare function findOrphans(graph: InspectionGraph): string[];
+/**
+ * Calculates statistics about the graph.
+ *
+ * @param graph - The graph to analyze
+ * @returns Object with component counts, link counts, and domain count
+ *
+ * @example
+ * ```typescript
+ * const stats = calculateStats(graph)
+ * // { componentCount: 10, linkCount: 8, domainCount: 2, ... }
+ * ```
+ */
+export declare function calculateStats(graph: InspectionGraph): BuilderStats;
+/**
+ * Finds non-fatal issues in the graph.
+ *
+ * Detects orphaned components and unused domains.
+ *
+ * @param graph - The graph to inspect
+ * @returns Array of warning objects
+ *
+ * @example
+ * ```typescript
+ * const warnings = findWarnings(graph)
+ * // [{ code: 'ORPHAN_COMPONENT', message: '...', componentId: '...' }]
+ * ```
+ */
+export declare function findWarnings(graph: InspectionGraph): BuilderWarning[];
+/**
+ * Converts builder internal graph to schema-compliant RiviereGraph.
+ *
+ * Removes undefined optional fields and ensures proper structure.
+ *
+ * @param graph - The internal builder graph
+ * @returns Schema-compliant RiviereGraph
+ *
+ * @example
+ * ```typescript
+ * const output = toRiviereGraph(builderGraph)
+ * JSON.stringify(output) // Valid Rivière JSON
+ * ```
+ */
+export declare function toRiviereGraph(graph: InspectionGraph): RiviereGraph;
+/**
+ * Validates the graph against the Rivière schema.
+ *
+ * @param graph - The graph to validate
+ * @returns Validation result with valid flag and any errors
+ *
+ * @example
+ * ```typescript
+ * const result = validateGraph(graph)
+ * if (!result.valid) {
+ *   console.error(result.errors)
+ * }
+ * ```
+ */
+export declare function validateGraph(graph: InspectionGraph): ValidationResult;
+export {};
+//# sourceMappingURL=inspection.d.ts.map

package/dist/inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.ts","sourceRoot":"","sources":["../src/inspection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,oBAAoB,EACpB,cAAc,EACd,YAAY,EACZ,IAAI,EACJ,YAAY,EACZ,UAAU,EACX,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE3D,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,EAAE,UAAU,EAAE,CAAA;QACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;KAClD,CAAA;IACD,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,EAAE,CAa5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAiBnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,cAAc,EAAE,CAuBrE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAiBnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAEtE"}

package/dist/inspection.js

@@ -0,0 +1,137 @@
+import { RiviereQuery } from '@living-architecture/riviere-query';
+/**
+ * Finds components with no incoming or outgoing links.
+ *
+ * @param graph - The graph to inspect
+ * @returns Array of orphaned component IDs
+ *
+ * @example
+ * ```typescript
+ * const orphans = findOrphans(graph)
+ * // ['orders:checkout:api:unused-endpoint']
+ * ```
+ */
+export function findOrphans(graph) {
+    const connectedIds = new Set();
+    for (const link of graph.links) {
+        connectedIds.add(link.source);
+        connectedIds.add(link.target);
+    }
+    for (const externalLink of graph.externalLinks) {
+        connectedIds.add(externalLink.source);
+    }
+    return graph.components.filter((c) => !connectedIds.has(c.id)).map((c) => c.id);
+}
+/**
+ * Calculates statistics about the graph.
+ *
+ * @param graph - The graph to analyze
+ * @returns Object with component counts, link counts, and domain count
+ *
+ * @example
+ * ```typescript
+ * const stats = calculateStats(graph)
+ * // { componentCount: 10, linkCount: 8, domainCount: 2, ... }
+ * ```
+ */
+export function calculateStats(graph) {
+    const components = graph.components;
+    return {
+        componentCount: components.length,
+        componentsByType: {
+            UI: components.filter((c) => c.type === 'UI').length,
+            API: components.filter((c) => c.type === 'API').length,
+            UseCase: components.filter((c) => c.type === 'UseCase').length,
+            DomainOp: components.filter((c) => c.type === 'DomainOp').length,
+            Event: components.filter((c) => c.type === 'Event').length,
+            EventHandler: components.filter((c) => c.type === 'EventHandler').length,
+            Custom: components.filter((c) => c.type === 'Custom').length,
+        },
+        linkCount: graph.links.length,
+        externalLinkCount: graph.externalLinks.length,
+        domainCount: Object.keys(graph.metadata.domains).length,
+    };
+}
+/**
+ * Finds non-fatal issues in the graph.
+ *
+ * Detects orphaned components and unused domains.
+ *
+ * @param graph - The graph to inspect
+ * @returns Array of warning objects
+ *
+ * @example
+ * ```typescript
+ * const warnings = findWarnings(graph)
+ * // [{ code: 'ORPHAN_COMPONENT', message: '...', componentId: '...' }]
+ * ```
+ */
+export function findWarnings(graph) {
+    const warnings = [];
+    for (const id of findOrphans(graph)) {
+        warnings.push({
+            code: 'ORPHAN_COMPONENT',
+            message: `Component '${id}' has no incoming or outgoing links`,
+            componentId: id,
+        });
+    }
+    const usedDomains = new Set(graph.components.map((c) => c.domain));
+    for (const domain of Object.keys(graph.metadata.domains)) {
+        if (!usedDomains.has(domain)) {
+            warnings.push({
+                code: 'UNUSED_DOMAIN',
+                message: `Domain '${domain}' is declared but has no components`,
+                domainName: domain,
+            });
+        }
+    }
+    return warnings;
+}
+/**
+ * Converts builder internal graph to schema-compliant RiviereGraph.
+ *
+ * Removes undefined optional fields and ensures proper structure.
+ *
+ * @param graph - The internal builder graph
+ * @returns Schema-compliant RiviereGraph
+ *
+ * @example
+ * ```typescript
+ * const output = toRiviereGraph(builderGraph)
+ * JSON.stringify(output) // Valid Rivière JSON
+ * ```
+ */
+export function toRiviereGraph(graph) {
+    const hasCustomTypes = Object.keys(graph.metadata.customTypes).length > 0;
+    const hasExternalLinks = graph.externalLinks.length > 0;
+    return {
+        version: graph.version,
+        metadata: {
+            ...(graph.metadata.name !== undefined && { name: graph.metadata.name }),
+            ...(graph.metadata.description !== undefined && { description: graph.metadata.description }),
+            sources: graph.metadata.sources,
+            domains: graph.metadata.domains,
+            ...(hasCustomTypes && { customTypes: graph.metadata.customTypes }),
+        },
+        components: graph.components,
+        links: graph.links,
+        ...(hasExternalLinks && { externalLinks: graph.externalLinks }),
+    };
+}
+/**
+ * Validates the graph against the Rivière schema.
+ *
+ * @param graph - The graph to validate
+ * @returns Validation result with valid flag and any errors
+ *
+ * @example
+ * ```typescript
+ * const result = validateGraph(graph)
+ * if (!result.valid) {
+ *   console.error(result.errors)
+ * }
+ * ```
+ */
+export function validateGraph(graph) {
+    return new RiviereQuery(toRiviereGraph(graph)).validate();
+}

package/dist/string-similarity.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Calculates the Levenshtein edit distance between two strings.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Number of single-character edits needed to transform a into b
+ *
+ * @example
+ * ```typescript
+ * levenshteinDistance('kitten', 'sitting') // 3
+ * levenshteinDistance('hello', 'hello') // 0
+ * ```
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Calculates normalized similarity score between two strings.
+ *
+ * Returns 1.0 for identical strings, 0.0 for completely different strings.
+ * Case-insensitive comparison.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score from 0.0 to 1.0
+ *
+ * @example
+ * ```typescript
+ * similarityScore('Order', 'order') // 1.0
+ * similarityScore('Order', 'Ordr') // 0.8
+ * ```
+ */
+export declare function similarityScore(a: string, b: string): number;
+//# sourceMappingURL=string-similarity.d.ts.map

package/dist/string-similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-similarity.d.ts","sourceRoot":"","sources":["../src/string-similarity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqBhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAW5D"}

package/dist/string-similarity.js

@@ -0,0 +1,61 @@
+/**
+ * Calculates the Levenshtein edit distance between two strings.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Number of single-character edits needed to transform a into b
+ *
+ * @example
+ * ```typescript
+ * levenshteinDistance('kitten', 'sitting') // 3
+ * levenshteinDistance('hello', 'hello') // 0
+ * ```
+ */
+export function levenshteinDistance(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const previousRow = Array.from({ length: b.length + 1 }, (_, j) => j);
+    const finalRow = [...a].reduce((currentRow, aChar, i) => {
+        const nextRow = [i + 1];
+        return [...b].reduce((row, bChar, j) => {
+            const cost = aChar === bChar ? 0 : 1;
+            const deletion = currentRow[j + 1];
+            const insertion = row[j];
+            const substitution = currentRow[j];
+            /* v8 ignore next -- @preserve */
+            const value = Math.min((insertion ?? 0) + 1, (deletion ?? 0) + 1, (substitution ?? 0) + cost);
+            return [...row, value];
+        }, nextRow);
+    }, previousRow);
+    /* v8 ignore next -- @preserve */
+    return finalRow[b.length] ?? 0;
+}
+/**
+ * Calculates normalized similarity score between two strings.
+ *
+ * Returns 1.0 for identical strings, 0.0 for completely different strings.
+ * Case-insensitive comparison.
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score from 0.0 to 1.0
+ *
+ * @example
+ * ```typescript
+ * similarityScore('Order', 'order') // 1.0
+ * similarityScore('Order', 'Ordr') // 0.8
+ * ```
+ */
+export function similarityScore(a, b) {
+    const aLower = a.toLowerCase();
+    const bLower = b.toLowerCase();
+    if (aLower.length === 0 && bLower.length === 0)
+        return 1.0;
+    if (aLower.length === 0 || bLower.length === 0)
+        return 0.0;
+    const distance = levenshteinDistance(aLower, bLower);
+    const maxLength = Math.max(aLower.length, bLower.length);
+    return 1 - distance / maxLength;
+}