@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/entity-details.tool.test.js

@@ -1,146 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { initKtxProject } from '../../../project/index.js';
-import { WarehouseCatalogService } from '../../../scan/warehouse-catalog.js';
-import { EntityDetailsTool } from './entity-details.tool.js';
-describe('EntityDetailsTool', () => {
-    let tempDir;
-    let project;
-    let tool;
-    let context;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-entity-details-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-        await seedLiveDatabaseScan();
-        tool = new EntityDetailsTool(() => new WarehouseCatalogService({ fileStore: project.fileStore }));
-        context = {
-            sourceId: 'ingest',
-            messageId: 'm1',
-            userId: 'system',
-            session: {
-                allowedConnectionNames: new Set(['warehouse']),
-            },
-        };
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    async function seedLiveDatabaseScan(connectionId = 'warehouse', syncId = 'sync-1') {
-        const root = `raw-sources/${connectionId}/live-database/${syncId}`;
-        await project.fileStore.writeFile(`${root}/connection.json`, JSON.stringify({ connectionId, driver: 'postgres', extractedAt: '2026-05-12T00:00:00.000Z' }, null, 2), 'ktx', 'ktx@example.com', 'seed connection');
-        await project.fileStore.writeFile(`${root}/tables/orders.json`, JSON.stringify({
-            catalog: null,
-            db: 'public',
-            name: 'orders',
-            kind: 'table',
-            comment: 'Customer orders',
-            estimatedRows: 12,
-            columns: [
-                {
-                    name: 'id',
-                    nativeType: 'integer',
-                    normalizedType: 'integer',
-                    dimensionType: 'number',
-                    nullable: false,
-                    primaryKey: true,
-                    comment: 'Order id',
-                },
-                {
-                    name: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'text',
-                    dimensionType: 'string',
-                    nullable: false,
-                    primaryKey: false,
-                    comment: 'Order status',
-                },
-            ],
-            foreignKeys: [],
-        }, null, 2), 'ktx', 'ktx@example.com', 'seed orders');
-        await project.fileStore.writeFile(`${root}/enrichment/relationship-profile.json`, JSON.stringify({
-            connectionId,
-            driver: 'postgres',
-            tables: [{ table: { catalog: null, db: 'public', name: 'orders' }, rowCount: 12 }],
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    rowCount: 12,
-                    nullCount: 0,
-                    distinctCount: 2,
-                    nullRate: 0,
-                    sampleValues: ['paid', 'refunded'],
-                },
-            },
-        }, null, 2), 'ktx', 'ktx@example.com', 'seed profile');
-    }
-    it('returns scoped table detail for a display target', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders' }] }, context);
-        expect(result.markdown).toContain('### public.orders');
-        expect(result.markdown).toContain('- status (text, nullable=false)');
-        expect(result.markdown).toContain('sample: ["paid","refunded"]');
-        expect(result.structured.scanAvailable).toBe(true);
-        expect(result.structured.resolved).toHaveLength(1);
-    });
-    it('resolves display targets that include a column name', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.status' }] }, context);
-        expect(result.markdown).toContain('### public.orders');
-        expect(result.markdown).toContain('- status (text, nullable=false)');
-        expect(result.markdown).not.toContain('- id (integer');
-        expect(result.structured.resolved).toHaveLength(1);
-        expect(result.structured.resolved[0]?.columns.map((column) => column.name)).toEqual(['status']);
-    });
-    it('reports missing explicit columns instead of returning an empty column list', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.plan_tier' }] }, context);
-        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
-        expect(result.markdown).toContain('Available columns: id, status');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('reports missing structured table targets in model-visible markdown', async () => {
-        const result = await tool.call({
-            connectionId: 'warehouse',
-            targets: [{ catalog: null, db: 'public', name: 'orderz' }],
-        }, context);
-        expect(result.markdown).toContain('Not found in scan: public.orderz');
-        expect(result.markdown).toContain('Closest matches: orders');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('reports missing structured column targets in model-visible markdown', async () => {
-        const result = await tool.call({
-            connectionId: 'warehouse',
-            targets: [{ catalog: null, db: 'public', name: 'orders', column: 'plan_tier' }],
-        }, context);
-        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
-        expect(result.markdown).toContain('Available columns: id, status');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('returns a no-scan state distinct from not found', async () => {
-        const result = await tool.call({ connectionId: 'empty', targets: [{ display: 'public.orders' }] }, { ...context, session: { ...context.session, allowedConnectionNames: new Set(['empty']) } });
-        expect(result.markdown).toContain('No live-database scan available for connection "empty"; run `ktx scan` first.');
-        expect(result.structured.scanAvailable).toBe(false);
-    });
-    it('refuses out-of-scope connections', async () => {
-        const result = await tool.call({ connectionId: 'billing', targets: [{ display: 'public.orders' }] }, context);
-        expect(result.markdown).toContain('Connection "billing" is not available to this ingest stage.');
-        expect(result.structured.scanAvailable).toBe(false);
-    });
-    it('uses connectionId as the public input field', async () => {
-        const legacyConnectionField = ['connection', 'Name'].join('');
-        expect(tool.parseInput({
-            connectionId: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        })).toEqual({
-            connectionId: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        });
-        expect(() => tool.parseInput({
-            [legacyConnectionField]: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        })).toThrow();
-    });
-});

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/index.d.ts

@@ -1,9 +0,0 @@
-import type { KtxFileStorePort } from '../../../core/index.js';
-import type { SlConnectionCatalogPort } from '../../../sl/index.js';
-import type { BaseTool } from '../../../tools/index.js';
-export declare function createWarehouseVerificationTools(deps: {
-    connections: SlConnectionCatalogPort;
-    fallbackFileStore: KtxFileStorePort;
-    wikiSearchTool: BaseTool;
-    slDiscoverTool: BaseTool;
-}): BaseTool[];

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/sql-execution.tool.d.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-import type { SlConnectionCatalogPort } from '../../../sl/index.js';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../../tools/index.js';
-declare const sqlExecutionInputSchema: z.ZodObject<{
-    connectionId: z.ZodString;
-    sql: z.ZodString;
-    rowLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strict>;
-type SqlExecutionInput = z.input<typeof sqlExecutionInputSchema>;
-export interface SqlExecutionStructured {
-    headers: string[];
-    rows: unknown[][];
-    rowCount: number;
-    truncated: boolean;
-    sql: string;
-    wrappedSql: string;
-    error?: string;
-}
-export declare class SqlExecutionTool extends BaseTool<typeof sqlExecutionInputSchema> {
-    private readonly connections;
-    readonly name = "sql_execution";
-    constructor(connections: SlConnectionCatalogPort);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        connectionId: z.ZodString;
-        sql: z.ZodString;
-        rowLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strict>;
-    call(input: SqlExecutionInput, context: ToolContext): Promise<ToolOutput<SqlExecutionStructured>>;
-}
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/sql-execution.tool.js

@@ -1,84 +0,0 @@
-import { z } from 'zod';
-import { assertReadOnlySql, limitSqlForExecution } from '../../../connections/index.js';
-import { BaseTool } from '../../../tools/index.js';
-const sqlExecutionInputSchema = z.object({
-    connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
-    sql: z.string().min(1),
-    rowLimit: z.number().int().positive().max(1000).optional().default(100),
-}).strict();
-function markdownTable(headers, rows, totalRows) {
-    if (headers.length === 0) {
-        return rows.length === 0 ? 'Query returned no rows.' : JSON.stringify(rows.slice(0, 20));
-    }
-    const visible = rows.slice(0, 20);
-    const lines = [
-        `| ${headers.join(' | ')} |`,
-        `| ${headers.map(() => '---').join(' | ')} |`,
-        ...visible.map((row) => `| ${row.map((value) => String(value ?? '')).join(' | ')} |`),
-    ];
-    if (totalRows > visible.length) {
-        lines.push(`... +${totalRows - visible.length} more rows`);
-    }
-    return lines.join('\n');
-}
-export class SqlExecutionTool extends BaseTool {
-    connections;
-    name = 'sql_execution';
-    constructor(connections) {
-        super();
-        this.connections = connections;
-    }
-    get description() {
-        return 'Run a single read-only SELECT or WITH probe against an allowed warehouse connection and return a capped markdown table or the warehouse error.';
-    }
-    get inputSchema() {
-        return sqlExecutionInputSchema;
-    }
-    async call(input, context) {
-        const allowed = context.session?.allowedConnectionNames;
-        if (allowed && !allowed.has(input.connectionId)) {
-            return {
-                markdown: `Connection "${input.connectionId}" is not available to this ingest stage.`,
-                structured: {
-                    headers: [],
-                    rows: [],
-                    rowCount: 0,
-                    truncated: false,
-                    sql: input.sql,
-                    wrappedSql: '',
-                    error: 'connection_not_allowed',
-                },
-            };
-        }
-        let sql;
-        let wrappedSql;
-        try {
-            sql = assertReadOnlySql(input.sql);
-            wrappedSql = limitSqlForExecution(sql, input.rowLimit);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                markdown: message,
-                structured: { headers: [], rows: [], rowCount: 0, truncated: false, sql: input.sql, wrappedSql: '', error: message },
-            };
-        }
-        try {
-            const result = await this.connections.executeQuery(input.connectionId, wrappedSql);
-            const headers = result.headers ?? [];
-            const rows = result.rows ?? [];
-            const rowCount = result.totalRows ?? rows.length;
-            return {
-                markdown: markdownTable(headers, rows, rowCount),
-                structured: { headers, rows, rowCount, truncated: rowCount > rows.length, sql, wrappedSql },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                markdown: `SQL execution failed: ${message}`,
-                structured: { headers: [], rows: [], rowCount: 0, truncated: false, sql, wrappedSql, error: message },
-            };
-        }
-    }
-}

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/sql-execution.tool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/sql-execution.tool.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { SqlExecutionTool } from './sql-execution.tool.js';
-describe('SqlExecutionTool', () => {
-    const connections = {
-        executeQuery: vi.fn(),
-    };
-    const tool = new SqlExecutionTool(connections);
-    const context = {
-        sourceId: 'ingest',
-        messageId: 'm1',
-        userId: 'system',
-        session: { allowedConnectionNames: new Set(['warehouse']) },
-    };
-    it('wraps read-only SQL with a capped row limit', async () => {
-        connections.executeQuery.mockResolvedValue({ headers: ['status'], rows: [['paid']], totalRows: 1 });
-        const result = await tool.call({ connectionId: 'warehouse', sql: 'select status from public.orders', rowLimit: 5 }, context);
-        expect(connections.executeQuery).toHaveBeenCalledWith('warehouse', 'select * from (select status from public.orders) as ktx_query_result limit 5');
-        expect(result.markdown).toContain('| status |');
-        expect(result.structured.wrappedSql).toContain('limit 5');
-    });
-    it.each(['insert into x values (1)', 'drop table x', 'vacuum'])('rejects mutating SQL: %s', async (sql) => {
-        connections.executeQuery.mockClear();
-        const result = await tool.call({ connectionId: 'warehouse', sql }, context);
-        expect(result.markdown).toContain('Only read-only SELECT/WITH queries can be executed locally.');
-        expect(connections.executeQuery).not.toHaveBeenCalled();
-    });
-    it('surfaces connector errors verbatim', async () => {
-        connections.executeQuery.mockRejectedValue(new Error('relation "orbit_analytics.customer" does not exist'));
-        const result = await tool.call({ connectionId: 'warehouse', sql: 'select 1 from orbit_analytics.customer', rowLimit: 1 }, context);
-        expect(result.markdown).toContain('relation "orbit_analytics.customer" does not exist');
-        expect(result.structured.error).toContain('relation "orbit_analytics.customer" does not exist');
-    });
-    it('uses connectionId as the public input field', () => {
-        const legacyConnectionField = ['connection', 'Name'].join('');
-        expect(tool.parseInput({
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        })).toEqual({
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        });
-        expect(() => tool.parseInput({
-            [legacyConnectionField]: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        })).toThrow();
-    });
-});

package/node_modules/@ktx/context/dist/ingest/types.d.ts

@@ -1,201 +0,0 @@
-import type { KtxEmbeddingPort } from '../core/embedding.js';
-import type { MemoryAction } from '../memory/index.js';
-import type { SemanticLayerService } from '../sl/index.js';
-import type { TouchedSlSource } from '../tools/index.js';
-import type { MemoryFlowEventSink } from './memory-flow/types.js';
-import type { StageIndex } from './stages/stage-index.types.js';
-import type { WorkUnitOutcome } from './stages/stage-3-work-units.js';
-export type IngestTrigger = 'upload' | 'scheduled_pull' | 'manual_resync' | 'manual_override';
-export interface DiffSet {
-    added: string[];
-    modified: string[];
-    deleted: string[];
-    unchanged: string[];
-}
-export interface WorkUnit {
-    unitKey: string;
-    displayLabel?: string;
-    rawFiles: string[];
-    peerFileIndex: string[];
-    dependencyPaths: string[];
-    notes?: string;
-    slDisallowed?: boolean;
-    slDisallowedReason?: 'lookml_connection_mismatch';
-}
-export interface EvictionUnit {
-    deletedRawPaths: string[];
-}
-export interface UnresolvedCardInfo {
-    cardId: number;
-    name?: string;
-    reason: 'cycle' | 'missing_native' | 'api_500' | 'unknown';
-    errorMessage?: string;
-}
-export interface ChunkResult {
-    workUnits: WorkUnit[];
-    eviction?: EvictionUnit;
-    unresolvedCards?: UnresolvedCardInfo[];
-    reconcileNotes?: string[];
-    contextReport?: {
-        capped?: boolean;
-        warnings?: string[];
-    };
-    parseArtifacts?: unknown;
-}
-export interface FetchContext {
-    connectionId: string;
-    sourceKey: string;
-    memoryFlow?: MemoryFlowEventSink;
-}
-type SourceFetchIssueKind = 'unmapped_looker_connection' | 'unparseable_sql_table_name' | 'looker_template_unresolved' | 'derived_table_not_supported' | 'lookml_connection_mismatch';
-export interface SourceFetchIssue {
-    rawPath: string;
-    entityType: string;
-    entityId: string | null;
-    severity: 'warning' | 'error';
-    statusCode: number | null;
-    message: string;
-    retryRecommended: boolean;
-    kind?: SourceFetchIssueKind;
-    details?: Record<string, unknown>;
-}
-export interface SourceFetchReport {
-    status: 'success' | 'partial';
-    retryRecommended: boolean;
-    skipped: SourceFetchIssue[];
-    warnings: SourceFetchIssue[];
-}
-export interface ScopeDescriptor {
-    fingerprint: string;
-    isPathInScope(rawPath: string): boolean;
-}
-export type TriageLane = 'skip' | 'light' | 'full';
-export interface TriageSignals {
-    parentType?: string;
-    objectType?: string;
-    isDateTitled?: boolean;
-    lastEditedAt?: string;
-    propertyHints?: Record<string, string>;
-}
-export interface ClusterWorkUnitsContext {
-    workUnits: WorkUnit[];
-    stagedDir: string;
-    embedding: KtxEmbeddingPort;
-}
-export interface DeterministicProjectionContext {
-    connectionId: string;
-    sourceKey: string;
-    syncId: string;
-    jobId: string;
-    runId: string;
-    stagedDir: string;
-    workdir: string;
-    parseArtifacts?: unknown;
-    semanticLayerService: SemanticLayerService;
-}
-export interface ProjectionResult {
-    warnings: string[];
-    errors: string[];
-    touchedSources: Array<{
-        connectionId: string;
-        sourceName: string;
-    }>;
-    changedWikiPageKeys: string[];
-    result?: unknown;
-}
-export interface FinalizationOverrideReplay {
-    priorJobId: string;
-    priorRunId: string;
-    priorSyncId: string;
-    evictionRawPaths: string[];
-}
-export interface DeterministicFinalizationContext {
-    connectionId: string;
-    sourceKey: string;
-    syncId: string;
-    jobId: string;
-    runId: string;
-    stagedDir: string;
-    workdir: string;
-    parseArtifacts?: unknown;
-    stageIndex: StageIndex;
-    workUnitOutcomes: WorkUnitOutcome[];
-    reconciliationActions: MemoryAction[];
-    overrideReplay?: FinalizationOverrideReplay;
-}
-export interface FinalizationResult {
-    warnings: string[];
-    errors: string[];
-    touchedSources: TouchedSlSource[];
-    changedWikiPageKeys: string[];
-    actions?: MemoryAction[];
-    result?: unknown;
-}
-export interface SourceAdapter {
-    readonly source: string;
-    readonly skillNames: string[];
-    readonly reconcileSkillNames?: string[];
-    readonly evidenceIndexing?: 'documents';
-    readonly triageSupported?: boolean;
-    getTriageSignals?(stagedDir: string, externalId: string): Promise<TriageSignals>;
-    detect(stagedDir: string): Promise<boolean>;
-    fetch?(pullConfig: unknown, stagedDir: string, ctx: FetchContext): Promise<void>;
-    readFetchReport?(stagedDir: string): Promise<SourceFetchReport | null>;
-    listTargetConnectionIds?(stagedDir: string): Promise<string[]>;
-    chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
-    clusterWorkUnits?(ctx: ClusterWorkUnitsContext): Promise<WorkUnit[]>;
-    project?(ctx: DeterministicProjectionContext): Promise<ProjectionResult>;
-    finalize?(ctx: DeterministicFinalizationContext): Promise<FinalizationResult>;
-    describeScope?(stagedDir: string): Promise<ScopeDescriptor>;
-    onPullSucceeded?(ctx: {
-        connectionId: string;
-        sourceKey: string;
-        syncId: string;
-        trigger: IngestTrigger;
-        completedAt: Date;
-        stagedDir: string;
-    }): Promise<void>;
-}
-export type IngestBundleRef = {
-    kind: 'upload';
-    uploadId: string;
-} | {
-    kind: 'scheduled_pull';
-    config: unknown;
-} | {
-    kind: 'override';
-    priorJobId: string;
-};
-export interface IngestBundleJob {
-    jobId: string;
-    connectionId: string;
-    sourceKey: string;
-    trigger: IngestTrigger;
-    bundleRef: IngestBundleRef;
-}
-export interface IngestDiffSummary {
-    added: number;
-    modified: number;
-    deleted: number;
-    unchanged: number;
-}
-export interface IngestBundleResult {
-    jobId: string;
-    runId: string;
-    syncId: string;
-    diffSummary: IngestDiffSummary;
-    workUnitCount: number;
-    failedWorkUnits: string[];
-    artifactsWritten: number;
-    commitSha: string | null;
-}
-export interface IngestJobPhase {
-    updateProgress(progress: number, message?: string): Promise<void>;
-    startPhase(weight: number): IngestJobPhase;
-}
-export interface IngestJobContext {
-    jobId: string;
-    memoryFlow?: MemoryFlowEventSink;
-    startPhase(weight: number): IngestJobPhase;
-}
-export {};

package/node_modules/@ktx/context/dist/ingest/types.js

@@ -1 +0,0 @@
-export {};

package/node_modules/@ktx/context/dist/ingest/wiki-body-refs.d.ts

@@ -1,24 +0,0 @@
-import type { SemanticLayerSource } from '../sl/index.js';
-export type WikiBodyRef = {
-    kind: 'sl_entity';
-    connectionId: string | null;
-    sourceName: string;
-    entityName: string;
-} | {
-    kind: 'sl_source';
-    connectionId: string | null;
-    sourceName: string;
-} | {
-    kind: 'table';
-    connectionId: string | null;
-    tableRef: string;
-};
-export interface WikiBodyRefValidationInput {
-    pageKey: string;
-    body: string;
-    visibleConnectionIds: string[];
-    loadSources(connectionId: string): Promise<SemanticLayerSource[]>;
-    tableExists(connectionId: string, tableRef: string): Promise<boolean>;
-}
-export declare function parseWikiBodyRefs(body: string): WikiBodyRef[];
-export declare function findInvalidWikiBodyRefs(input: WikiBodyRefValidationInput): Promise<string[]>;

package/node_modules/@ktx/context/dist/ingest/wiki-body-refs.js

@@ -1,111 +0,0 @@
-const inlineCodePattern = /`([^`\n]+)`/g;
-function visibleLinesOutsideFences(body) {
-    const lines = [];
-    let fenced = false;
-    for (const line of body.split('\n')) {
-        if (/^\s*```/.test(line)) {
-            fenced = !fenced;
-            continue;
-        }
-        if (!fenced) {
-            lines.push(line);
-        }
-    }
-    return lines;
-}
-function parseConnectionScoped(value) {
-    const slash = value.indexOf('/');
-    if (slash <= 0) {
-        return { connectionId: null, body: value };
-    }
-    return { connectionId: value.slice(0, slash), body: value.slice(slash + 1) };
-}
-function isIdentifierToken(value) {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
-}
-export function parseWikiBodyRefs(body) {
-    const refs = [];
-    for (const line of visibleLinesOutsideFences(body)) {
-        for (const match of line.matchAll(inlineCodePattern)) {
-            const token = (match[1] ?? '').trim();
-            if (!token) {
-                continue;
-            }
-            const scoped = parseConnectionScoped(token);
-            if (scoped.body.startsWith('source:')) {
-                const sourceName = scoped.body.slice('source:'.length).trim();
-                if (sourceName) {
-                    refs.push({ kind: 'sl_source', connectionId: scoped.connectionId, sourceName });
-                }
-                continue;
-            }
-            if (scoped.body.startsWith('table:')) {
-                const tableRef = scoped.body.slice('table:'.length).trim();
-                if (tableRef) {
-                    refs.push({ kind: 'table', connectionId: scoped.connectionId, tableRef });
-                }
-                continue;
-            }
-            const parts = scoped.body.split('.');
-            if (parts.length === 2 && isIdentifierToken(parts[0] ?? '') && isIdentifierToken(parts[1] ?? '')) {
-                refs.push({
-                    kind: 'sl_entity',
-                    connectionId: scoped.connectionId,
-                    sourceName: parts[0],
-                    entityName: parts[1],
-                });
-            }
-        }
-    }
-    return refs;
-}
-function entityNames(source) {
-    return new Set([
-        ...(source.measures ?? []).map((measure) => measure.name),
-        ...(source.columns ?? []).map((column) => column.name),
-        ...(source.segments ?? []).map((segment) => segment.name),
-    ]);
-}
-export async function findInvalidWikiBodyRefs(input) {
-    const errors = [];
-    const sourceCache = new Map();
-    const loadSources = async (connectionId) => {
-        const cached = sourceCache.get(connectionId);
-        if (cached) {
-            return cached;
-        }
-        const sources = await input.loadSources(connectionId);
-        sourceCache.set(connectionId, sources);
-        return sources;
-    };
-    const findSource = async (connectionIds, sourceName) => {
-        for (const connectionId of connectionIds) {
-            const source = (await loadSources(connectionId)).find((candidate) => candidate.name === sourceName);
-            if (source) {
-                return { connectionId, source };
-            }
-        }
-        return null;
-    };
-    for (const ref of parseWikiBodyRefs(input.body)) {
-        const connectionIds = ref.connectionId ? [ref.connectionId] : input.visibleConnectionIds;
-        if (ref.kind === 'table') {
-            const found = await Promise.all(connectionIds.map((connectionId) => input.tableExists(connectionId, ref.tableRef)));
-            if (!found.some(Boolean)) {
-                errors.push(`${input.pageKey}: unknown raw table ${ref.connectionId ? `${ref.connectionId}/` : ''}${ref.tableRef}`);
-            }
-            continue;
-        }
-        const found = await findSource(connectionIds, ref.sourceName);
-        if (!found) {
-            if (ref.kind === 'sl_source') {
-                errors.push(`${input.pageKey}: unknown semantic-layer source ${ref.connectionId ? `${ref.connectionId}/` : ''}${ref.sourceName}`);
-            }
-            continue;
-        }
-        if (ref.kind === 'sl_entity' && !entityNames(found.source).has(ref.entityName)) {
-            errors.push(`${input.pageKey}: unknown semantic-layer entity ${ref.sourceName}.${ref.entityName}`);
-        }
-    }
-    return errors;
-}

package/node_modules/@ktx/context/dist/ingest/wiki-body-refs.test.d.ts

@@ -1 +0,0 @@
-export {};