@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/ingest/adapters/looker/types.test.js

@@ -0,0 +1,260 @@
+import { describe, expect, it } from 'vitest';
+import { lookerPullConfigSchema, parseLookerPullConfig, parsedTargetTableSchema, stagedDashboardFileSchema, stagedExploreFileSchema, stagedLookerFetchIssueSchema, stagedLookerQuerySchema, stagedLookerScopeFileSchema, stagedLookerSignalsFileSchema, stagedLookFileSchema, stagedSyncConfigSchema, } from './types.js';
+describe('Looker staged runtime schemas', () => {
+    it('parses pull config and staged sync config', () => {
+        expect(lookerPullConfigSchema.parse({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            instanceBaseUrl: 'https://example.looker.com',
+        })).toEqual({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            instanceBaseUrl: 'https://example.looker.com',
+            connectionMappings: {},
+            connectionTypes: {},
+            parsedTargetTables: {},
+        });
+        expect(stagedSyncConfigSchema.parse({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            fetchedAt: '2026-04-30T12:00:00.000Z',
+            instanceBaseUrl: 'https://example.looker.com',
+        })).toMatchObject({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            instanceBaseUrl: 'https://example.looker.com',
+        });
+    });
+    it('parses incremental pull cursors and scope manifests', () => {
+        expect(parseLookerPullConfig({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            dashboardUpdatedSince: '2026-04-30T10:00:00.000Z',
+            lookUpdatedSince: '2026-04-30T11:00:00.000Z',
+        })).toEqual({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            dashboardUpdatedSince: '2026-04-30T10:00:00.000Z',
+            lookUpdatedSince: '2026-04-30T11:00:00.000Z',
+            connectionMappings: {},
+            connectionTypes: {},
+            parsedTargetTables: {},
+        });
+        expect(stagedLookerScopeFileSchema.parse({
+            mode: 'incremental',
+            knownCurrentRawPaths: ['dashboards/10.json', 'looks/20.json'],
+            fetchedRawPaths: ['dashboards/10.json'],
+        })).toEqual({
+            mode: 'incremental',
+            knownCurrentRawPaths: ['dashboards/10.json', 'looks/20.json'],
+            fetchedRawPaths: ['dashboards/10.json'],
+        });
+        expect(stagedSyncConfigSchema.parse({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            fetchedAt: '2026-04-30T12:30:00.000Z',
+            previousCursors: {
+                dashboardsLastSyncedAt: null,
+                looksLastSyncedAt: '2026-04-30T11:00:00.000Z',
+            },
+            nextCursors: {
+                dashboardsLastSyncedAt: '2026-04-30T12:00:00.000Z',
+                looksLastSyncedAt: '2026-04-30T11:00:00.000Z',
+            },
+        }).nextCursors).toEqual({
+            dashboardsLastSyncedAt: '2026-04-30T12:00:00.000Z',
+            looksLastSyncedAt: '2026-04-30T11:00:00.000Z',
+        });
+    });
+    it('normalizes numeric Looker ids to strings', () => {
+        const dashboard = stagedDashboardFileSchema.parse({
+            lookerId: 10,
+            title: 'Sales Pipeline',
+            description: null,
+            folderId: 7,
+            ownerId: 3,
+            updatedAt: '2026-04-30T12:00:00.000Z',
+            tiles: [{ id: 100, title: 'ARR', lookId: null, query: { model: 'b2b', view: 'sales_pipeline' } }],
+        });
+        expect(dashboard.lookerId).toBe('10');
+        expect(dashboard.folderId).toBe('7');
+        expect(dashboard.ownerId).toBe('3');
+        expect(dashboard.tiles[0].id).toBe('100');
+    });
+    it('parses explores, looks, and signal files with defaults', () => {
+        expect(stagedExploreFileSchema.parse({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            label: 'Sales Pipeline',
+            description: null,
+            fields: {
+                dimensions: [{ name: 'opportunities.id', label: 'Opportunity ID', type: 'number', sql: '${TABLE}.id' }],
+                measures: [{ name: 'opportunities.arr', label: 'ARR', type: 'sum', sql: '${TABLE}.arr' }],
+            },
+            joins: [{ name: 'accounts', type: 'left_outer', relationship: 'many_to_one' }],
+        })).toMatchObject({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            fields: { dimensions: [{ name: 'opportunities.id' }], measures: [{ name: 'opportunities.arr' }] },
+        });
+        expect(stagedLookFileSchema.parse({
+            lookerId: '20',
+            title: 'Open Pipeline',
+            description: null,
+            folderId: null,
+            ownerId: null,
+            updatedAt: null,
+            query: { model: 'b2b', view: 'sales_pipeline', fields: ['opportunities.arr'] },
+        })).toMatchObject({ lookerId: '20', query: { fields: ['opportunities.arr'] } });
+        expect(stagedLookerSignalsFileSchema.parse({}).dashboardUsage).toEqual([]);
+    });
+    it('parses warehouse SL mapping pull config and staged target table fields', () => {
+        const targetConnectionId = '22222222-2222-4222-8222-222222222222';
+        const parsedTargetTable = {
+            ok: true,
+            catalog: 'proj',
+            schema: 'dataset',
+            name: 'opportunities',
+            canonicalTable: 'proj.dataset.opportunities',
+        };
+        expect(parsedTargetTableSchema.parse(parsedTargetTable)).toEqual(parsedTargetTable);
+        expect(parseLookerPullConfig({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            connectionMappings: { b2b_sandbox_bq: targetConnectionId },
+            connectionTypes: { b2b_sandbox_bq: 'BIGQUERY' },
+            parsedTargetTables: { 'b2b.sales_pipeline': parsedTargetTable },
+        })).toEqual({
+            lookerConnectionId: '11111111-1111-4111-8111-111111111111',
+            connectionMappings: { b2b_sandbox_bq: targetConnectionId },
+            connectionTypes: { b2b_sandbox_bq: 'BIGQUERY' },
+            parsedTargetTables: { 'b2b.sales_pipeline': parsedTargetTable },
+        });
+        expect(stagedExploreFileSchema.parse({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            label: 'Sales Pipeline',
+            description: null,
+            rawSqlTableName: 'proj.dataset.opportunities AS opportunities',
+            connectionName: 'b2b_sandbox_bq',
+            viewName: 'opportunities',
+            fields: {
+                dimensions: [{ name: 'opportunities.id', label: 'Opportunity ID', type: 'number', sql: '${TABLE}.id' }],
+                measures: [{ name: 'opportunities.arr', label: 'ARR', type: 'sum', sql: '${TABLE}.arr' }],
+            },
+            joins: [
+                {
+                    name: 'accounts',
+                    type: 'left_outer',
+                    relationship: 'many_to_one',
+                    rawSqlTableName: 'proj.dataset.accounts',
+                    sqlOn: '${opportunities.account_id} = ${accounts.id}',
+                    from: null,
+                    targetTable: {
+                        ok: true,
+                        catalog: 'proj',
+                        schema: 'dataset',
+                        name: 'accounts',
+                        canonicalTable: 'proj.dataset.accounts',
+                    },
+                },
+            ],
+            targetWarehouseConnectionId: targetConnectionId,
+            targetTable: parsedTargetTable,
+        })).toMatchObject({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            connectionName: 'b2b_sandbox_bq',
+            targetWarehouseConnectionId: targetConnectionId,
+            targetTable: parsedTargetTable,
+            joins: [{ name: 'accounts', targetTable: { ok: true, name: 'accounts' } }],
+        });
+    });
+    it('parses structured Looker mapping fetch warnings', () => {
+        expect(stagedLookerFetchIssueSchema.parse({
+            rawPath: 'looker_connection_mappings/b2b_sandbox_bq',
+            entityType: 'looker_connection_mapping',
+            entityId: 'b2b_sandbox_bq',
+            severity: 'warning',
+            statusCode: null,
+            message: 'Looker connection b2b_sandbox_bq is not mapped to a warehouse connection.',
+            retryRecommended: false,
+            kind: 'unmapped_looker_connection',
+            details: {
+                lookerConnectionName: 'b2b_sandbox_bq',
+                affectedExplores: ['b2b.sales_pipeline'],
+            },
+        })).toMatchObject({
+            entityType: 'looker_connection_mapping',
+            kind: 'unmapped_looker_connection',
+            details: {
+                lookerConnectionName: 'b2b_sandbox_bq',
+                affectedExplores: ['b2b.sales_pipeline'],
+            },
+        });
+    });
+    it('parses LookML model listing warnings in fetch reports', () => {
+        expect(stagedLookerFetchIssueSchema.parse({
+            rawPath: 'lookml_models.json',
+            entityType: 'lookml_models',
+            entityId: null,
+            severity: 'warning',
+            statusCode: 403,
+            message: 'LookML model access denied',
+            retryRecommended: false,
+        })).toEqual({
+            rawPath: 'lookml_models.json',
+            entityType: 'lookml_models',
+            entityId: null,
+            severity: 'warning',
+            statusCode: 403,
+            message: 'LookML model access denied',
+            retryRecommended: false,
+        });
+    });
+    it('accepts slug-shaped connection ids inside KTX Looker runtime schemas', () => {
+        const parsedTargetTable = {
+            ok: true,
+            catalog: 'proj',
+            schema: 'dataset',
+            name: 'opportunities',
+            canonicalTable: 'proj.dataset.opportunities',
+        };
+        expect(parseLookerPullConfig({
+            lookerConnectionId: 'prod-looker',
+            connectionMappings: { b2b_sandbox_bq: 'prod-warehouse' },
+            connectionTypes: { b2b_sandbox_bq: 'BIGQUERY' },
+            parsedTargetTables: { 'b2b.sales_pipeline': parsedTargetTable },
+        })).toMatchObject({
+            lookerConnectionId: 'prod-looker',
+            connectionMappings: { b2b_sandbox_bq: 'prod-warehouse' },
+        });
+        expect(stagedSyncConfigSchema.parse({
+            lookerConnectionId: 'prod-looker',
+            fetchedAt: '2026-04-30T12:00:00.000Z',
+        })).toMatchObject({
+            lookerConnectionId: 'prod-looker',
+        });
+        expect(stagedLookerQuerySchema.parse({
+            model: 'b2b',
+            view: 'sales_pipeline',
+            targetWarehouseConnectionId: 'prod-warehouse',
+            targetTable: parsedTargetTable,
+        })).toMatchObject({
+            targetWarehouseConnectionId: 'prod-warehouse',
+            targetTable: parsedTargetTable,
+        });
+        expect(stagedExploreFileSchema.parse({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            label: 'Sales Pipeline',
+            description: null,
+            fields: { dimensions: [], measures: [] },
+            targetWarehouseConnectionId: 'prod-warehouse',
+            targetTable: parsedTargetTable,
+        })).toMatchObject({
+            targetWarehouseConnectionId: 'prod-warehouse',
+            targetTable: parsedTargetTable,
+        });
+    });
+    it('rejects unsafe KTX Looker connection ids', () => {
+        expect(() => parseLookerPullConfig({
+            lookerConnectionId: '../prod-looker',
+        })).toThrow();
+        expect(() => parseLookerPullConfig({
+            connectionMappings: { b2b_sandbox_bq: 'prod/warehouse' },
+        })).toThrow();
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/chunk.d.ts

@@ -0,0 +1,19 @@
+import type { ChunkResult, DiffSet } from '../../types.js';
+import type { ParsedLookmlProject } from './parse.js';
+interface ChunkOptions {
+    diffSet?: DiffSet;
+    mismatchedModelNames?: Set<string>;
+}
+/**
+ * Emit WorkUnits for a parsed LookML project.
+ *
+ *   First run (no diffSet): one WU per model + `lookml-orphans` (if any non-owned views)
+ *                           + `lookml-dashboard-<name>` per dashboard file.
+ *
+ *   Re-sync (diffSet provided): filter to WUs whose rawFiles intersect added∪modified;
+ *                               widen dependencyPaths with every file in `allPaths`
+ *                               that's upstream of the WU's changed files via the graph.
+ *                               Emit a single EvictionUnit for diffSet.deleted.
+ */
+export declare function chunkLookmlProject(project: ParsedLookmlProject, opts?: ChunkOptions): ChunkResult;
+export {};

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/chunk.js

@@ -0,0 +1,128 @@
+import { buildLookmlGraph } from './graph.js';
+function lookmlSlDisallowedNotes(modelName, existingNotes) {
+    return [
+        '[LOOKML SL WRITES DISALLOWED]',
+        'reason: lookml_connection_mismatch',
+        `model: ${modelName}`,
+        'Do not call sl_write_source or sl_edit_source for this WorkUnit.',
+        'Continue wiki extraction and context candidates from the raw LookML files.',
+        '[/LOOKML SL WRITES DISALLOWED]',
+        '',
+        existingNotes,
+    ].join('\n');
+}
+/**
+ * Emit WorkUnits for a parsed LookML project.
+ *
+ *   First run (no diffSet): one WU per model + `lookml-orphans` (if any non-owned views)
+ *                           + `lookml-dashboard-<name>` per dashboard file.
+ *
+ *   Re-sync (diffSet provided): filter to WUs whose rawFiles intersect added∪modified;
+ *                               widen dependencyPaths with every file in `allPaths`
+ *                               that's upstream of the WU's changed files via the graph.
+ *                               Emit a single EvictionUnit for diffSet.deleted.
+ */
+export function chunkLookmlProject(project, opts = {}) {
+    const graph = buildLookmlGraph(project);
+    const firstRunUnits = emitFirstRunWorkUnits(project, graph, opts);
+    if (!opts.diffSet) {
+        return { workUnits: firstRunUnits };
+    }
+    return applyDiffSet(firstRunUnits, project, graph, opts.diffSet);
+}
+function emitFirstRunWorkUnits(project, graph, opts) {
+    const allModelPaths = [...new Set(project.models.map((m) => m.path))].sort();
+    const allDashboardPaths = [...new Set(project.dashboards.map((d) => d.path))].sort();
+    // Dedupe: a .view.lkml with multiple `view:` blocks produces multiple ParsedLookmlView
+    // entries sharing one path.
+    const allViewPaths = [...new Set(project.views.map((v) => v.path))].sort();
+    const workUnits = [];
+    // Per-model WU, sorted by model name for determinism.
+    const sortedModels = [...project.models].sort((a, b) => a.name.localeCompare(b.name));
+    for (const model of sortedModels) {
+        const includedViewPaths = (graph.viewsIncludedByModel.get(model.name) ?? []).filter((p) => allViewPaths.includes(p));
+        // Views the model includes and which this model ALSO owns (first-includer-wins).
+        const ownedViewPaths = includedViewPaths.filter((p) => graph.ownerByViewPath.get(p) === model.name);
+        // Views the model includes but that another lexicographically-earlier model owns.
+        // These land in dependencyPaths so this WU's agent can READ them, but the "canonical
+        // write" for those views happens in the owner's WU.
+        const nonOwnedDepViewPaths = includedViewPaths.filter((p) => graph.ownerByViewPath.get(p) !== model.name).sort();
+        const rawFiles = [model.path, ...ownedViewPaths].sort();
+        const peerFileIndex = [
+            ...allModelPaths.filter((p) => p !== model.path),
+            ...allViewPaths.filter((p) => !rawFiles.includes(p) && !nonOwnedDepViewPaths.includes(p)),
+            ...allDashboardPaths,
+        ].sort();
+        const isMismatched = opts.mismatchedModelNames?.has(model.name) ?? false;
+        const notes = model.explores.length > 0
+            ? `LookML model "${model.name}" (explores: ${model.explores.join(', ')})`
+            : `LookML model "${model.name}"`;
+        workUnits.push({
+            unitKey: `lookml-${model.name}`,
+            displayLabel: `LookML model "${model.name}"`,
+            rawFiles,
+            peerFileIndex,
+            dependencyPaths: nonOwnedDepViewPaths,
+            notes: isMismatched ? lookmlSlDisallowedNotes(model.name, notes) : notes,
+            slDisallowed: isMismatched ? true : undefined,
+            slDisallowedReason: isMismatched ? 'lookml_connection_mismatch' : undefined,
+        });
+    }
+    // Orphan view WU — views that no model includes. Skip entirely if none.
+    const orphanViewPaths = allViewPaths.filter((p) => !graph.ownerByViewPath.has(p)).sort();
+    if (orphanViewPaths.length > 0) {
+        workUnits.push({
+            unitKey: 'lookml-orphans',
+            displayLabel: 'LookML orphan views',
+            rawFiles: orphanViewPaths,
+            peerFileIndex: [...allModelPaths, ...allDashboardPaths].sort(),
+            dependencyPaths: [],
+            notes: 'Views not referenced by any .model.lkml (orphaned)',
+        });
+    }
+    // One WU per dashboard file.
+    for (const dashboard of [...project.dashboards].sort((a, b) => a.name.localeCompare(b.name))) {
+        workUnits.push({
+            unitKey: `lookml-dashboard-${dashboard.name}`,
+            displayLabel: `LookML dashboard "${dashboard.name}"`,
+            rawFiles: [dashboard.path],
+            peerFileIndex: [...allModelPaths, ...allViewPaths].sort(),
+            dependencyPaths: [],
+            notes: `LookML dashboard "${dashboard.name}"`,
+        });
+    }
+    return workUnits;
+}
+function applyDiffSet(firstRunUnits, _project, graph, diffSet) {
+    const touched = new Set([...diffSet.added, ...diffSet.modified]);
+    const keptUnits = [];
+    for (const wu of firstRunUnits) {
+        const anyTouched = wu.rawFiles.some((p) => touched.has(p));
+        if (!anyTouched) {
+            continue;
+        }
+        // Widen dependencyPaths: for every view in rawFiles, add paths of all transitive
+        // extends ancestors (if known in the graph) that aren't already in rawFiles.
+        const existingDeps = new Set(wu.dependencyPaths);
+        for (const rawPath of wu.rawFiles) {
+            const viewNames = graph.viewNamesByPath.get(rawPath) ?? [];
+            for (const viewName of viewNames) {
+                const ancestors = graph.extendsAncestorsByViewName.get(viewName) ?? [];
+                for (const ancestorName of ancestors) {
+                    const ancestorPaths = graph.pathsByViewName.get(ancestorName) ?? [];
+                    for (const ancestorPath of ancestorPaths) {
+                        if (!wu.rawFiles.includes(ancestorPath)) {
+                            existingDeps.add(ancestorPath);
+                        }
+                    }
+                }
+            }
+        }
+        keptUnits.push({
+            ...wu,
+            dependencyPaths: [...existingDeps].sort(),
+        });
+    }
+    const eviction = diffSet.deleted.length > 0 ? { deletedRawPaths: [...diffSet.deleted].sort() } : undefined;
+    return { workUnits: keptUnits, eviction };
+}

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/chunk.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/chunk.test.js

@@ -0,0 +1,213 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { chunkLookmlProject } from './chunk.js';
+import { parseLookmlStagedDir } from './parse.js';
+const FIXTURE_ROOT = join(__dirname, '../../../../test/fixtures/lookml');
+describe('chunkLookmlProject — first run', () => {
+    it('single-model bundle → 1 WU with model + all views in rawFiles', async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'single-model');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const result = chunkLookmlProject(project);
+        expect(result.workUnits).toHaveLength(1);
+        const wu = result.workUnits[0];
+        expect(wu.unitKey).toBe('lookml-orders');
+        expect(wu.rawFiles.sort()).toEqual(['orders.model.lkml', 'views/customers.view.lkml', 'views/orders.view.lkml']);
+        expect(wu.peerFileIndex).toEqual([]);
+        expect(wu.dependencyPaths).toEqual([]);
+        expect(result.eviction).toBeUndefined();
+    });
+    it('multi-model bundle → 1 WU per model; shared view owned by lex-first model; others see it in dependencyPaths + peerFileIndex is pathless-index', async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const result = chunkLookmlProject(project);
+        expect(result.workUnits).toHaveLength(2);
+        const marketing = result.workUnits.find((wu) => wu.unitKey === 'lookml-marketing');
+        const orders = result.workUnits.find((wu) => wu.unitKey === 'lookml-orders');
+        expect(marketing).toBeDefined();
+        expect(orders).toBeDefined();
+        if (!marketing || !orders) {
+            throw new Error('expected marketing and orders work units');
+        }
+        // marketing sorts before orders → marketing owns shared_dims
+        expect(marketing.rawFiles).toContain('views/shared_dims.view.lkml');
+        expect(marketing.rawFiles).toContain('views/campaigns.view.lkml');
+        expect(marketing.rawFiles).toContain('marketing.model.lkml');
+        expect(marketing.rawFiles).not.toContain('views/orders.view.lkml');
+        expect(marketing.dependencyPaths).toEqual([]);
+        // orders does NOT own shared_dims — it's in dependencyPaths (read-only upstream).
+        expect(orders.rawFiles).not.toContain('views/shared_dims.view.lkml');
+        expect(orders.dependencyPaths).toEqual(['views/shared_dims.view.lkml']);
+        expect(orders.rawFiles).toContain('views/orders.view.lkml');
+        expect(orders.rawFiles).toContain('orders.model.lkml');
+        // Each WU's peerFileIndex lists the OTHER model's files (paths-only index).
+        expect(orders.peerFileIndex).toContain('marketing.model.lkml');
+        expect(orders.peerFileIndex).toContain('views/campaigns.view.lkml');
+        // Dependency paths should not be duplicated into peerFileIndex.
+        expect(orders.peerFileIndex).not.toContain('views/shared_dims.view.lkml');
+    });
+    it('extends-chain fixture: single WU contains base + orders + orders_ext; chain order visible via graph', async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'extends-chain');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const result = chunkLookmlProject(project);
+        // One model ("orders") includes views/*.view.lkml — so all three views land in its WU.
+        expect(result.workUnits).toHaveLength(1);
+        const wu = result.workUnits[0];
+        expect(wu.unitKey).toBe('lookml-orders');
+        expect(wu.rawFiles.sort()).toEqual([
+            'orders.model.lkml',
+            'views/base.view.lkml',
+            'views/orders.view.lkml',
+            'views/orders_ext.view.lkml',
+        ]);
+        expect(wu.dependencyPaths).toEqual([]); // all ancestors already in rawFiles on first run
+        expect(wu.notes).toMatch(/orders/);
+    });
+    it('is deterministic: two calls on the same project return structurally identical WorkUnits', async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const r1 = chunkLookmlProject(project);
+        const r2 = chunkLookmlProject(project);
+        expect(r1.workUnits).toEqual(r2.workUnits);
+    });
+    it('unitKey is model-name-derived (stable across parse+chunk cycles and across re-syncs)', async () => {
+        const project = await parseLookmlStagedDir(join(FIXTURE_ROOT, 'multi-model'));
+        const { workUnits } = chunkLookmlProject(project);
+        expect(workUnits.map((wu) => wu.unitKey).sort()).toEqual(['lookml-marketing', 'lookml-orders']);
+    });
+    it('marks mismatched model WorkUnits as SL-disallowed and keeps wiki ingest enabled', () => {
+        const project = {
+            models: [
+                {
+                    path: 'b2b.model.lkml',
+                    name: 'b2b',
+                    includes: ['views/orders.view.lkml'],
+                    explores: ['orders'],
+                    connectionName: 'wrong_connection',
+                },
+            ],
+            views: [{ path: 'views/orders.view.lkml', name: 'orders', extendsFrom: [], rawSqlTableName: 'public.orders' }],
+            dashboards: [],
+            allPaths: ['b2b.model.lkml', 'views/orders.view.lkml'],
+        };
+        const result = chunkLookmlProject(project, { mismatchedModelNames: new Set(['b2b']) });
+        const wu = result.workUnits[0];
+        expect(wu.unitKey).toBe('lookml-b2b');
+        expect(wu.rawFiles).toEqual(['b2b.model.lkml', 'views/orders.view.lkml']);
+        expect(wu.slDisallowed).toBe(true);
+        expect(wu.slDisallowedReason).toBe('lookml_connection_mismatch');
+        expect(wu.notes).toContain('[LOOKML SL WRITES DISALLOWED]');
+        expect(wu.notes).toContain('reason: lookml_connection_mismatch');
+        expect(wu.notes).toContain('Do not call sl_write_source or sl_edit_source for this WorkUnit.');
+    });
+});
+describe('chunkLookmlProject — re-sync', () => {
+    it("modified file in one model only emits that model's WU", async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'multi-model');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const result = chunkLookmlProject(project, {
+            diffSet: {
+                added: [],
+                modified: ['views/campaigns.view.lkml'],
+                deleted: [],
+                unchanged: [
+                    'marketing.model.lkml',
+                    'orders.model.lkml',
+                    'views/orders.view.lkml',
+                    'views/shared_dims.view.lkml',
+                ],
+            },
+        });
+        expect(result.workUnits).toHaveLength(1);
+        expect(result.workUnits[0].unitKey).toBe('lookml-marketing');
+    });
+    it("added file under a model emits that model's WU with the new path in rawFiles", async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'single-model');
+        const project = await parseLookmlStagedDir(stagedDir);
+        const result = chunkLookmlProject(project, {
+            diffSet: {
+                added: ['views/customers.view.lkml'],
+                modified: [],
+                deleted: [],
+                unchanged: ['orders.model.lkml', 'views/orders.view.lkml'],
+            },
+        });
+        expect(result.workUnits).toHaveLength(1);
+        expect(result.workUnits[0].rawFiles).toContain('views/customers.view.lkml');
+    });
+    it('widens dependencyPaths with transitive extends ancestors on re-sync', async () => {
+        const stagedDir = join(FIXTURE_ROOT, 'extends-chain');
+        const project = await parseLookmlStagedDir(stagedDir);
+        // Only orders_ext is touched; base and orders are upstream ancestors.
+        // Because the single-model WU's rawFiles ALREADY include all three on first run,
+        // they remain in rawFiles — dependencyPaths stays empty. Widening matters when
+        // re-sync drops some files from rawFiles, which doesn't apply for a monolithic
+        // single-model WU. Assert the baseline invariant.
+        const result = chunkLookmlProject(project, {
+            diffSet: {
+                added: [],
+                modified: ['views/orders_ext.view.lkml'],
+                deleted: [],
+                unchanged: ['orders.model.lkml', 'views/base.view.lkml', 'views/orders.view.lkml'],
+            },
+        });
+        expect(result.workUnits).toHaveLength(1);
+        const wu = result.workUnits[0];
+        expect(wu.rawFiles).toContain('views/orders_ext.view.lkml');
+        // Ancestors already in rawFiles → not duplicated into dependencyPaths.
+        expect(wu.dependencyPaths).toEqual([]);
+    });
+    it('widens dependencyPaths when an ancestor is OUTSIDE the WU (synthesized cross-model case)', () => {
+        // Synthesize a scenario in-memory: two models, "a" owns base.view.lkml,
+        // "b" owns derived.view.lkml which extends base. A diff that only touches
+        // derived.view.lkml should widen b's WU with base.view.lkml in dependencyPaths
+        // if base lives outside b's rawFiles. In practice with the current emit rules,
+        // base.view.lkml would already be in dependencyPaths because model b lists
+        // base.view.lkml under its `include:`. Here we confirm the widening is idempotent.
+        const project = {
+            models: [
+                { path: 'a.model.lkml', name: 'a', includes: ['views/base.view.lkml'], explores: [], connectionName: null },
+                {
+                    path: 'b.model.lkml',
+                    name: 'b',
+                    includes: ['views/base.view.lkml', 'views/derived.view.lkml'],
+                    explores: [],
+                    connectionName: null,
+                },
+            ],
+            views: [
+                { path: 'views/base.view.lkml', name: 'base', extendsFrom: [], rawSqlTableName: null },
+                { path: 'views/derived.view.lkml', name: 'derived', extendsFrom: ['base'], rawSqlTableName: null },
+            ],
+            dashboards: [],
+            allPaths: ['a.model.lkml', 'b.model.lkml', 'views/base.view.lkml', 'views/derived.view.lkml'],
+        };
+        const result = chunkLookmlProject(project, {
+            diffSet: {
+                added: [],
+                modified: ['views/derived.view.lkml'],
+                deleted: [],
+                unchanged: ['a.model.lkml', 'b.model.lkml', 'views/base.view.lkml'],
+            },
+        });
+        const b = result.workUnits.find((wu) => wu.unitKey === 'lookml-b');
+        expect(b).toBeDefined();
+        if (!b) {
+            throw new Error('expected lookml-b work unit');
+        }
+        expect(b.dependencyPaths).toContain('views/base.view.lkml');
+    });
+    it('passes through diffSet.deleted as an EvictionUnit', async () => {
+        const project = await parseLookmlStagedDir(join(FIXTURE_ROOT, 'single-model'));
+        const result = chunkLookmlProject(project, {
+            diffSet: {
+                added: [],
+                modified: [],
+                deleted: ['views/zombie.view.lkml'],
+                unchanged: ['orders.model.lkml', 'views/customers.view.lkml', 'views/orders.view.lkml'],
+            },
+        });
+        expect(result.eviction).toEqual({ deletedRawPaths: ['views/zombie.view.lkml'] });
+        // No WU emitted because no current files are touched.
+        expect(result.workUnits).toEqual([]);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/detect.d.ts

@@ -0,0 +1 @@
+export declare function detectLookmlStagedDir(stagedDir: string): Promise<boolean>;

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/detect.js

@@ -0,0 +1,11 @@
+import { readdir } from 'node:fs/promises';
+const LKML_EXT_RE = /\.(lkml|lookml)$/i;
+export async function detectLookmlStagedDir(stagedDir) {
+    const entries = await readdir(stagedDir, { withFileTypes: true, recursive: true });
+    for (const entry of entries) {
+        if (entry.isFile() && LKML_EXT_RE.test(entry.name)) {
+            return true;
+        }
+    }
+    return false;
+}

package/node_modules/@ktx/context/dist/ingest/adapters/lookml/detect.test.d.ts

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