dbctx 1.4.6 → 2.0.1

package/dist/flow/interpreter.mjs

@@ -0,0 +1,605 @@
+import { existsSync } from 'node:fs';
+import { TRPCClientError } from '@trpc/client';
+import { computeSchemaHash } from '@dbctx/common/schema-hash';
+import { runInAction } from 'mobx';
+import { connectSSH } from '../app/ssh.mjs';
+import { connectDB } from '../app/db.mjs';
+import { assembleDatabase } from '../app/assemble.mjs';
+import { loadIntrospectionFromFile, populateIntrospectionCounts, } from '../app/load-introspection.mjs';
+import { createSession, waitForAuthorization, connectAccount, checkGate, checkBilling, } from '../app/session.mjs';
+import { buildSessionURL } from '../app/open-url.mjs';
+import { readConfig, flushConfig } from '../app/config.mjs';
+import { runSampling, prepareOutputDir, persistTableSamplesToDir, loadSensitiveMask, } from '../app/sample.mjs';
+import { fetchPublicPlannerStatistics } from '../db/index.mjs';
+import { createAuthenticatedTRPCClient } from '../lib/trpc.mjs';
+import { streamPostIntrospection, dispatchAndStreamPostSampling, } from '../app/tail.mjs';
+import { atomicWriteFile, recoverAtomicWrite } from '../lib/atomic-write.mjs';
+import { DBCTX_DEV } from '../lib/env.mjs';
+import { logger } from '../logger.mjs';
+import { when } from 'mobx';
+export const initialContext = () => ({
+    cleanupSSH: null,
+    db: null,
+    introspection: null,
+    authed: null,
+    postIntrospectionPoll: null,
+    explanation: null,
+});
+const errMsg = (e) => e instanceof Error ? e.message : String(e);
+// Pulls the structured `dbctx` payload tRPC's errorFormatter promotes onto
+// shape.data. Returns null for non-tRPC errors or non-gate errors so callers
+// can fall back to the prose `message`.
+const extractGateError = (e) => {
+    if (!(e instanceof TRPCClientError)) {
+        return null;
+    }
+    const data = e.data;
+    return data?.dbctx ?? null;
+};
+// Dispatches an ingest-failed event and, if the error carries structured
+// gate data, parks it on the store so the UI can render a tailored layout
+// instead of the prose `message`. The gate field sits outside the flow
+// projection on purpose — projection only owns `state`/`error`.
+const dispatchIngestFailed = (err, dispatch, store) => {
+    const gate = extractGateError(err);
+    if (gate !== null) {
+        runInAction(() => {
+            store.steps.ingestion.introspection.gate = gate;
+        });
+    }
+    dispatch({ kind: 'ingest-failed', error: errMsg(err) });
+};
+// Single phase transition handler. Called once per (prev → curr) phase
+// change with prev !== curr. Each branch fires the side effects for the
+// new phase and dispatches event(s) back when async work resolves.
+export const driveSide = async (prev, curr, store, ctx, dispatch) => {
+    if (prev !== null && prev.phase === curr.phase) {
+        // Side-channel sub-status updates don't trigger effects.
+        return;
+    }
+    if (curr.phase === 'connecting-ssh') {
+        try {
+            ctx.cleanupSSH = (await connectSSH(store)) ?? null;
+            // connectSSH may set enabled=false when no ssh flag was passed.
+            if (!store.steps.sshConnection.enabled) {
+                dispatch({ kind: 'ssh-not-needed' });
+                return;
+            }
+            await when(() => {
+                const s = store.steps.sshConnection.state;
+                return s === 'connected' || s === 'error';
+            });
+            const finalState = store.steps.sshConnection.state;
+            if (finalState === 'error') {
+                dispatch({
+                    kind: 'ssh-failed',
+                    error: store.steps.sshConnection.error ?? 'ssh failed',
+                });
+                return;
+            }
+            dispatch({ kind: 'ssh-connected' });
+        }
+        catch (err) {
+            dispatch({ kind: 'ssh-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'connecting-db') {
+        try {
+            ctx.db = (await connectDB(store)) ?? null;
+            await when(() => {
+                const s = store.steps.databaseConnection.state;
+                return s === 'connected' || s === 'error';
+            });
+            const dbState = store.steps.databaseConnection.state;
+            if (dbState === 'error' || ctx.db === null) {
+                dispatch({
+                    kind: 'db-failed',
+                    error: store.steps.databaseConnection.error ?? 'db failed',
+                });
+                return;
+            }
+            dispatch({ kind: 'db-connected' });
+        }
+        catch (err) {
+            dispatch({ kind: 'db-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'introspecting') {
+        if (ctx.db === null) {
+            dispatch({
+                kind: 'introspection-failed',
+                error: 'no db connection',
+            });
+            return;
+        }
+        try {
+            const useJsonPath = store.outputOptions.useIntrospectionJsonPath;
+            if (useJsonPath !== null) {
+                runInAction(() => {
+                    store.steps.introspection.state = 'fetching';
+                });
+                const loaded = await loadIntrospectionFromFile(useJsonPath, ctx.db.pool);
+                if (!loaded.ok) {
+                    runInAction(() => {
+                        store.steps.introspection.state = 'error';
+                        store.steps.introspection.error = loaded.error.message;
+                    });
+                    dispatch({
+                        kind: 'introspection-failed',
+                        error: loaded.error.message,
+                    });
+                    return;
+                }
+                populateIntrospectionCounts(store, loaded.result);
+                runInAction(() => {
+                    store.steps.introspection.state = 'done';
+                });
+                ctx.introspection = loaded.result;
+            }
+            else {
+                ctx.introspection = await assembleDatabase(ctx.db.pool, store);
+            }
+            if (DBCTX_DEV) {
+                const { databaseIntrospectionSchema } = await import('@dbctx/core/schemas/introspection');
+                databaseIntrospectionSchema.parse(ctx.introspection);
+            }
+            dispatch({ kind: 'introspection-loaded' });
+        }
+        catch (err) {
+            dispatch({ kind: 'introspection-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'output-json') {
+        const outputPath = curr.outputJSONPath;
+        if (outputPath === null || ctx.introspection === null) {
+            dispatch({ kind: 'output-json-not-requested' });
+            return;
+        }
+        try {
+            await recoverAtomicWrite(outputPath);
+            if (existsSync(outputPath) &&
+                !store.outputOptions.allowIntrospectionJsonOverwrite) {
+                runInAction(() => {
+                    store.steps.outputJson.state = 'prompting-overwrite';
+                    store.steps.outputJson.path = outputPath;
+                });
+                await when(() => store.steps.outputJson.confirmed !== null);
+                if (!store.steps.outputJson.confirmed) {
+                    dispatch({ kind: 'output-json-skipped' });
+                    return;
+                }
+            }
+            runInAction(() => {
+                store.steps.outputJson.state = 'writing';
+                store.steps.outputJson.path = outputPath;
+            });
+            await atomicWriteFile(outputPath, JSON.stringify(ctx.introspection, null, 2));
+            runInAction(() => {
+                store.steps.outputJson.state = 'done';
+            });
+            dispatch({ kind: 'output-json-written' });
+        }
+        catch (err) {
+            runInAction(() => {
+                store.steps.outputJson.state = 'error';
+                store.steps.outputJson.error = errMsg(err);
+            });
+            dispatch({ kind: 'output-json-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'creating-session') {
+        if (ctx.db === null || ctx.introspection === null) {
+            dispatch({
+                kind: 'session-failed',
+                error: 'no db or introspection in context',
+            });
+            return;
+        }
+        try {
+            const config = await readConfig();
+            const sessionId = await createSession(ctx.db.pool, ctx.introspection, store, config.token ?? null, config.device_id);
+            // Re-auth fast-path: if existing config token is still valid,
+            // skip the browser-auth handshake entirely.
+            if (config.token) {
+                try {
+                    await connectAccount(config.token, store);
+                    await checkBilling(config.token, buildSessionURL(sessionId), store);
+                    const canContinue = await checkGate(config.token, store);
+                    if (!canContinue) {
+                        dispatch({ kind: 'auth-not-needed' });
+                        return;
+                    }
+                    // Single dispatch carrying both sessionId and token.
+                    // Avoids transitioning through awaiting-authorization,
+                    // which would race-fire waitForAuthorization and stomp
+                    // the already-'connected' account state back to 'waiting'.
+                    dispatch({
+                        kind: 'fast-path-completed',
+                        sessionId,
+                        token: config.token,
+                    });
+                    return;
+                }
+                catch (err) {
+                    if (err instanceof TRPCClientError &&
+                        (err.data?.code === 'UNAUTHORIZED' ||
+                            err.data?.code === 'NOT_FOUND')) {
+                        await flushConfig();
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            dispatch({ kind: 'session-created', sessionId });
+        }
+        catch (err) {
+            dispatch({ kind: 'session-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'awaiting-authorization') {
+        if (curr.sessionId === null) {
+            dispatch({ kind: 'auth-failed', error: 'no sessionId in state' });
+            return;
+        }
+        try {
+            await waitForAuthorization(curr.sessionId, store);
+            const freshToken = (await readConfig()).token;
+            if (!freshToken) {
+                dispatch({ kind: 'auth-failed', error: 'no token after auth' });
+                return;
+            }
+            await checkBilling(freshToken, buildSessionURL(curr.sessionId), store);
+            const canContinue = await checkGate(freshToken, store);
+            if (!canContinue) {
+                dispatch({ kind: 'auth-failed', error: 'gate blocked' });
+                return;
+            }
+            dispatch({ kind: 'auth-confirmed', token: freshToken });
+        }
+        catch (err) {
+            dispatch({ kind: 'auth-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'awaiting-explanation') {
+        if (curr.explanation !== null) {
+            ctx.explanation = curr.explanation;
+            runInAction(() => {
+                store.steps.userExplanation.state = 'done';
+                store.steps.userExplanation.value = curr.explanation;
+            });
+            dispatch({
+                kind: 'explanation-given',
+                value: curr.explanation,
+            });
+            return;
+        }
+        runInAction(() => {
+            store.steps.userExplanation.state = 'prompting';
+        });
+        await when(() => store.steps.userExplanation.state === 'done');
+        const v = store.steps.userExplanation.value ?? '';
+        ctx.explanation = v;
+        dispatch({ kind: 'explanation-given', value: v });
+        return;
+    }
+    if (curr.phase === 'preflight-checking') {
+        if (ctx.db === null ||
+            ctx.introspection === null ||
+            curr.authToken === null ||
+            curr.sessionId === null) {
+            dispatch({
+                kind: 'ingest-failed',
+                error: 'context not ready for preflight',
+            });
+            return;
+        }
+        try {
+            ctx.authed = createAuthenticatedTRPCClient(() => Promise.resolve(curr.authToken));
+            const explanation = ctx.explanation ?? curr.explanation;
+            if (explanation !== null) {
+                ctx.introspection.userExplanation = explanation;
+            }
+            const plannerStats = await fetchPublicPlannerStatistics(ctx.db.pool);
+            const introspectionHash = computeSchemaHash(ctx.introspection);
+            const checkHit = await ctx.authed.revisions.checkIntrospection.mutate({
+                sessionId: curr.sessionId,
+                introspectionHash,
+                systemIdentifier: ctx.introspection.identifier.system_identifier,
+                databaseOID: String(ctx.introspection.identifier.database_oid),
+                plannerStatistics: { relations: plannerStats },
+            });
+            if (checkHit !== null) {
+                runInAction(() => {
+                    store.landingURL = checkHit.landingURL;
+                });
+                kickPostIntrospectionPoll(ctx, checkHit.postIntrospectionJobId, store);
+                dispatch({
+                    kind: 'check-introspection-hit',
+                    revisionId: checkHit.revisionId,
+                    samplesExist: checkHit.samplesExist,
+                    tablesNeedingSamples: checkHit.tablesNeedingSamples,
+                    postIntrospectionJobId: checkHit.postIntrospectionJobId,
+                });
+                return;
+            }
+            dispatch({ kind: 'check-introspection-miss' });
+        }
+        catch (err) {
+            dispatchIngestFailed(err, dispatch, store);
+        }
+        return;
+    }
+    if (curr.phase === 'ingesting-introspection') {
+        if (ctx.authed === null ||
+            ctx.introspection === null ||
+            curr.sessionId === null ||
+            ctx.db === null) {
+            dispatch({
+                kind: 'ingest-failed',
+                error: 'context not ready for ingest',
+            });
+            return;
+        }
+        try {
+            runInAction(() => {
+                store.steps.ingestion.introspection.state = 'uploading';
+            });
+            const plannerStats = await fetchPublicPlannerStatistics(ctx.db.pool);
+            const ingest = await ctx.authed.revisions.ingestIntrospection.mutate({
+                sessionId: curr.sessionId,
+                introspection: ctx.introspection,
+                plannerStatistics: { relations: plannerStats },
+            });
+            runInAction(() => {
+                store.landingURL = ingest.landingURL;
+            });
+            kickPostIntrospectionPoll(ctx, ingest.postIntrospectionJobId, store);
+            dispatch({
+                kind: 'introspection-ingested',
+                revisionId: ingest.revisionId,
+                samplesExist: ingest.samplesExist,
+                tablesNeedingSamples: ingest.tablesNeedingSamples,
+                postIntrospectionJobId: ingest.postIntrospectionJobId,
+            });
+        }
+        catch (err) {
+            dispatchIngestFailed(err, dispatch, store);
+        }
+        return;
+    }
+    if (curr.phase === 'sampling-mask-resolving') {
+        if (ctx.authed === null ||
+            curr.revisionId === null ||
+            ctx.introspection === null) {
+            dispatch({
+                kind: 'mask-fetch-failed',
+                error: 'context not ready for mask resolution',
+            });
+            return;
+        }
+        try {
+            const fileMaskPath = curr.fileMaskPath;
+            if (fileMaskPath !== null) {
+                const mask = await loadSensitiveMask(fileMaskPath);
+                dispatch({ kind: 'mask-loaded', mask });
+                return;
+            }
+            // Server-managed mask: wait for post-introspection to finish.
+            if (ctx.postIntrospectionPoll !== null) {
+                await ctx.postIntrospectionPoll;
+                ctx.postIntrospectionPoll = null;
+            }
+            // After the await, sub-status reflects post-introspection state.
+            // The reducer's projection won't have re-fired driveSide on its own
+            // (sub-status only). Inspect store directly.
+            if (store.steps.ingestion.postIntrospection.state === 'error') {
+                dispatch({
+                    kind: 'mask-fetch-failed',
+                    error: 'post-introspection enrichment failed — sensitive mask unavailable; refusing to sample',
+                });
+                return;
+            }
+            const res = await ctx.authed.revisions.getSensitiveMask.query({
+                revisionId: curr.revisionId,
+            });
+            if (!res.ready) {
+                dispatch({
+                    kind: 'mask-fetch-failed',
+                    error: 'server reported sensitive mask not ready after post-introspection completion; refusing to sample',
+                });
+                return;
+            }
+            dispatch({ kind: 'mask-loaded', mask: res.mask });
+        }
+        catch (err) {
+            dispatch({ kind: 'mask-fetch-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'sampling') {
+        if (ctx.db === null ||
+            ctx.introspection === null ||
+            curr.sampling.mask === null) {
+            dispatch({
+                kind: 'sampling-failed',
+                error: 'context not ready for sampling',
+            });
+            return;
+        }
+        try {
+            const mask = curr.sampling.mask;
+            const sampleFileIndex = {};
+            const outputDir = curr.outputSamplesDir;
+            if (outputDir !== null) {
+                const ready = await prepareOutputDir(outputDir, store.outputOptions.allowSampleOverwrite, store);
+                if (!ready) {
+                    dispatch({
+                        kind: 'sampling-failed',
+                        error: 'output dir not ready',
+                    });
+                    return;
+                }
+            }
+            // Filter the per-table sampling loop to only the tables the
+            // server flagged as needing fresh samples. Null = pre-handshake
+            // sentinel; treat as "all tables" for safety.
+            const tableFilter = curr.tablesNeedingSamples === null
+                ? undefined
+                : new Set(curr.tablesNeedingSamples);
+            for await (const event of runSampling(ctx.db.pool, ctx.introspection, store, mask, tableFilter)) {
+                if (outputDir !== null) {
+                    await persistTableSamplesToDir(outputDir, event, sampleFileIndex);
+                }
+                dispatch({ kind: 'sample-table-yielded', event });
+            }
+            dispatch({ kind: 'sampling-completed' });
+        }
+        catch (err) {
+            dispatch({ kind: 'sampling-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'uploading-samples') {
+        if (ctx.authed === null || curr.revisionId === null) {
+            dispatch({
+                kind: 'samples-upload-failed',
+                error: 'context not ready for upload',
+            });
+            return;
+        }
+        try {
+            const samples = curr.sampling.collected;
+            if (samples.length === 0) {
+                runInAction(() => {
+                    store.steps.ingestion.samples.state = 'done';
+                });
+                dispatch({ kind: 'samples-upload-not-needed' });
+                return;
+            }
+            const sampleInputs = samples.map((event) => ({
+                tableName: event.tableName,
+                columns: Object.fromEntries(Object.entries(event.samples.columns).map(([col, s]) => [
+                    col,
+                    [...s.values],
+                ])),
+            }));
+            const CHUNK_SIZE = 25;
+            runInAction(() => {
+                store.steps.ingestion.samples.state = 'uploading';
+                store.steps.ingestion.samples.totalTables = sampleInputs.length;
+                store.steps.ingestion.samples.uploadedTables = 0;
+            });
+            const chunks = Array.from({ length: Math.ceil(sampleInputs.length / CHUNK_SIZE) }, (_, i) => sampleInputs.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE));
+            for (let i = 0; i < chunks.length; i++) {
+                const chunk = chunks[i];
+                await ctx.authed.revisions.ingestSamples.mutate({
+                    revisionId: curr.revisionId,
+                    samples: chunk,
+                    chunkIndex: i,
+                    chunkTotal: chunks.length,
+                });
+                runInAction(() => {
+                    store.steps.ingestion.samples.uploadedTables +=
+                        chunk.length;
+                });
+                dispatch({
+                    kind: 'sample-chunk-uploaded',
+                    chunkSize: chunk.length,
+                });
+            }
+            runInAction(() => {
+                store.steps.ingestion.samples.state = 'done';
+            });
+            logger.info(`ingested ${sampleInputs.length} sample tables in ${chunks.length} chunk(s)`);
+            dispatch({ kind: 'samples-upload-completed' });
+        }
+        catch (err) {
+            dispatch({ kind: 'samples-upload-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'awaiting-post-sampling') {
+        if (ctx.authed === null || curr.revisionId === null) {
+            dispatch({
+                kind: 'post-sampling-failed',
+                error: 'context not ready',
+            });
+            return;
+        }
+        try {
+            // First ensure post-introspection finished (file-mask fast path may
+            // have skipped the explicit await earlier).
+            if (ctx.postIntrospectionPoll !== null) {
+                await ctx.postIntrospectionPoll;
+                ctx.postIntrospectionPoll = null;
+            }
+            if (store.steps.ingestion.postIntrospection.state === 'error') {
+                runInAction(() => {
+                    store.steps.ingestion.postSampling.state = 'error';
+                    store.steps.ingestion.postSampling.error =
+                        'skipped — post-introspection enrichment failed';
+                });
+                dispatch({
+                    kind: 'post-sampling-failed',
+                    error: 'post-introspection enrichment failed',
+                });
+                return;
+            }
+            await dispatchAndStreamPostSampling(ctx.authed, curr.revisionId, store);
+            if (store.steps.ingestion.postSampling.state === 'error') {
+                dispatch({
+                    kind: 'post-sampling-failed',
+                    error: store.steps.ingestion.postSampling.error ??
+                        'post-sampling failed',
+                });
+                return;
+            }
+            dispatch({ kind: 'post-sampling-completed' });
+        }
+        catch (err) {
+            dispatch({ kind: 'post-sampling-failed', error: errMsg(err) });
+        }
+        return;
+    }
+    if (curr.phase === 'done' || curr.phase === 'error') {
+        cleanup(ctx);
+        return;
+    }
+};
+const kickPostIntrospectionPoll = (ctx, jobId, store) => {
+    runInAction(() => {
+        if (jobId === null) {
+            store.steps.ingestion.postIntrospection.state = 'done';
+            store.steps.ingestion.postIntrospection.reused = true;
+        }
+        else {
+            store.steps.ingestion.postIntrospection.jobId = jobId;
+            if (store.steps.ingestion.postIntrospection.state === 'idle') {
+                store.steps.ingestion.postIntrospection.state = 'queued';
+            }
+        }
+    });
+    if (jobId === null || ctx.authed === null) {
+        ctx.postIntrospectionPoll = Promise.resolve();
+        return;
+    }
+    ctx.postIntrospectionPoll = streamPostIntrospection(ctx.authed, jobId, store).then(() => { }, () => { });
+};
+export const cleanup = (ctx) => {
+    if (ctx.db !== null) {
+        ctx.db.cleanup();
+        ctx.db = null;
+    }
+    if (ctx.cleanupSSH !== null) {
+        ctx.cleanupSSH();
+        ctx.cleanupSSH = null;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interpreter.mjs","sourceRoot":"./src/","sources":["flow/interpreter.mts"],"names":[],"mappings":"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","sourcesContent":["import {existsSync} from 'node:fs';\nimport type {TRPCClient} from '@trpc/client';\nimport type {TAppRouter, TGateErrorData} from '@dbctx/core';\nimport {TRPCClientError} from '@trpc/client';\nimport {computeSchemaHash} from '@dbctx/common/schema-hash';\nimport {runInAction} from 'mobx';\nimport {connectSSH} from '../app/ssh.mjs';\nimport {connectDB, type TDBConnection} from '../app/db.mjs';\nimport {assembleDatabase} from '../app/assemble.mjs';\nimport {\n    loadIntrospectionFromFile,\n    populateIntrospectionCounts,\n} from '../app/load-introspection.mjs';\nimport {\n    createSession,\n    waitForAuthorization,\n    connectAccount,\n    checkGate,\n    checkBilling,\n} from '../app/session.mjs';\nimport {buildSessionURL} from '../app/open-url.mjs';\nimport {readConfig, flushConfig} from '../app/config.mjs';\nimport {\n    runSampling,\n    prepareOutputDir,\n    persistTableSamplesToDir,\n    loadSensitiveMask,\n    type TSensitiveMask,\n} from '../app/sample.mjs';\nimport {fetchPublicPlannerStatistics} from '../db/index.mjs';\nimport {createAuthenticatedTRPCClient} from '../lib/trpc.mjs';\nimport {\n    streamPostIntrospection,\n    dispatchAndStreamPostSampling,\n} from '../app/tail.mjs';\nimport {atomicWriteFile, recoverAtomicWrite} from '../lib/atomic-write.mjs';\nimport {DBCTX_DEV} from '../lib/env.mjs';\nimport {logger} from '../logger.mjs';\nimport type {TStore} from '../store.mjs';\nimport type {TFlowEvent} from './events.mjs';\nimport type {TFlowState} from './states.mjs';\nimport {when} from 'mobx';\n\n// Effect handles the interpreter accumulates as the flow advances. Not\n// part of TFlowState because they aren't pure data — Promise handles, DB\n// pools, cleanup callbacks. The dispatcher closes over this context.\nexport type TInterpreterContext = {\n    cleanupSSH: (() => void) | null;\n    db: TDBConnection | null;\n    introspection: Awaited<ReturnType<typeof assembleDatabase>> | null;\n    authed: TRPCClient<TAppRouter> | null;\n    postIntrospectionPoll: Promise<void> | null;\n    explanation: string | null;\n};\n\nexport const initialContext = (): TInterpreterContext => ({\n    cleanupSSH: null,\n    db: null,\n    introspection: null,\n    authed: null,\n    postIntrospectionPoll: null,\n    explanation: null,\n});\n\ntype TDispatch = (event: TFlowEvent) => void;\n\nconst errMsg = (e: unknown): string =>\n    e instanceof Error ? e.message : String(e);\n\n// Pulls the structured `dbctx` payload tRPC's errorFormatter promotes onto\n// shape.data. Returns null for non-tRPC errors or non-gate errors so callers\n// can fall back to the prose `message`.\nconst extractGateError = (e: unknown): TGateErrorData | null => {\n    if (!(e instanceof TRPCClientError)) {\n        return null;\n    }\n    const data = e.data as {dbctx?: TGateErrorData | null} | undefined;\n    return data?.dbctx ?? null;\n};\n\n// Dispatches an ingest-failed event and, if the error carries structured\n// gate data, parks it on the store so the UI can render a tailored layout\n// instead of the prose `message`. The gate field sits outside the flow\n// projection on purpose — projection only owns `state`/`error`.\nconst dispatchIngestFailed = (\n    err: unknown,\n    dispatch: TDispatch,\n    store: TStore,\n): void => {\n    const gate = extractGateError(err);\n    if (gate !== null) {\n        runInAction(() => {\n            store.steps.ingestion.introspection.gate = gate;\n        });\n    }\n    dispatch({kind: 'ingest-failed', error: errMsg(err)});\n};\n\n// Single phase transition handler. Called once per (prev → curr) phase\n// change with prev !== curr. Each branch fires the side effects for the\n// new phase and dispatches event(s) back when async work resolves.\nexport const driveSide = async (\n    prev: TFlowState | null,\n    curr: TFlowState,\n    store: TStore,\n    ctx: TInterpreterContext,\n    dispatch: TDispatch,\n): Promise<void> => {\n    if (prev !== null && prev.phase === curr.phase) {\n        // Side-channel sub-status updates don't trigger effects.\n        return;\n    }\n\n    if (curr.phase === 'connecting-ssh') {\n        try {\n            ctx.cleanupSSH = (await connectSSH(store)) ?? null;\n            // connectSSH may set enabled=false when no ssh flag was passed.\n            if (!store.steps.sshConnection.enabled) {\n                dispatch({kind: 'ssh-not-needed'});\n                return;\n            }\n            await when(() => {\n                const s: string = store.steps.sshConnection.state;\n                return s === 'connected' || s === 'error';\n            });\n            const finalState: string = store.steps.sshConnection.state;\n            if (finalState === 'error') {\n                dispatch({\n                    kind: 'ssh-failed',\n                    error: store.steps.sshConnection.error ?? 'ssh failed',\n                });\n                return;\n            }\n            dispatch({kind: 'ssh-connected'});\n        } catch (err) {\n            dispatch({kind: 'ssh-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'connecting-db') {\n        try {\n            ctx.db = (await connectDB(store)) ?? null;\n            await when(() => {\n                const s: string = store.steps.databaseConnection.state;\n                return s === 'connected' || s === 'error';\n            });\n            const dbState: string = store.steps.databaseConnection.state;\n            if (dbState === 'error' || ctx.db === null) {\n                dispatch({\n                    kind: 'db-failed',\n                    error: store.steps.databaseConnection.error ?? 'db failed',\n                });\n                return;\n            }\n            dispatch({kind: 'db-connected'});\n        } catch (err) {\n            dispatch({kind: 'db-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'introspecting') {\n        if (ctx.db === null) {\n            dispatch({\n                kind: 'introspection-failed',\n                error: 'no db connection',\n            });\n            return;\n        }\n        try {\n            const useJsonPath = store.outputOptions.useIntrospectionJsonPath;\n            if (useJsonPath !== null) {\n                runInAction(() => {\n                    store.steps.introspection.state = 'fetching';\n                });\n                const loaded = await loadIntrospectionFromFile(\n                    useJsonPath,\n                    ctx.db.pool,\n                );\n                if (!loaded.ok) {\n                    runInAction(() => {\n                        store.steps.introspection.state = 'error';\n                        store.steps.introspection.error = loaded.error.message;\n                    });\n                    dispatch({\n                        kind: 'introspection-failed',\n                        error: loaded.error.message,\n                    });\n                    return;\n                }\n                populateIntrospectionCounts(store, loaded.result);\n                runInAction(() => {\n                    store.steps.introspection.state = 'done';\n                });\n                ctx.introspection = loaded.result;\n            } else {\n                ctx.introspection = await assembleDatabase(ctx.db.pool, store);\n            }\n\n            if (DBCTX_DEV) {\n                const {databaseIntrospectionSchema} =\n                    await import('@dbctx/core/schemas/introspection');\n                databaseIntrospectionSchema.parse(ctx.introspection);\n            }\n            dispatch({kind: 'introspection-loaded'});\n        } catch (err) {\n            dispatch({kind: 'introspection-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'output-json') {\n        const outputPath = curr.outputJSONPath;\n        if (outputPath === null || ctx.introspection === null) {\n            dispatch({kind: 'output-json-not-requested'});\n            return;\n        }\n        try {\n            await recoverAtomicWrite(outputPath);\n            if (\n                existsSync(outputPath) &&\n                !store.outputOptions.allowIntrospectionJsonOverwrite\n            ) {\n                runInAction(() => {\n                    store.steps.outputJson.state = 'prompting-overwrite';\n                    store.steps.outputJson.path = outputPath;\n                });\n                await when(() => store.steps.outputJson.confirmed !== null);\n                if (!store.steps.outputJson.confirmed) {\n                    dispatch({kind: 'output-json-skipped'});\n                    return;\n                }\n            }\n            runInAction(() => {\n                store.steps.outputJson.state = 'writing';\n                store.steps.outputJson.path = outputPath;\n            });\n            await atomicWriteFile(\n                outputPath,\n                JSON.stringify(ctx.introspection, null, 2),\n            );\n            runInAction(() => {\n                store.steps.outputJson.state = 'done';\n            });\n            dispatch({kind: 'output-json-written'});\n        } catch (err) {\n            runInAction(() => {\n                store.steps.outputJson.state = 'error';\n                store.steps.outputJson.error = errMsg(err);\n            });\n            dispatch({kind: 'output-json-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'creating-session') {\n        if (ctx.db === null || ctx.introspection === null) {\n            dispatch({\n                kind: 'session-failed',\n                error: 'no db or introspection in context',\n            });\n            return;\n        }\n        try {\n            const config = await readConfig();\n            const sessionId = await createSession(\n                ctx.db.pool,\n                ctx.introspection,\n                store,\n                config.token ?? null,\n                config.device_id,\n            );\n\n            // Re-auth fast-path: if existing config token is still valid,\n            // skip the browser-auth handshake entirely.\n            if (config.token) {\n                try {\n                    await connectAccount(config.token, store);\n                    await checkBilling(\n                        config.token,\n                        buildSessionURL(sessionId),\n                        store,\n                    );\n                    const canContinue = await checkGate(config.token, store);\n                    if (!canContinue) {\n                        dispatch({kind: 'auth-not-needed'});\n                        return;\n                    }\n                    // Single dispatch carrying both sessionId and token.\n                    // Avoids transitioning through awaiting-authorization,\n                    // which would race-fire waitForAuthorization and stomp\n                    // the already-'connected' account state back to 'waiting'.\n                    dispatch({\n                        kind: 'fast-path-completed',\n                        sessionId,\n                        token: config.token,\n                    });\n                    return;\n                } catch (err) {\n                    if (\n                        err instanceof TRPCClientError &&\n                        (err.data?.code === 'UNAUTHORIZED' ||\n                            err.data?.code === 'NOT_FOUND')\n                    ) {\n                        await flushConfig();\n                    } else {\n                        throw err;\n                    }\n                }\n            }\n\n            dispatch({kind: 'session-created', sessionId});\n        } catch (err) {\n            dispatch({kind: 'session-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'awaiting-authorization') {\n        if (curr.sessionId === null) {\n            dispatch({kind: 'auth-failed', error: 'no sessionId in state'});\n            return;\n        }\n        try {\n            await waitForAuthorization(curr.sessionId, store);\n            const freshToken = (await readConfig()).token;\n            if (!freshToken) {\n                dispatch({kind: 'auth-failed', error: 'no token after auth'});\n                return;\n            }\n            await checkBilling(\n                freshToken,\n                buildSessionURL(curr.sessionId),\n                store,\n            );\n            const canContinue = await checkGate(freshToken, store);\n            if (!canContinue) {\n                dispatch({kind: 'auth-failed', error: 'gate blocked'});\n                return;\n            }\n            dispatch({kind: 'auth-confirmed', token: freshToken});\n        } catch (err) {\n            dispatch({kind: 'auth-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'awaiting-explanation') {\n        if (curr.explanation !== null) {\n            ctx.explanation = curr.explanation;\n            runInAction(() => {\n                store.steps.userExplanation.state = 'done';\n                store.steps.userExplanation.value = curr.explanation;\n            });\n            dispatch({\n                kind: 'explanation-given',\n                value: curr.explanation,\n            });\n            return;\n        }\n        runInAction(() => {\n            store.steps.userExplanation.state = 'prompting';\n        });\n        await when(() => store.steps.userExplanation.state === 'done');\n        const v = store.steps.userExplanation.value ?? '';\n        ctx.explanation = v;\n        dispatch({kind: 'explanation-given', value: v});\n        return;\n    }\n\n    if (curr.phase === 'preflight-checking') {\n        if (\n            ctx.db === null ||\n            ctx.introspection === null ||\n            curr.authToken === null ||\n            curr.sessionId === null\n        ) {\n            dispatch({\n                kind: 'ingest-failed',\n                error: 'context not ready for preflight',\n            });\n            return;\n        }\n        try {\n            ctx.authed = createAuthenticatedTRPCClient(() =>\n                Promise.resolve(curr.authToken!),\n            );\n            const explanation = ctx.explanation ?? curr.explanation;\n            if (explanation !== null) {\n                ctx.introspection.userExplanation = explanation;\n            }\n            const plannerStats = await fetchPublicPlannerStatistics(\n                ctx.db.pool,\n            );\n            const introspectionHash = computeSchemaHash(ctx.introspection);\n            const checkHit =\n                await ctx.authed.revisions.checkIntrospection.mutate({\n                    sessionId: curr.sessionId,\n                    introspectionHash,\n                    systemIdentifier:\n                        ctx.introspection.identifier.system_identifier,\n                    databaseOID: String(\n                        ctx.introspection.identifier.database_oid,\n                    ),\n                    plannerStatistics: {relations: plannerStats},\n                });\n            if (checkHit !== null) {\n                runInAction(() => {\n                    store.landingURL = checkHit.landingURL;\n                });\n                kickPostIntrospectionPoll(\n                    ctx,\n                    checkHit.postIntrospectionJobId,\n                    store,\n                );\n                dispatch({\n                    kind: 'check-introspection-hit',\n                    revisionId: checkHit.revisionId,\n                    samplesExist: checkHit.samplesExist,\n                    tablesNeedingSamples: checkHit.tablesNeedingSamples,\n                    postIntrospectionJobId: checkHit.postIntrospectionJobId,\n                });\n                return;\n            }\n            dispatch({kind: 'check-introspection-miss'});\n        } catch (err) {\n            dispatchIngestFailed(err, dispatch, store);\n        }\n        return;\n    }\n\n    if (curr.phase === 'ingesting-introspection') {\n        if (\n            ctx.authed === null ||\n            ctx.introspection === null ||\n            curr.sessionId === null ||\n            ctx.db === null\n        ) {\n            dispatch({\n                kind: 'ingest-failed',\n                error: 'context not ready for ingest',\n            });\n            return;\n        }\n        try {\n            runInAction(() => {\n                store.steps.ingestion.introspection.state = 'uploading';\n            });\n            const plannerStats = await fetchPublicPlannerStatistics(\n                ctx.db.pool,\n            );\n            const ingest =\n                await ctx.authed.revisions.ingestIntrospection.mutate({\n                    sessionId: curr.sessionId,\n                    introspection: ctx.introspection,\n                    plannerStatistics: {relations: plannerStats},\n                });\n            runInAction(() => {\n                store.landingURL = ingest.landingURL;\n            });\n            kickPostIntrospectionPoll(\n                ctx,\n                ingest.postIntrospectionJobId,\n                store,\n            );\n            dispatch({\n                kind: 'introspection-ingested',\n                revisionId: ingest.revisionId,\n                samplesExist: ingest.samplesExist,\n                tablesNeedingSamples: ingest.tablesNeedingSamples,\n                postIntrospectionJobId: ingest.postIntrospectionJobId,\n            });\n        } catch (err) {\n            dispatchIngestFailed(err, dispatch, store);\n        }\n        return;\n    }\n\n    if (curr.phase === 'sampling-mask-resolving') {\n        if (\n            ctx.authed === null ||\n            curr.revisionId === null ||\n            ctx.introspection === null\n        ) {\n            dispatch({\n                kind: 'mask-fetch-failed',\n                error: 'context not ready for mask resolution',\n            });\n            return;\n        }\n        try {\n            const fileMaskPath = curr.fileMaskPath;\n            if (fileMaskPath !== null) {\n                const mask = await loadSensitiveMask(fileMaskPath);\n                dispatch({kind: 'mask-loaded', mask});\n                return;\n            }\n            // Server-managed mask: wait for post-introspection to finish.\n            if (ctx.postIntrospectionPoll !== null) {\n                await ctx.postIntrospectionPoll;\n                ctx.postIntrospectionPoll = null;\n            }\n            // After the await, sub-status reflects post-introspection state.\n            // The reducer's projection won't have re-fired driveSide on its own\n            // (sub-status only). Inspect store directly.\n            if (store.steps.ingestion.postIntrospection.state === 'error') {\n                dispatch({\n                    kind: 'mask-fetch-failed',\n                    error: 'post-introspection enrichment failed — sensitive mask unavailable; refusing to sample',\n                });\n                return;\n            }\n            const res = await ctx.authed.revisions.getSensitiveMask.query({\n                revisionId: curr.revisionId,\n            });\n            if (!res.ready) {\n                dispatch({\n                    kind: 'mask-fetch-failed',\n                    error: 'server reported sensitive mask not ready after post-introspection completion; refusing to sample',\n                });\n                return;\n            }\n            dispatch({kind: 'mask-loaded', mask: res.mask});\n        } catch (err) {\n            dispatch({kind: 'mask-fetch-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'sampling') {\n        if (\n            ctx.db === null ||\n            ctx.introspection === null ||\n            curr.sampling.mask === null\n        ) {\n            dispatch({\n                kind: 'sampling-failed',\n                error: 'context not ready for sampling',\n            });\n            return;\n        }\n        try {\n            const mask: TSensitiveMask = curr.sampling.mask;\n            const sampleFileIndex: Record<string, string> = {};\n            const outputDir = curr.outputSamplesDir;\n            if (outputDir !== null) {\n                const ready = await prepareOutputDir(\n                    outputDir,\n                    store.outputOptions.allowSampleOverwrite,\n                    store,\n                );\n                if (!ready) {\n                    dispatch({\n                        kind: 'sampling-failed',\n                        error: 'output dir not ready',\n                    });\n                    return;\n                }\n            }\n            // Filter the per-table sampling loop to only the tables the\n            // server flagged as needing fresh samples. Null = pre-handshake\n            // sentinel; treat as \"all tables\" for safety.\n            const tableFilter: ReadonlySet<string> | undefined =\n                curr.tablesNeedingSamples === null\n                    ? undefined\n                    : new Set(curr.tablesNeedingSamples);\n            for await (const event of runSampling(\n                ctx.db.pool,\n                ctx.introspection,\n                store,\n                mask,\n                tableFilter,\n            )) {\n                if (outputDir !== null) {\n                    await persistTableSamplesToDir(\n                        outputDir,\n                        event,\n                        sampleFileIndex,\n                    );\n                }\n                dispatch({kind: 'sample-table-yielded', event});\n            }\n            dispatch({kind: 'sampling-completed'});\n        } catch (err) {\n            dispatch({kind: 'sampling-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'uploading-samples') {\n        if (ctx.authed === null || curr.revisionId === null) {\n            dispatch({\n                kind: 'samples-upload-failed',\n                error: 'context not ready for upload',\n            });\n            return;\n        }\n        try {\n            const samples = curr.sampling.collected;\n            if (samples.length === 0) {\n                runInAction(() => {\n                    store.steps.ingestion.samples.state = 'done';\n                });\n                dispatch({kind: 'samples-upload-not-needed'});\n                return;\n            }\n            const sampleInputs = samples.map((event) => ({\n                tableName: event.tableName,\n                columns: Object.fromEntries(\n                    Object.entries(event.samples.columns).map(([col, s]) => [\n                        col,\n                        [...s.values],\n                    ]),\n                ),\n            }));\n            const CHUNK_SIZE = 25;\n            runInAction(() => {\n                store.steps.ingestion.samples.state = 'uploading';\n                store.steps.ingestion.samples.totalTables = sampleInputs.length;\n                store.steps.ingestion.samples.uploadedTables = 0;\n            });\n            const chunks = Array.from(\n                {length: Math.ceil(sampleInputs.length / CHUNK_SIZE)},\n                (_, i) =>\n                    sampleInputs.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE),\n            );\n            for (let i = 0; i < chunks.length; i++) {\n                const chunk = chunks[i];\n                await ctx.authed.revisions.ingestSamples.mutate({\n                    revisionId: curr.revisionId,\n                    samples: chunk,\n                    chunkIndex: i,\n                    chunkTotal: chunks.length,\n                });\n                runInAction(() => {\n                    store.steps.ingestion.samples.uploadedTables +=\n                        chunk.length;\n                });\n                dispatch({\n                    kind: 'sample-chunk-uploaded',\n                    chunkSize: chunk.length,\n                });\n            }\n            runInAction(() => {\n                store.steps.ingestion.samples.state = 'done';\n            });\n            logger.info(\n                `ingested ${sampleInputs.length} sample tables in ${chunks.length} chunk(s)`,\n            );\n            dispatch({kind: 'samples-upload-completed'});\n        } catch (err) {\n            dispatch({kind: 'samples-upload-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'awaiting-post-sampling') {\n        if (ctx.authed === null || curr.revisionId === null) {\n            dispatch({\n                kind: 'post-sampling-failed',\n                error: 'context not ready',\n            });\n            return;\n        }\n        try {\n            // First ensure post-introspection finished (file-mask fast path may\n            // have skipped the explicit await earlier).\n            if (ctx.postIntrospectionPoll !== null) {\n                await ctx.postIntrospectionPoll;\n                ctx.postIntrospectionPoll = null;\n            }\n            if (store.steps.ingestion.postIntrospection.state === 'error') {\n                runInAction(() => {\n                    store.steps.ingestion.postSampling.state = 'error';\n                    store.steps.ingestion.postSampling.error =\n                        'skipped — post-introspection enrichment failed';\n                });\n                dispatch({\n                    kind: 'post-sampling-failed',\n                    error: 'post-introspection enrichment failed',\n                });\n                return;\n            }\n            await dispatchAndStreamPostSampling(\n                ctx.authed,\n                curr.revisionId,\n                store,\n            );\n            if (store.steps.ingestion.postSampling.state === 'error') {\n                dispatch({\n                    kind: 'post-sampling-failed',\n                    error:\n                        store.steps.ingestion.postSampling.error ??\n                        'post-sampling failed',\n                });\n                return;\n            }\n            dispatch({kind: 'post-sampling-completed'});\n        } catch (err) {\n            dispatch({kind: 'post-sampling-failed', error: errMsg(err)});\n        }\n        return;\n    }\n\n    if (curr.phase === 'done' || curr.phase === 'error') {\n        cleanup(ctx);\n        return;\n    }\n};\n\nconst kickPostIntrospectionPoll = (\n    ctx: TInterpreterContext,\n    jobId: string | null,\n    store: TStore,\n): void => {\n    runInAction(() => {\n        if (jobId === null) {\n            store.steps.ingestion.postIntrospection.state = 'done';\n            store.steps.ingestion.postIntrospection.reused = true;\n        } else {\n            store.steps.ingestion.postIntrospection.jobId = jobId;\n            if (store.steps.ingestion.postIntrospection.state === 'idle') {\n                store.steps.ingestion.postIntrospection.state = 'queued';\n            }\n        }\n    });\n    if (jobId === null || ctx.authed === null) {\n        ctx.postIntrospectionPoll = Promise.resolve();\n        return;\n    }\n    ctx.postIntrospectionPoll = streamPostIntrospection(\n        ctx.authed,\n        jobId,\n        store,\n    ).then(\n        () => {},\n        () => {},\n    );\n};\n\nexport const cleanup = (ctx: TInterpreterContext): void => {\n    if (ctx.db !== null) {\n        ctx.db.cleanup();\n        ctx.db = null;\n    }\n    if (ctx.cleanupSSH !== null) {\n        ctx.cleanupSSH();\n        ctx.cleanupSSH = null;\n    }\n};\n"]}