@sqlanvil/cli 1.21.0 → 1.23.0

package/bundle.js

@@ -50606,7 +50606,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.21.0";
+const version = "1.23.0";
 const dataformVersion = "3.0.61";
 
 async function build(compiledGraph, runConfig, dbadapter) {
@@ -51016,7 +51016,8 @@ function mysqlCredentialsTemplate() {
     };
     return `${JSON.stringify(template, null, 2)}\n`;
 }
-async function init(projectDir, projectConfig) {
+async function init(projectDir, projectConfig, options = {}) {
+    var _a;
     const workflowSettingsYamlPath = path__namespace.join(projectDir, "workflow_settings.yaml");
     const packageJsonPath = path__namespace.join(projectDir, "package.json");
     const gitignorePath = path__namespace.join(projectDir, ".gitignore");
@@ -51064,7 +51065,11 @@ async function init(projectDir, projectConfig) {
     if (projectConfig.builtinAssertionNamePrefix) {
         workflowSettings.builtinAssertionNamePrefix = projectConfig.builtinAssertionNamePrefix;
     }
-    if (isPostgresLike) {
+    const includeSample = options.includeSample !== false;
+    const withBigQuerySource = includeSample &&
+        warehouse !== "mysql" &&
+        (!isPostgresLike || options.includeBigQuerySource !== false);
+    if (isPostgresLike && withBigQuerySource) {
         workflowSettings.connections = {
             bigquery_public: sqlanvil.ConnectionConfig.create({
                 platform: "bigquery",
@@ -51080,7 +51085,7 @@ async function init(projectDir, projectConfig) {
     fs__namespace$1.writeFileSync(gitignorePath, gitIgnoreContents);
     filesWritten.push(gitignorePath);
     if (!isBigQuery) {
-        fs__namespace$1.writeFileSync(path__namespace.join(projectDir, CREDENTIALS_FILENAME), warehouse === "mysql" ? mysqlCredentialsTemplate() : postgresCredentialsTemplate(warehouse));
+        fs__namespace$1.writeFileSync(path__namespace.join(projectDir, CREDENTIALS_FILENAME), (_a = options.credentialsJson) !== null && _a !== void 0 ? _a : (warehouse === "mysql" ? mysqlCredentialsTemplate() : postgresCredentialsTemplate(warehouse)));
         filesWritten.push(path__namespace.join(projectDir, CREDENTIALS_FILENAME));
     }
     const mkdir = (...segments) => {
@@ -51101,7 +51106,10 @@ async function init(projectDir, projectConfig) {
     const reportingDir = mkdir("definitions", "outputs", "reporting");
     const testDir = mkdir("definitions", "test");
     keep(mkdir("includes"));
-    const withBigQuerySource = warehouse !== "mysql";
+    if (!includeSample) {
+        [sourcesDir, intermediateDir, salesDir, reportingDir, testDir].forEach(keep);
+        return { filesWritten, dirsCreated };
+    }
     write(path__namespace.join(sourcesDir, "app_orders.sqlx"), `-- A declaration: a table that already exists in your warehouse (created by your
 -- application, an import, or another pipeline). Point name/dataset at a real table —
 -- downstream models read it with \${ref("app_orders")}.
@@ -53541,7 +53549,7 @@ class Runner {
         return actionResult;
     }
     async executeTask(client, task, parentAction, options, action) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         const timer = Timer.start();
         const taskResult = {
             status: sqlanvil.TaskResult.ExecutionStatus.RUNNING,
@@ -53613,7 +53621,14 @@ class Runner {
         }
         else if (task.type === "extract") {
             try {
-                const extractor = ((_d = action === null || action === void 0 ? void 0 : action.extract) === null || _d === void 0 ? void 0 : _d.platform) === "mysql"
+                if (Object.keys((_e = (_d = action === null || action === void 0 ? void 0 : action.extract) === null || _d === void 0 ? void 0 : _d.columnTypes) !== null && _e !== void 0 ? _e : {}).length === 0) {
+                    const ds = ((_f = action === null || action === void 0 ? void 0 : action.extract) === null || _f === void 0 ? void 0 : _f.platform) === "mysql"
+                        ? (_g = action === null || action === void 0 ? void 0 : action.extract) === null || _g === void 0 ? void 0 : _g.database : (_h = action === null || action === void 0 ? void 0 : action.extract) === null || _h === void 0 ? void 0 : _h.dataset;
+                    throw new Error(`declaration "${(_j = action === null || action === void 0 ? void 0 : action.target) === null || _j === void 0 ? void 0 : _j.name}" has no columnTypes — scaffold them with: ` +
+                        `sqlanvil introspect ${(_k = action === null || action === void 0 ? void 0 : action.extract) === null || _k === void 0 ? void 0 : _k.connectionName} ${ds}.${(_l = action === null || action === void 0 ? void 0 : action.extract) === null || _l === void 0 ? void 0 : _l.sourceName} ` +
+                        `--output <its .sqlx file>`);
+                }
+                const extractor = ((_m = action === null || action === void 0 ? void 0 : action.extract) === null || _m === void 0 ? void 0 : _m.platform) === "mysql"
                     ? this.executionOptions.mysqlExtract || runMysqlExtract
                     : this.executionOptions.bigQueryExtract || runBigQueryExtract;
                 await extractor({
@@ -53643,7 +53658,7 @@ class Runner {
                 }), task.type === "operation" ? 1 : options.bigquery.actionRetryLimit + 1 || 1);
                 taskResult.metadata = metadata;
                 if (task.type === "assertion") {
-                    const rowCount = (_e = rows[0]) === null || _e === void 0 ? void 0 : _e[Object.keys(rows[0])[0]];
+                    const rowCount = (_o = rows[0]) === null || _o === void 0 ? void 0 : _o[Object.keys(rows[0])[0]];
                     if (rowCount > 0) {
                         throw new Error(`Assertion failed: query returned ${rowCount} row(s).`);
                     }
@@ -53655,7 +53670,7 @@ class Runner {
                     ? sqlanvil.TaskResult.ExecutionStatus.CANCELLED
                     : sqlanvil.TaskResult.ExecutionStatus.FAILED;
                 taskResult.errorMessage = `${this.graph.projectConfig.warehouse} error: ${e.message}`;
-                if ((_g = (_f = e.metadata) === null || _f === void 0 ? void 0 : _f.bigquery) === null || _g === void 0 ? void 0 : _g.jobId) {
+                if ((_q = (_p = e.metadata) === null || _p === void 0 ? void 0 : _p.bigquery) === null || _q === void 0 ? void 0 : _q.jobId) {
                     taskResult.metadata = {
                         bigquery: {
                             jobId: e.metadata.bigquery.jobId
@@ -54175,443 +54190,594 @@ ${columnRows || '<tr><td colspan="3" class="meta">No documented columns.</td></t
 `;
 }
 
-const CHECKER_SOURCE = `
-import json, os, sys
-
-script_path, requirements_path, version_spec = sys.argv[1], sys.argv[2], sys.argv[3]
-errors = []
-
-import platform
-py_version = platform.python_version()
-
-def load_packaging():
-    try:
-        from packaging.specifiers import SpecifierSet
-        from packaging.requirements import Requirement
-        return SpecifierSet, Requirement
-    except ImportError:
-        pass
-    try:
-        from pip._vendor.packaging.specifiers import SpecifierSet
-        from pip._vendor.packaging.requirements import Requirement
-        return SpecifierSet, Requirement
-    except ImportError:
-        return None, None
-
-SpecifierSet, Requirement = load_packaging()
-
-def mini_parse(v):
-    import re
-    return [int(x) for x in re.findall(r"[0-9]+", v.split("+")[0])][:4]
-
-def mini_check(version, spec):
-    import re
-    ok = True
-    for clause in spec.split(","):
-        clause = clause.strip()
-        m = re.match(r"(===|==|!=|<=|>=|~=|<|>)\\s*(.+)", clause)
-        if not m:
-            return None
-        op, want = m.group(1), m.group(2).strip()
-        if want.endswith(".*"):
-            prefix = mini_parse(want[:-2])
-            have = mini_parse(version)[:len(prefix)]
-            eq = have == prefix
-            if (op in ("==", "===") and not eq) or (op == "!=" and eq):
-                ok = False
-            continue
-        a, b = mini_parse(version), mini_parse(want)
-        n = max(len(a), len(b))
-        a = a + [0] * (n - len(a))
-        b = b + [0] * (n - len(b))
-        if op in ("==", "==="):
-            res = a == b
-        elif op == "!=":
-            res = a != b
-        elif op == "<=":
-            res = a <= b
-        elif op == ">=":
-            res = a >= b
-        elif op == "<":
-            res = a < b
-        elif op == ">":
-            res = a > b
-        else:  # ~= : at least b, within b's series
-            wb = mini_parse(want)
-            res = a >= b and a[:max(len(wb) - 1, 1)] == b[:max(len(wb) - 1, 1)]
-        if not res:
-            ok = False
-    return ok
-
-def check_version(version, spec, what):
-    if SpecifierSet is not None:
-        try:
-            if version not in SpecifierSet(spec, prereleases=True):
-                errors.append('%s: installed %s does not satisfy "%s"' % (what, version, spec))
-            return
-        except Exception as e:
-            errors.append('%s: could not evaluate specifier "%s": %s' % (what, spec, e))
-            return
-    if mini_check(version, spec) is False:
-        errors.append('%s: installed %s does not satisfy "%s"' % (what, version, spec))
-
-if version_spec:
-    check_version(py_version, version_spec, "python interpreter")
-
-if requirements_path:
-    from importlib import metadata
-    try:
-        lines = open(requirements_path).read().splitlines()
-    except OSError as e:
-        errors.append("requirements: cannot read %s: %s" % (requirements_path, e))
-        lines = []
-    for raw in lines:
-        line = raw.split("#")[0].strip()
-        if not line or line.startswith("-"):
-            continue
-        if Requirement is not None:
-            try:
-                req = Requirement(line)
-            except Exception:
-                errors.append('requirements: cannot parse "%s"' % line)
-                continue
-            if req.marker is not None and not req.marker.evaluate():
-                continue
-            name, spec = req.name, str(req.specifier)
-        else:
-            import re
-            if ";" in line:
-                line = line.split(";")[0].strip()
-            m = re.match(r"^([A-Za-z0-9][A-Za-z0-9._-]*)\\s*(\\[[^\\]]*\\])?\\s*(.*)$", line)
-            if not m:
-                errors.append('requirements: cannot parse "%s"' % line)
-                continue
-            name, spec = m.group(1), (m.group(3) or "").strip()
-        try:
-            installed = metadata.version(name)
-        except metadata.PackageNotFoundError:
-            errors.append(
-                "requirements: %s is not installed%s" % (name, " (need %s)" % spec if spec else "")
-            )
-            continue
-        if spec:
-            check_version(installed, spec, "requirements: %s" % name)
-
-try:
-    with open(script_path, "rb") as f:
-        compile(f.read(), script_path, "exec")
-except SyntaxError as e:
-    errors.append("syntax: %s (line %s)" % (e.msg, e.lineno))
-except (OSError, ValueError) as e:
-    errors.append("syntax: cannot compile %s: %s" % (script_path, e))
-
-print(json.dumps({"interpreter_version": py_version, "errors": errors}))
-`;
-const defaultCheckerExec = (interpreter, args, cwd) => new Promise((resolve, reject) => {
-    childProcess.execFile(interpreter, args, { cwd, timeout: 60000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-        if (err) {
-            reject(new Error(`checker failed under ${interpreter}: ${err.message}\n${stderr}`.trim()));
-        }
-        else {
-            resolve(stdout);
-        }
-    });
-});
-const failure = (message) => ({
-    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
-    error: { message }
-});
-async function checkScriptAction(script, projectDir, checkerExec = defaultCheckerExec) {
-    if (script.language !== "python") {
-        return [failure(`no validator for script language "${script.language}"`)];
-    }
-    let interpreter;
-    try {
-        interpreter = resolveInterpreter({ language: script.language, envRoot: script.envRoot }, projectDir);
-    }
-    catch (e) {
-        return [failure(e.message)];
-    }
-    let stdout;
-    try {
-        stdout = await checkerExec(interpreter, ["-c", CHECKER_SOURCE, script.scriptFilename, script.depsFile || "", script.runtimeVersion || ""], projectDir);
-    }
-    catch (e) {
-        return [failure(e.message)];
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(stdout);
-    }
-    catch (e) {
-        return [failure(`checker returned unparseable output: ${stdout.slice(0, 500)}`)];
+function containsPath(parent, child) {
+    const rel = path__namespace.relative(parent, child);
+    return rel === "" || (!rel.startsWith("..") && !path__namespace.isAbsolute(rel));
+}
+class OutWriter {
+    constructor(outDir) {
+        this.outDir = outDir;
     }
-    if (parsed.errors && parsed.errors.length > 0) {
-        return parsed.errors.map(failure);
+    write(relPath, contents) {
+        const full = path__namespace.resolve(this.outDir, relPath);
+        if (!containsPath(path__namespace.resolve(this.outDir), full)) {
+            throw new Error(`Refusing to write outside the output directory: ${relPath}`);
+        }
+        fs__namespace$1.mkdirSync(path__namespace.dirname(full), { recursive: true });
+        fs__namespace$1.writeFileSync(full, contents);
     }
-    return [{ status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS }];
 }
-
-function targetKey(target) {
-    return [target.database, target.schema, target.name].filter(Boolean).join(".");
+const SAFETY_SKIP = [
+    /^\.git(\/|$)/,
+    /(^|\/)node_modules(\/|$)/,
+    /(^|\/)\.df-credentials[^/]*\.json$/,
+    /service_account[^/]*\.json$/i,
+    /(^|\/)\.env([^/]*)$/,
+    /\.pem$/,
+    /(^|\/)compile_output\.json$/,
+    /(^|\/)\.DS_Store$/,
+    /(^|\/)target(\/|$)/,
+];
+function walkFiles(root) {
+    const out = [];
+    const walk = (rel) => {
+        for (const entry of fs__namespace$1.readdirSync(path__namespace.join(root, rel), { withFileTypes: true })) {
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (SAFETY_SKIP.some(re => re.test(relPath) || re.test(relPath + "/"))) {
+                skippedForSafety.add(relPath);
+                continue;
+            }
+            if (entry.isDirectory()) {
+                walk(relPath);
+            }
+            else if (entry.isFile()) {
+                out.push(relPath);
+            }
+        }
+    };
+    walk("");
+    return out;
 }
-function topoOrder(nodes) {
-    const byKey = new Map(nodes.map(n => [n.key, n]));
-    const indegree = new Map();
-    const dependents = new Map();
-    for (const n of nodes) {
-        const inGraphDeps = Array.from(new Set(n.dependencyKeys.filter(d => byKey.has(d) && d !== n.key)));
-        indegree.set(n.key, inGraphDeps.length);
-        for (const dep of inGraphDeps) {
-            dependents.set(dep, (dependents.get(dep) || []).concat(n.key));
+let skippedForSafety;
+function findConfigBlock(source) {
+    const m = /(^|\n)\s*config\s*\{/.exec(source);
+    if (!m)
+        return null;
+    const open = source.indexOf("{", m.index + m[0].indexOf("config"));
+    let depth = 0;
+    let inString = null;
+    for (let i = open; i < source.length; i++) {
+        const ch = source[i];
+        const prev = source[i - 1];
+        if (inString) {
+            if (ch === inString && prev !== "\\")
+                inString = null;
+            continue;
         }
-    }
-    const ready = nodes
-        .filter(n => (indegree.get(n.key) || 0) === 0)
-        .map(n => n.key)
-        .sort();
-    const ordered = [];
-    const emitted = new Set();
-    while (ready.length) {
-        const key = ready.shift();
-        if (emitted.has(key)) {
+        if (ch === '"' || ch === "'" || ch === "`") {
+            inString = ch;
             continue;
         }
-        emitted.add(key);
-        ordered.push(byKey.get(key));
-        for (const dep of (dependents.get(key) || []).slice().sort()) {
-            indegree.set(dep, (indegree.get(dep) || 0) - 1);
-            if ((indegree.get(dep) || 0) <= 0 && !emitted.has(dep)) {
-                ready.push(dep);
-                ready.sort();
+        if (ch === "{")
+            depth++;
+        if (ch === "}") {
+            depth--;
+            if (depth === 0) {
+                return {
+                    start: m.index + (m[1] ? m[1].length : 0),
+                    open,
+                    end: i + 1,
+                    body: source.slice(open + 1, i),
+                };
             }
         }
     }
-    if (ordered.length < nodes.length) {
-        for (const n of nodes.slice().sort((a, b) => a.key.localeCompare(b.key))) {
-            if (!emitted.has(n.key)) {
-                emitted.add(n.key);
-                ordered.push(n);
+    return null;
+}
+function jsBlockLines(source) {
+    const lines = new Set();
+    const re = /(^|\n)\s*js\s*\{/g;
+    let m;
+    while ((m = re.exec(source))) {
+        const open = source.indexOf("{", m.index + m[0].length - 1);
+        let depth = 0;
+        let end = -1;
+        for (let i = open; i < source.length; i++) {
+            if (source[i] === "{")
+                depth++;
+            if (source[i] === "}") {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
             }
         }
+        if (end < 0)
+            end = source.length - 1;
+        const startLine = source.slice(0, m.index + (m[1] ? m[1].length : 0)).split("\n").length - 1;
+        const endLine = source.slice(0, end).split("\n").length - 1;
+        for (let l = startLine; l <= endLine; l++)
+            lines.add(l);
     }
-    return ordered;
-}
-function dependencyBlocked(dependencyKeys, statusByKey) {
-    return dependencyKeys.some(dep => {
-        const status = statusByKey.get(dep);
-        return status !== undefined && status !== "PASS";
-    });
+    return lines;
 }
-const VALIDATE_SHADOW_PREFIX = "sqlanvil_validate_";
-function validateShadowSuffix(nowMs) {
-    return `${VALIDATE_SHADOW_PREFIX}${nowMs}`;
+const str = (field, body) => {
+    const re = new RegExp(`${field}\\s*:\\s*["'\`]([^"'\`]+)["'\`]`);
+    const m = re.exec(body);
+    return m ? m[1] : null;
+};
+function parseSqlxConfig(body) {
+    let database = str("database", body);
+    if (!database && /database\s*:\s*(dataform|sqlanvil)\.projectConfig\.defaultDatabase/.test(body)) {
+        database = "<defaultDatabase>";
+    }
+    return {
+        type: str("type", body),
+        schema: str("schema", body),
+        database,
+        name: str("name", body),
+        description: str("description", body),
+    };
 }
-function parseShadowTimestamp(schemaName) {
-    const match = schemaName.match(/sqlanvil_validate_(\d+)/);
-    return match ? Number(match[1]) : null;
+const GLOBAL_RULES = [
+    {
+        pattern: /\bdataform\.projectConfig\b/g,
+        replacement: "sqlanvil.projectConfig",
+        kind: "rewrite",
+        note: "dataform.projectConfig → sqlanvil.projectConfig (compile global renamed)",
+    },
+];
+const SQL_RULES = [
+    {
+        pattern: /\bSAFE_CAST\s*\(/g,
+        replacement: "CAST(",
+        kind: "rewrite",
+        note: "SAFE_CAST → CAST — Postgres CAST raises on bad input; verify the data or guard it",
+    },
+    {
+        pattern: /\bCURRENT_DATE\s*\(\s*\)/g,
+        replacement: "CURRENT_DATE",
+        kind: "rewrite",
+        note: "CURRENT_DATE() → CURRENT_DATE",
+    },
+    {
+        pattern: /\bCURRENT_DATE\s*\(\s*['"]/g,
+        kind: "flag",
+        note: "CURRENT_DATE('<tz>') — Postgres: (CURRENT_TIMESTAMP AT TIME ZONE '<tz>')::date",
+    },
+    {
+        pattern: /\bSAFE_DIVIDE\s*\(/g,
+        kind: "flag",
+        note: "SAFE_DIVIDE(a, b) — Postgres: a / NULLIF(b, 0)",
+    },
+    {
+        pattern: /\bSAFE_OFFSET\s*\(/g,
+        kind: "flag",
+        note: "array[SAFE_OFFSET(n)] — Postgres arrays are 1-based; use (split_part / arr[n+1])",
+    },
+    { pattern: /\bQUALIFY\b/gi, kind: "flag", note: "QUALIFY — rewrite as a subquery/CTE filter on the window function" },
+    { pattern: /\bUNNEST\s*\(/g, kind: "flag", note: "UNNEST — Postgres unnest() works on arrays only (no STRUCT arrays); verify semantics" },
+    { pattern: /\bSTRUCT\s*[(<]/g, kind: "flag", note: "STRUCT — no Postgres equivalent; consider jsonb or a composite type" },
+    { pattern: /\bARRAY\s*</g, kind: "flag", note: "ARRAY<T> type syntax — Postgres uses T[]" },
+    { pattern: /\bFORMAT_DATE\s*\(/g, kind: "flag", note: "FORMAT_DATE → TO_CHAR (different format tokens)" },
+    { pattern: /\bPARSE_DATE\s*\(/g, kind: "flag", note: "PARSE_DATE → TO_DATE (different format tokens)" },
+    { pattern: /\bFORMAT_TIMESTAMP\s*\(/g, kind: "flag", note: "FORMAT_TIMESTAMP → TO_CHAR (different format tokens)" },
+    {
+        pattern: /\b(DATE_ADD|DATE_SUB|TIMESTAMP_ADD|TIMESTAMP_SUB|DATETIME_ADD|DATETIME_SUB)\s*\(/g,
+        kind: "flag",
+        note: "BigQuery date arithmetic — Postgres uses interval arithmetic (x + INTERVAL '1 day')",
+    },
+    { pattern: /\bDATE_DIFF\s*\(/g, kind: "flag", note: "DATE_DIFF — Postgres: subtraction / EXTRACT(EPOCH FROM ...) depending on the part" },
+    { pattern: /_PARTITIONTIME|_PARTITIONDATE|_TABLE_SUFFIX/g, kind: "flag", note: "BigQuery pseudo-column has no Postgres equivalent" },
+    { pattern: /\bEXPORT\s+DATA\b/gi, kind: "flag", note: "EXPORT DATA — use a sqlanvil `type: \"export\"` action instead" },
+    { pattern: /\bEXECUTE\s+IMMEDIATE\b/gi, kind: "flag", note: "BigQuery scripting (EXECUTE IMMEDIATE) — rewrite as a PL/pgSQL DO block or operations" },
+    { pattern: /\bGENERATE_UUID\s*\(\s*\)/g, kind: "flag", note: "GENERATE_UUID() → gen_random_uuid()" },
+    {
+        pattern: /`[A-Za-z0-9_-]+\.[A-Za-z0-9_$]+\.[A-Za-z0-9_$]+`/g,
+        kind: "flag",
+        note: "backticked BigQuery FQN — use ${ref(...)} (declare it as a source) or a quoted Postgres name",
+    },
+];
+const CONFIG_BQ_KEYS = /^(\s*)(bigquery\s*:|partitionBy\s*:|clusterBy\s*:|requirePartitionFilter\s*:|partitionExpirationDays\s*:|database\s*:)/;
+const sanitize = (s) => s.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+const connectionNameFor = (project) => `bq_${sanitize(project)}`;
+function convertDeclaration(source, parsed, connection, sourceDataset, filePath) {
+    const span = findConfigBlock(source);
+    const description = parsed.description
+        ? `    description: ${JSON.stringify(parsed.description)},\n`
+        : "";
+    const newConfig = `config {
+    type: "declaration",
+    connection: ${JSON.stringify(connection)},
+    schema: ${JSON.stringify(sourceDataset)},
+    name: ${JSON.stringify(parsed.name)},
+${description}    columnTypes: {
+        // SQLANVIL-MIGRATE(TODO): scaffold the columns from the live source:
+        //   sqlanvil introspect ${connection} ${sourceDataset}.${parsed.name} --output ${filePath}
+    },
+}`;
+    const content = source.slice(0, span.start) + newConfig + source.slice(span.end);
+    return {
+        content,
+        findings: [
+            {
+                line: 1,
+                kind: "rewrite",
+                note: `declaration now reads BigQuery through connection "${connection}" (runner-extract); columnTypes need introspect`,
+            },
+        ],
+    };
 }
-function shadowSchemasToSweep(schemaNames, nowMs, maxAgeMs) {
-    return schemaNames.filter(name => {
-        const ts = parseShadowTimestamp(name);
-        return ts !== null && nowMs - ts > maxAgeMs;
-    });
-}
-
-const SHADOW_MAX_AGE_MS = 60 * 60 * 1000;
-async function sweepOrphanShadows(deps, nowMs, maxAgeMs = SHADOW_MAX_AGE_MS) {
-    try {
-        const schemas = await deps.listSchemas();
-        for (const schema of shadowSchemasToSweep(schemas, nowMs, maxAgeMs)) {
-            try {
-                await deps.execute(deps.dropSchemaCascadeSql(schema));
+function convertTarget(source, jsMode) {
+    const span = jsMode ? null : findConfigBlock(source);
+    const findings = [];
+    const lines = source.split("\n");
+    const jsLines = jsMode ? new Set() : jsBlockLines(source);
+    let configStartLine = -1;
+    let configEndLine = -1;
+    if (span) {
+        configStartLine = source.slice(0, span.start).split("\n").length - 1;
+        configEndLine = source.slice(0, span.end).split("\n").length - 1;
+    }
+    const out = [];
+    let commentingConfigBlockDepth = 0;
+    let swallowLeadingComma = false;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        const inConfig = i >= configStartLine && i <= configEndLine && configStartLine >= 0;
+        const markersSafe = !jsMode && !jsLines.has(i);
+        const marker = (note) => inConfig ? `// SQLANVIL-MIGRATE: ${note}` : `-- SQLANVIL-MIGRATE: ${note}`;
+        const lineNo = i + 1;
+        const notesForLine = [];
+        for (const rule of GLOBAL_RULES) {
+            rule.pattern.lastIndex = 0;
+            if (rule.pattern.test(line)) {
+                line = line.replace(rule.pattern, rule.replacement);
+                findings.push({ line: lineNo, kind: "rewrite", note: rule.note });
+            }
+        }
+        if (swallowLeadingComma) {
+            swallowLeadingComma = false;
+            if (/^\s*,\s*$/.test(line)) {
+                out.push(`// ${line}`);
+                continue;
             }
-            catch (e) {
+            if (/^\s*,/.test(line)) {
+                line = line.replace(/,/, " ");
+            }
+        }
+        if (inConfig && commentingConfigBlockDepth === 0) {
+            const m = CONFIG_BQ_KEYS.exec(line);
+            if (m) {
+                const note = `BigQuery-only setting — not applicable on Postgres (partitioning/clustering → postgres: {}; project qualifiers drop)`;
+                findings.push({ line: lineNo, kind: "flag", note });
+                out.push(marker(note));
+                const opens = (line.match(/\{/g) || []).length;
+                const closes = (line.match(/\}/g) || []).length;
+                commentingConfigBlockDepth = Math.max(0, opens - closes);
+                if (commentingConfigBlockDepth === 0)
+                    swallowLeadingComma = !/,\s*$/.test(line) ? true : false;
+                out.push(`// ${line}`);
+                continue;
+            }
+        }
+        else if (commentingConfigBlockDepth > 0) {
+            const opens = (line.match(/\{/g) || []).length;
+            const closes = (line.match(/\}/g) || []).length;
+            commentingConfigBlockDepth = Math.max(0, commentingConfigBlockDepth + opens - closes);
+            if (commentingConfigBlockDepth === 0 && !/,\s*$/.test(line))
+                swallowLeadingComma = true;
+            out.push(`// ${line}`);
+            continue;
+        }
+        if (!inConfig || jsMode) {
+            for (const rule of SQL_RULES) {
+                rule.pattern.lastIndex = 0;
+                if (!rule.pattern.test(line))
+                    continue;
+                if (rule.replacement !== undefined) {
+                    rule.pattern.lastIndex = 0;
+                    line = line.replace(rule.pattern, rule.replacement);
+                    findings.push({ line: lineNo, kind: "rewrite", note: rule.note });
+                    if (markersSafe)
+                        notesForLine.push(rule.note);
+                }
+                else {
+                    findings.push({ line: lineNo, kind: "flag", note: rule.note });
+                    if (markersSafe)
+                        notesForLine.push(rule.note);
+                }
             }
         }
+        for (const note of notesForLine) {
+            out.push(marker(note));
+        }
+        out.push(line);
     }
-    catch (e) {
+    let content = out.join("\n");
+    if (jsMode && findings.length > 0) {
+        const noted = findings.slice(0, 12).map(f => ` *   L${f.line}: ${f.note}`);
+        const more = findings.length > 12 ? [` *   …and ${findings.length - 12} more (see migration-report.json)`] : [];
+        content =
+            ["/* SQLANVIL-MIGRATE — findings in this file (inline markers are unsafe in JS templates):", ...noted, ...more, " */"].join("\n") +
+                "\n" +
+                content;
     }
+    return { content, findings };
 }
-function tableType(enumType) {
-    switch (enumType) {
-        case sqlanvil.TableType.VIEW:
-            return "view";
-        case sqlanvil.TableType.INCREMENTAL:
-            return "incremental";
-        default:
-            return "table";
+function readSourceConfig(srcDir) {
+    var _a, _b, _c, _d, _e;
+    const wsPath = path__namespace.join(srcDir, "workflow_settings.yaml");
+    const djPath = path__namespace.join(srcDir, "dataform.json");
+    let raw;
+    if (fs__namespace$1.existsSync(wsPath)) {
+        raw = jsYaml.load(fs__namespace$1.readFileSync(wsPath, "utf8")) || {};
     }
-}
-function depKeys(deps) {
-    return (deps || []).map(targetKey);
-}
-async function validate(compiledGraph, deps, options = {}) {
-    const nodes = [];
-    for (const table of compiledGraph.tables || []) {
-        nodes.push({
-            key: targetKey(table.target),
-            dependencyKeys: depKeys(table.dependencyTargets),
-            kind: "table",
-            type: tableType(table.enumType),
-            target: table.target,
-            table,
-            action: table
-        });
+    else if (fs__namespace$1.existsSync(djPath)) {
+        raw = JSON.parse(fs__namespace$1.readFileSync(djPath, "utf8"));
     }
-    for (const assertion of compiledGraph.assertions || []) {
-        nodes.push({
-            key: targetKey(assertion.target),
-            dependencyKeys: depKeys(assertion.dependencyTargets),
-            kind: "assertion",
-            type: "assertion",
-            target: assertion.target,
-            action: assertion
-        });
+    else {
+        throw new Error(`${srcDir} does not look like a Dataform project (no workflow_settings.yaml or dataform.json).`);
     }
-    for (const operation of compiledGraph.operations || []) {
-        if (!operation.target) {
+    const s = (k) => (typeof raw[k] === "string" ? raw[k] : null);
+    return {
+        defaultProject: (_a = s("defaultProject")) !== null && _a !== void 0 ? _a : s("defaultDatabase"),
+        defaultDataset: (_c = (_b = s("defaultDataset")) !== null && _b !== void 0 ? _b : s("defaultSchema")) !== null && _c !== void 0 ? _c : "dataform",
+        defaultAssertionDataset: (_d = s("defaultAssertionDataset")) !== null && _d !== void 0 ? _d : s("assertionSchema"),
+        vars: (_e = raw.vars) !== null && _e !== void 0 ? _e : null,
+        raw,
+    };
+}
+async function migrateDataform(opts) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const srcDir = path__namespace.resolve(opts.srcDir);
+    const outDir = path__namespace.resolve(opts.outDir);
+    if (containsPath(srcDir, outDir)) {
+        throw new Error("The output directory must not be inside the source project.");
+    }
+    if (containsPath(outDir, srcDir)) {
+        throw new Error("The source project must not be inside the output directory.");
+    }
+    if (fs__namespace$1.existsSync(outDir) && fs__namespace$1.readdirSync(outDir).length > 0) {
+        throw new Error(`Output directory ${outDir} is not empty.`);
+    }
+    const sourceConfig = readSourceConfig(srcDir);
+    const writer = new OutWriter(outDir);
+    skippedForSafety = new Set();
+    const files = walkFiles(srcDir);
+    const report = {
+        generator: `sqlanvil migrate-dataform ${version}`,
+        sourceDir: srcDir,
+        sourceConfig: sourceConfig.raw,
+        inventory: { sqlxFiles: 0, jsFiles: 0, byType: {} },
+        connections: [],
+        overlappingSchemas: [],
+        files: [],
+        skippedForSafety: [],
+        warnings: [],
+    };
+    const sqlxFiles = [];
+    for (const rel of files) {
+        if (!rel.endsWith(".sqlx"))
             continue;
+        const source = fs__namespace$1.readFileSync(path__namespace.join(srcDir, rel), "utf8");
+        const span = findConfigBlock(source);
+        const parsed = span
+            ? parseSqlxConfig(span.body)
+            : { type: null, schema: null, database: null, name: null, description: null };
+        sqlxFiles.push({ rel, source, parsed });
+        report.inventory.sqlxFiles++;
+        const t = (_a = parsed.type) !== null && _a !== void 0 ? _a : "(none)";
+        report.inventory.byType[t] = ((_b = report.inventory.byType[t]) !== null && _b !== void 0 ? _b : 0) + 1;
+    }
+    const resolveDatabase = (db) => { var _a; return !db || db === "<defaultDatabase>" ? (_a = sourceConfig.defaultProject) !== null && _a !== void 0 ? _a : "UNKNOWN_PROJECT" : db; };
+    const declarationSchemas = new Set();
+    const targetSchemas = new Set();
+    const connectionMap = new Map();
+    for (const f of sqlxFiles) {
+        if (f.parsed.type === "declaration") {
+            const dataset = (_c = f.parsed.schema) !== null && _c !== void 0 ? _c : sourceConfig.defaultDataset;
+            const project = resolveDatabase(f.parsed.database);
+            declarationSchemas.add(dataset);
+            const name = connectionNameFor(project);
+            const existing = connectionMap.get(name);
+            if (existing) {
+                existing.declarationCount++;
+                if (!existing.datasets.includes(dataset))
+                    existing.datasets.push(dataset);
+            }
+            else {
+                connectionMap.set(name, {
+                    name,
+                    project,
+                    datasets: [dataset],
+                    declarationCount: 1,
+                    introspectExample: `sqlanvil introspect ${name} <dataset>.<table> --output <declaration.sqlx>`,
+                });
+            }
         }
-        nodes.push({
-            key: targetKey(operation.target),
-            dependencyKeys: depKeys(operation.dependencyTargets),
-            kind: "operation",
-            type: "operation",
-            target: operation.target,
-            action: undefined
-        });
-    }
-    for (const imp of compiledGraph.imports || []) {
-        if (!imp.target) {
-            continue;
+        else if (f.parsed.type) {
+            targetSchemas.add((_d = f.parsed.schema) !== null && _d !== void 0 ? _d : sourceConfig.defaultDataset);
         }
-        nodes.push({
-            key: targetKey(imp.target),
-            dependencyKeys: depKeys(imp.dependencyTargets),
-            kind: "import",
-            type: "import",
-            target: imp.target,
-            action: undefined
-        });
     }
-    for (const script of compiledGraph.scripts || []) {
-        if (!script.target) {
+    report.connections = [...connectionMap.values()].sort((a, b) => a.name.localeCompare(b.name));
+    report.overlappingSchemas = [...declarationSchemas].filter(s => targetSchemas.has(s)).sort();
+    for (const rel of files) {
+        const abs = path__namespace.join(srcDir, rel);
+        if (rel === "workflow_settings.yaml" || rel === "dataform.json") {
             continue;
         }
-        nodes.push({
-            key: targetKey(script.target),
-            dependencyKeys: depKeys(script.dependencyTargets),
-            kind: "script",
-            type: "script",
-            target: script.target,
-            script,
-            action: undefined
-        });
-    }
-    const ordered = topoOrder(nodes);
-    const shadowSchemas = Array.from(new Set(nodes.filter(n => n.kind === "table").map(n => n.target.schema)));
-    const statusByKey = new Map();
-    const results = [];
-    try {
-        for (const schema of shadowSchemas) {
-            await deps.execute(deps.createSchemaSql(schema));
-        }
-        for (const node of ordered) {
-            if (node.kind === "operation" ||
-                node.kind === "import" ||
-                (node.kind === "script" && !deps.checkScript)) {
-                statusByKey.set(node.key, "SKIPPED");
-                results.push({ target: node.target, type: node.type, status: "SKIPPED", errors: [] });
-                continue;
-            }
-            if (dependencyBlocked(node.dependencyKeys, statusByKey)) {
-                statusByKey.set(node.key, "BLOCKED");
-                results.push({ target: node.target, type: node.type, status: "BLOCKED", errors: [] });
-                continue;
-            }
-            const evaluations = node.kind === "script"
-                ? await deps.checkScript(node.script)
-                : await deps.evaluate(node.action);
-            const failed = evaluations.some(e => e.status === sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE);
-            const status = failed ? "FAILURE" : "PASS";
-            statusByKey.set(node.key, status);
-            results.push({ target: node.target, type: node.type, status, errors: evaluations });
-            if (status === "PASS" && node.kind === "table") {
-                try {
-                    await deps.execute(deps.validationStubSql(node.table));
-                }
-                catch (e) {
-                }
+        if (rel.endsWith(".sqlx")) {
+            const info = sqlxFiles.find(f => f.rel === rel);
+            if (info.parsed.type === "declaration") {
+                const dataset = (_e = info.parsed.schema) !== null && _e !== void 0 ? _e : sourceConfig.defaultDataset;
+                const project = resolveDatabase(info.parsed.database);
+                const connection = connectionNameFor(project);
+                const { content, findings } = convertDeclaration(info.source, info.parsed, connection, dataset, rel);
+                writer.write(rel, content);
+                report.files.push({
+                    file: rel,
+                    action: "declaration",
+                    type: "declaration",
+                    status: "rewritten",
+                    findings,
+                    connection,
+                });
             }
-        }
-    }
-    finally {
-        if (!options.keepShadow) {
-            for (const schema of shadowSchemas.slice().reverse()) {
-                try {
-                    await deps.execute(deps.dropSchemaCascadeSql(schema));
-                }
-                catch (e) {
-                }
+            else {
+                const { content, findings } = convertTarget(info.source, false);
+                writer.write(rel, content);
+                report.files.push({
+                    file: rel,
+                    action: "target",
+                    type: (_f = info.parsed.type) !== null && _f !== void 0 ? _f : "(none)",
+                    status: findings.length === 0
+                        ? "clean"
+                        : findings.some(f => f.kind === "flag")
+                            ? "flagged"
+                            : "rewritten",
+                    findings,
+                });
             }
+            continue;
         }
-    }
-    return results;
-}
-
-class SupabaseDbAdapter extends PostgresDbAdapter {
-    static async create(credentials, options) {
-        const sslMode = (credentials.sslMode || "").toLowerCase();
-        const sslEnabled = !(options === null || options === void 0 ? void 0 : options.disableSslForTestsOnly) && sslMode !== "disable";
-        const clientConfig = {
-            host: credentials.host,
-            port: credentials.port,
-            database: credentials.database,
-            user: credentials.user,
-            password: credentials.password,
-            ssl: sslEnabled
-                ? {
-                    rejectUnauthorized: sslMode === "verify-ca" || sslMode === "verify-full"
-                }
-                : false
-        };
-        const queryExecutor = new PgPoolExecutor(clientConfig, options);
-        try {
-            await queryExecutor.verifyConnection();
-        }
-        catch (e) {
-            await queryExecutor.close().catch(() => undefined);
-            throw new ErrorWithCause(`Could not connect to Supabase Postgres at ${credentials.host}:${credentials.port} ` +
-                `as "${credentials.user}": ${e.message}`, e);
+        if (rel.endsWith(".js") && (rel.startsWith("definitions/") || rel.startsWith("includes/"))) {
+            report.inventory.jsFiles++;
+            const source = fs__namespace$1.readFileSync(abs, "utf8");
+            const { content, findings } = convertTarget(source, true);
+            writer.write(rel, content);
+            const isIncludes = rel.startsWith("includes/");
+            if (isIncludes && findings.length > 0) {
+                report.warnings.push(`includes helper ${rel} emits BigQuery-flavored SQL — review its ${findings.length} finding(s)`);
+            }
+            report.files.push({
+                file: rel,
+                action: isIncludes ? "includes" : "target",
+                type: "js",
+                status: findings.length === 0
+                    ? "clean"
+                    : findings.some(f => f.kind === "flag")
+                        ? "flagged"
+                        : "rewritten",
+                findings,
+            });
+            continue;
         }
-        return new SupabaseDbAdapter(queryExecutor);
+        writer.write(rel, fs__namespace$1.readFileSync(abs));
+        report.files.push({ file: rel, action: "copied", status: "clean", findings: [] });
     }
-    constructor(queryExecutor) {
-        super(queryExecutor);
-    }
-    async verifyServiceRolePermissions() {
-        var _a;
-        try {
-            const result = await this.execute("select current_user");
-            const currentUser = (_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.current_user;
-            return !!currentUser;
-        }
-        catch (_b) {
-            return false;
-        }
+    const settings = {
+        warehouse: "supabase",
+        defaultDataset: sourceConfig.defaultDataset.toLowerCase(),
+        defaultAssertionDataset: ((_g = sourceConfig.defaultAssertionDataset) !== null && _g !== void 0 ? _g : "sqlanvil_assertions").toLowerCase(),
+        sqlanvilCoreVersion: (_h = opts.coreVersion) !== null && _h !== void 0 ? _h : version,
+    };
+    if (sourceConfig.vars)
+        settings.vars = sourceConfig.vars;
+    if (report.connections.length > 0) {
+        settings.connections = Object.fromEntries(report.connections.map(c => {
+            var _a;
+            return [
+                c.name,
+                {
+                    platform: "bigquery",
+                    project: c.project,
+                    billingProject: (_a = sourceConfig.defaultProject) !== null && _a !== void 0 ? _a : "REPLACE_WITH_YOUR_GCP_PROJECT",
+                    mode: "runner-extract",
+                },
+            ];
+        }));
     }
-    async validatePublicationState(pubName = "supabase_realtime") {
-        try {
-            const result = await this.execute(`select 1 from pg_publication where pubname = $1`, {
-                params: [pubName]
-            });
-            return result.rows.length > 0;
-        }
-        catch (_a) {
-            return false;
-        }
+    writer.write("workflow_settings.yaml", jsYaml.dump(settings));
+    report.skippedForSafety = [...skippedForSafety].sort();
+    if (skippedForSafety.size > 0) {
+        report.warnings.push(`Skipped ${skippedForSafety.size} file(s)/dir(s) for safety (credentials, build artifacts, VCS) — see skippedForSafety`);
     }
+    writer.write("migration-report.json", JSON.stringify(report, null, 2));
+    writer.write("migration-report.md", renderReportMd(report));
+    return report;
+}
+function renderReportMd(r) {
+    const targets = r.files.filter(f => f.action === "target");
+    const flagged = targets.filter(f => f.status === "flagged");
+    const rewritten = targets.filter(f => f.status === "rewritten");
+    const clean = targets.filter(f => f.status === "clean");
+    const declarations = r.files.filter(f => f.action === "declaration");
+    const lines = [];
+    lines.push(`# Dataform → SQLAnvil migration report`);
+    lines.push("");
+    lines.push(`Generated by ${r.generator} from \`${r.sourceDir}\` (source untouched).`);
+    lines.push("");
+    lines.push(`## Inventory`);
+    lines.push("");
+    lines.push(`- ${r.inventory.sqlxFiles} .sqlx, ${r.inventory.jsFiles} .js`);
+    for (const [t, n] of Object.entries(r.inventory.byType).sort((a, b) => b[1] - a[1])) {
+        lines.push(`  - ${t}: ${n}`);
+    }
+    lines.push("");
+    lines.push(`## Source connections (${r.connections.length})`);
+    lines.push("");
+    lines.push(`Declarations keep reading BigQuery through named \`connections:\` in workflow_settings.yaml ` +
+        `(mode: runner-extract — no Vault, no wrappers). Each declaration needs \`columnTypes\` ` +
+        `before it can extract; scaffold them with \`sqlanvil introspect\`:`);
+    lines.push("");
+    for (const c of r.connections) {
+        lines.push(`- **${c.name}** — project \`${c.project}\`, ${c.declarationCount} declaration(s) across ` +
+            `${c.datasets.length} dataset(s): ${c.datasets.slice(0, 8).map(d => `\`${d}\``).join(", ")}` +
+            (c.datasets.length > 8 ? ", …" : ""));
+        lines.push(`  - \`${c.introspectExample}\``);
+    }
+    if (r.overlappingSchemas.length > 0) {
+        lines.push("");
+        lines.push(`## ⚠ Schemas that are BOTH source and target`);
+        lines.push("");
+        lines.push(`These schemas have declarations AND materializing actions: ${r.overlappingSchemas
+            .map(s => `\`${s}\``)
+            .join(", ")}. ` +
+            `Their declared tables are probably produced by this pipeline (or a sibling) — once those ` +
+            `producers move to Postgres, convert the declarations to plain local declarations instead ` +
+            `of BigQuery connections.`);
+    }
+    lines.push("");
+    lines.push(`## Target files (${targets.length})`);
+    lines.push("");
+    lines.push(`- clean: ${clean.length}`);
+    lines.push(`- rewritten (safe lexical changes only): ${rewritten.length}`);
+    lines.push(`- **flagged (need dialect review): ${flagged.length}** — every location is marked ` +
+        `inline with \`SQLANVIL-MIGRATE:\``);
+    lines.push("");
+    for (const f of flagged) {
+        lines.push(`- \`${f.file}\` (${f.type})`);
+        for (const finding of f.findings.filter(x => x.kind === "flag").slice(0, 6)) {
+            lines.push(`  - L${finding.line}: ${finding.note}`);
+        }
+        const more = f.findings.filter(x => x.kind === "flag").length - 6;
+        if (more > 0)
+            lines.push(`  - …and ${more} more (see migration-report.json)`);
+    }
+    lines.push("");
+    lines.push(`## Declarations (${declarations.length})`);
+    lines.push("");
+    lines.push(`Every declaration was rewritten to ride its connection. The BigQuery data does not move.`);
+    if (r.warnings.length > 0) {
+        lines.push("");
+        lines.push(`## Warnings`);
+        lines.push("");
+        for (const w of r.warnings)
+            lines.push(`- ${w}`);
+    }
+    lines.push("");
+    lines.push(`## Finish the migration`);
+    lines.push("");
+    lines.push(`1. \`sqlanvil compile\` — should already succeed.`);
+    lines.push(`2. Scaffold \`columnTypes\` for the declarations you actually read (see connections above).`);
+    lines.push(`3. \`sqlanvil validate\` against your Postgres/Supabase warehouse — PASS/FAILURE/BLOCKED per ` +
+        `model is the migration to-do list. Work the flagged files until validate is green.`);
+    lines.push(`4. This report is machine-readable (migration-report.json) — pointing an AI agent at it plus ` +
+        `the \`SQLANVIL-MIGRATE:\` markers is the fastest path through the dialect work.`);
+    lines.push("");
+    return lines.join("\n");
 }
 
 function actuallyResolve(...filePaths) {
@@ -54819,6 +54985,20 @@ function getTestInput(questionText) {
         throw new Error(`Failed to parse DATAFORM_CLI_TEST_INPUTS: ${e.message || e}`);
     }
 }
+function passwordQuestion(questionText) {
+    return prompt(questionText, {
+        hideEchoBack: true,
+        mask: ""
+    });
+}
+function interactivePasswordQuestion(questionText) {
+    if (!process.stdin.isTTY && process.env.DATAFORM_CLI_TEST_INPUTS !== undefined) {
+        const testInput = getTestInput(questionText);
+        print(`${questionText} ********\n`);
+        return testInput;
+    }
+    return passwordQuestion(questionText);
+}
 function selectionQuestion(questionText, options) {
     return readlineSync__namespace.keyInSelect(options, `${questionText}\n`, {
         cancel: false
@@ -54961,162 +55141,809 @@ function printExecutionGraph(executionGraph, asJson) {
             operationActions.forEach(operationAction => writeStdOut(operationString(operationAction.target, operationAction.tasks.length === 0), 1));
         }
     }
-}
-function printExecutedAction(executedAction, executionAction, dryRun) {
-    const jobIds = executedAction.tasks
-        .filter(task => { var _a, _b; return (_b = (_a = task.metadata) === null || _a === void 0 ? void 0 : _a.bigquery) === null || _b === void 0 ? void 0 : _b.jobId; })
-        .map(task => task.metadata.bigquery.jobId);
-    const bytesBilled = executedAction.tasks
-        .filter(task => { var _a, _b; return (_b = (_a = task.metadata) === null || _a === void 0 ? void 0 : _a.bigquery) === null || _b === void 0 ? void 0 : _b.jobId; })
-        .map(task => {
-        var _a, _b, _c, _d;
-        const bytes = (_d = (_c = (_b = (_a = task.metadata.bigquery) === null || _a === void 0 ? void 0 : _a.totalBytesBilled) === null || _b === void 0 ? void 0 : _b.toNumber) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : 0;
-        return formatBytesInHumanReadableFormat(bytes);
-    });
-    const executionSuffix = formatExecutionSuffix(jobIds, bytesBilled);
-    switch (executedAction.status) {
-        case sqlanvil.ActionResult.ExecutionStatus.SUCCESSFUL: {
-            switch (executionAction.type) {
-                case "table": {
-                    writeStdOut(`${successOutput(`Table ${dryRun ? "dry run success" : "created"}: `)} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    return;
-                }
-                case "assertion": {
-                    writeStdOut(`${successOutput(`Assertion ${dryRun ? "dry run success" : "passed"}: `)} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    return;
-                }
-                case "operation": {
-                    writeStdOut(`${successOutput(`Operation ${dryRun ? "dry run success" : "completed successfully"}: `)} ${operationString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    return;
-                }
-            }
+}
+function printExecutedAction(executedAction, executionAction, dryRun) {
+    const jobIds = executedAction.tasks
+        .filter(task => { var _a, _b; return (_b = (_a = task.metadata) === null || _a === void 0 ? void 0 : _a.bigquery) === null || _b === void 0 ? void 0 : _b.jobId; })
+        .map(task => task.metadata.bigquery.jobId);
+    const bytesBilled = executedAction.tasks
+        .filter(task => { var _a, _b; return (_b = (_a = task.metadata) === null || _a === void 0 ? void 0 : _a.bigquery) === null || _b === void 0 ? void 0 : _b.jobId; })
+        .map(task => {
+        var _a, _b, _c, _d;
+        const bytes = (_d = (_c = (_b = (_a = task.metadata.bigquery) === null || _a === void 0 ? void 0 : _a.totalBytesBilled) === null || _b === void 0 ? void 0 : _b.toNumber) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : 0;
+        return formatBytesInHumanReadableFormat(bytes);
+    });
+    const executionSuffix = formatExecutionSuffix(jobIds, bytesBilled);
+    switch (executedAction.status) {
+        case sqlanvil.ActionResult.ExecutionStatus.SUCCESSFUL: {
+            switch (executionAction.type) {
+                case "table": {
+                    writeStdOut(`${successOutput(`Table ${dryRun ? "dry run success" : "created"}: `)} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    return;
+                }
+                case "assertion": {
+                    writeStdOut(`${successOutput(`Assertion ${dryRun ? "dry run success" : "passed"}: `)} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    return;
+                }
+                case "operation": {
+                    writeStdOut(`${successOutput(`Operation ${dryRun ? "dry run success" : "completed successfully"}: `)} ${operationString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    return;
+                }
+            }
+        }
+        case sqlanvil.ActionResult.ExecutionStatus.FAILED: {
+            switch (executionAction.type) {
+                case "table": {
+                    writeStdErr(`${errorOutput("Dataset creation failed: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    break;
+                }
+                case "assertion": {
+                    writeStdErr(`${errorOutput("Assertion failed: ")} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    break;
+                }
+                case "operation": {
+                    writeStdErr(`${errorOutput("Operation failed: ")} ${operationString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    break;
+                }
+            }
+            printExecutedActionErrors(executedAction, executionAction);
+            return;
+        }
+        case sqlanvil.ActionResult.ExecutionStatus.SKIPPED: {
+            switch (executionAction.type) {
+                case "table": {
+                    writeStdOut(`${warningOutput("Skipping dataset creation: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+                case "assertion": {
+                    writeStdOut(`${warningOutput("Skipping assertion execution: ")} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+                case "operation": {
+                    writeStdOut(`${warningOutput("Skipping operation execution: ")} ${operationString(executionAction.target, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+            }
+            return;
+        }
+        case sqlanvil.ActionResult.ExecutionStatus.DISABLED: {
+            switch (executionAction.type) {
+                case "table": {
+                    writeStdOut(`${warningOutput("Dataset creation disabled: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+                case "assertion": {
+                    writeStdOut(`${warningOutput(`Assertion execution disabled: `)} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+                case "operation": {
+                    writeStdOut(`${warningOutput(`Operation execution disabled: `)} ${operationString(executionAction.target, executionAction.tasks.length === 0)}`);
+                    return;
+                }
+            }
+            return;
+        }
+    }
+}
+function printFormatFilesResult(formatResults) {
+    const sorted = formatResults.sort((a, b) => a.filename.localeCompare(b.filename));
+    const successfulFormatResults = sorted.filter(result => !result.err && !result.needsFormatting);
+    const needsFormattingResults = sorted.filter(result => !result.err && result.needsFormatting);
+    const failedFormatResults = sorted.filter(result => !!result.err);
+    if (successfulFormatResults.length > 0) {
+        printSuccess("Successfully formatted:");
+        successfulFormatResults.forEach(result => writeStdOut(result.filename, 1));
+    }
+    if (needsFormattingResults.length > 0) {
+        printError("Files that need formatting:");
+        needsFormattingResults.forEach(result => writeStdErr(result.filename, 1));
+    }
+    if (failedFormatResults.length > 0) {
+        printError("Errors encountered during formatting:");
+        failedFormatResults.forEach(result => writeStdOut(`${result.filename}: ${result.err.message}`, 1));
+    }
+}
+function datasetString(target, datasetType, disabled) {
+    return `${targetString(target)} [${datasetType}]${disabled ? " [disabled]" : ""}`;
+}
+function assertionString(target, disabled) {
+    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
+}
+function operationString(target, disabled) {
+    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
+}
+function plainTargetString(target) {
+    return `${target.schema}.${target.name}`;
+}
+function targetString(target) {
+    return calloutOutput(`${target.schema}.${target.name}`);
+}
+function dotRepresentation(graph, interactive) {
+    var _a, _b, _c;
+    const nodes = [];
+    const edges = [];
+    const formatTarget = interactive ? targetString : plainTargetString;
+    (_a = graph.tables) === null || _a === void 0 ? void 0 : _a.forEach(table => {
+        var _a;
+        const nodeName = `${formatTarget(table.target)}`;
+        nodes.push(`"${nodeName}" [label="${formatTarget(table.target)} [${tableTypeEnumToString(table.enumType)}]"]`);
+        (_a = table.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
+            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
+        });
+    });
+    (_b = graph.assertions) === null || _b === void 0 ? void 0 : _b.forEach(assertion => {
+        var _a;
+        const nodeName = `${formatTarget(assertion.target)}`;
+        nodes.push(`"${nodeName}" [label="${formatTarget(assertion.target)}"]`);
+        (_a = assertion.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
+            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
+        });
+    });
+    (_c = graph.operations) === null || _c === void 0 ? void 0 : _c.forEach(operation => {
+        var _a;
+        const nodeName = `${formatTarget(operation.target)}`;
+        nodes.push(`"${nodeName}" [label="${formatTarget(operation.target)}"`);
+        (_a = operation.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
+            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
+        });
+    });
+    return `digraph {\n${nodes.join(";\n")};\n${edges.join(";\n")};\n}`;
+}
+function printExecutedActionErrors(executedAction, executionAction) {
+    const failingTasks = executedAction.tasks.filter(task => task.status === sqlanvil.TaskResult.ExecutionStatus.FAILED);
+    failingTasks.forEach((task, i) => {
+        executionAction.tasks[i].statement.split("\n").forEach(line => {
+            writeStdErr(`${DEFAULT_PROMPT}${line}`, 1);
+        });
+        printError(task.errorMessage, 1);
+    });
+}
+
+const INIT_MODE_QUESTION = "Start a fresh project, or convert an existing Dataform project? (fresh/convert)";
+const INIT_WAREHOUSE_QUESTION = "Which warehouse? (supabase/postgres/bigquery/mysql)";
+const INIT_PROJECT_DIR_QUESTION = "Project directory?";
+const INIT_BQ_PROJECT_QUESTION = "Google Cloud project ID (the default project models build in)?";
+const INIT_BQ_LOCATION_QUESTION = "Default BigQuery location (e.g. US, us-central1)?";
+const INIT_DEFAULT_SCHEMA_QUESTION = "Default schema for models?";
+const INIT_INCLUDE_SAMPLE_QUESTION = "Include the sample project (sources -> staging views -> outputs -> assertion)?";
+const INIT_INCLUDE_BQ_SOURCE_QUESTION = "Include the cross-warehouse BigQuery sample source (Google public ZIP data)?";
+const INIT_CONFIGURE_CREDS_QUESTION = `Configure warehouse credentials now (written to the gitignored ${CREDENTIALS_FILENAME})?`;
+const CREDS_HOST_QUESTION = "Host?";
+const CREDS_PORT_QUESTION = "Port?";
+const CREDS_DATABASE_QUESTION = "Database?";
+const CREDS_USER_QUESTION = "User?";
+const CREDS_PASSWORD_QUESTION = "Password? (leave empty to fill in later)";
+const CREDS_SSLMODE_QUESTION = "SSL mode? (disable/require)";
+const CONVERT_SOURCE_QUESTION = "Path to the Dataform project to convert (read-only, never modified)?";
+const CONVERT_OUT_QUESTION = "Directory for the converted sqlanvil project (created; must be empty)?";
+const SUPABASE_POOLER_HINT = "Use the SESSION POOLER connection (Supabase Dashboard -> Connect -> Session pooler): host " +
+    "aws-<n>-<region>.pooler.supabase.com, user postgres.<project-ref>. The direct " +
+    "db.<ref>.supabase.co host is IPv6-only and unreachable from most networks.";
+const MAX_ATTEMPTS = 20;
+function withDefault(question, defaultValue) {
+    return defaultValue ? `${question} [${defaultValue}]` : question;
+}
+function ask(question, defaultValue) {
+    const answer = interactiveQuestion(withDefault(question, defaultValue)).trim();
+    return answer === "" ? defaultValue !== null && defaultValue !== void 0 ? defaultValue : "" : answer;
+}
+function askRequired(question) {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const answer = ask(question);
+        if (answer !== "") {
+            return answer;
+        }
+        printError("A value is required.");
+    }
+    throw new Error(`No answer provided for: ${question}`);
+}
+function askChoice(question, choices, defaultValue) {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const answer = ask(question, defaultValue).toLowerCase();
+        if (choices.includes(answer)) {
+            return answer;
+        }
+        printError(`Please answer one of: ${choices.join(", ")}.`);
+    }
+    throw new Error(`No valid answer provided for: ${question}`);
+}
+function askYesNo(question, defaultValue) {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const answer = ask(question, defaultValue ? "y" : "n").toLowerCase();
+        if (answer === "y" || answer === "yes") {
+            return true;
+        }
+        if (answer === "n" || answer === "no") {
+            return false;
+        }
+        printError("Please answer y or n.");
+    }
+    throw new Error(`No valid answer provided for: ${question}`);
+}
+function askInt(question, defaultValue) {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const value = parseInt(ask(question, String(defaultValue)), 10);
+        if (!isNaN(value)) {
+            return value;
+        }
+        printError("Entered value must be an integer.");
+    }
+    throw new Error(`No valid answer provided for: ${question}`);
+}
+function collectCredentials(warehouse) {
+    if (warehouse === "mysql") {
+        const creds = {
+            host: ask(CREDS_HOST_QUESTION, "localhost"),
+            port: askInt(CREDS_PORT_QUESTION, 3306),
+            database: ask(CREDS_DATABASE_QUESTION, "sqlanvil"),
+            user: ask(CREDS_USER_QUESTION, "root"),
+            password: interactivePasswordQuestion(CREDS_PASSWORD_QUESTION),
+            sslMode: ask(CREDS_SSLMODE_QUESTION, "disable")
+        };
+        return `${JSON.stringify(creds, null, 2)}\n`;
+    }
+    const isSupabase = warehouse === "supabase";
+    if (isSupabase) {
+        print(SUPABASE_POOLER_HINT);
+    }
+    const host = ask(CREDS_HOST_QUESTION, isSupabase ? "aws-1-<region>.pooler.supabase.com" : "localhost");
+    if (/^db\..+\.supabase\.co$/.test(host)) {
+        printError("Warning: that is the DIRECT Supabase host, which is IPv6-only — connections fail with " +
+            "ENOTFOUND on most networks. Prefer the Session pooler host (Dashboard -> Connect).");
+    }
+    const creds = {
+        host,
+        port: askInt(CREDS_PORT_QUESTION, 5432),
+        database: ask(CREDS_DATABASE_QUESTION, "postgres"),
+        user: ask(CREDS_USER_QUESTION, isSupabase ? "postgres.<your-project-ref>" : "postgres"),
+        password: interactivePasswordQuestion(CREDS_PASSWORD_QUESTION),
+        sslMode: ask(CREDS_SSLMODE_QUESTION, isSupabase ? "require" : "disable"),
+        defaultSchema: "public"
+    };
+    return `${JSON.stringify(creds, null, 2)}\n`;
+}
+function printMigrationSummary(report, outDir) {
+    const targets = report.files.filter(f => f.action === "target");
+    const flagged = targets.filter(f => f.status === "flagged").length;
+    printSuccess(`Converted ${report.inventory.sqlxFiles} .sqlx file(s): ` +
+        `${report.connections.length} source connection(s) over ` +
+        `${report.files.filter(f => f.action === "declaration").length} declaration(s); ` +
+        `${targets.length} target file(s), ${flagged} flagged for dialect review.`);
+    print(`Report: ${path__namespace.join(outDir, "migration-report.md")}`);
+}
+function ensureGitignoreCoversCredentials(dir) {
+    const gitignorePath = path__namespace.join(dir, ".gitignore");
+    const existing = fs__namespace$1.existsSync(gitignorePath) ? fs__namespace$1.readFileSync(gitignorePath, "utf8") : "";
+    if (existing.includes(".df-credentials")) {
+        return;
+    }
+    const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    fs__namespace$1.writeFileSync(gitignorePath, `${existing}${separator}.df-credentials*.json\n`);
+}
+async function runConvertFlow() {
+    let srcDir = "";
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const candidate = actuallyResolve(askRequired(CONVERT_SOURCE_QUESTION));
+        if (fs__namespace$1.existsSync(candidate)) {
+            srcDir = candidate;
+            break;
+        }
+        printError(`${candidate} does not exist.`);
+    }
+    if (!srcDir) {
+        throw new Error("No usable source directory provided.");
+    }
+    const outDir = actuallyResolve(askRequired(CONVERT_OUT_QUESTION));
+    print("\nConverting...\n");
+    const report = await migrateDataform({ srcDir, outDir });
+    printMigrationSummary(report, outDir);
+    if (askYesNo(INIT_CONFIGURE_CREDS_QUESTION, true)) {
+        const credentialsPath = path__namespace.join(outDir, CREDENTIALS_FILENAME);
+        ensureGitignoreCoversCredentials(outDir);
+        fs__namespace$1.writeFileSync(credentialsPath, collectCredentials("supabase"));
+        printSuccess(`Credentials written to ${credentialsPath}`);
+    }
+    print("\nNext steps:");
+    print(`  1. sqlanvil compile ${outDir}`);
+    print(`  2. Review ${path__namespace.join(outDir, "migration-report.md")} — BigQuery source connections ` +
+        `need columnTypes (the introspect commands are in the report).`);
+    print(`  3. sqlanvil validate ${outDir}  (PASS/FAILURE/BLOCKED per model = the migration to-do list)`);
+    return 0;
+}
+async function runFreshFlow(defaultProjectDir) {
+    const warehouse = askChoice(INIT_WAREHOUSE_QUESTION, ["supabase", "postgres", "bigquery", "mysql"], "supabase");
+    const isPostgresLike = warehouse === "postgres" || warehouse === "supabase";
+    const projectDir = actuallyResolve(ask(INIT_PROJECT_DIR_QUESTION, defaultProjectDir));
+    const projectConfig = { warehouse };
+    if (warehouse === "bigquery") {
+        projectConfig.defaultDatabase = askRequired(INIT_BQ_PROJECT_QUESTION);
+        projectConfig.defaultLocation = askRequired(INIT_BQ_LOCATION_QUESTION);
+    }
+    projectConfig.defaultSchema = ask(INIT_DEFAULT_SCHEMA_QUESTION, isPostgresLike ? "public" : "sqlanvil");
+    const includeSample = askYesNo(INIT_INCLUDE_SAMPLE_QUESTION, true);
+    const includeBigQuerySource = includeSample && isPostgresLike ? askYesNo(INIT_INCLUDE_BQ_SOURCE_QUESTION, true) : undefined;
+    let credentialsJson;
+    if (warehouse !== "bigquery" && askYesNo(INIT_CONFIGURE_CREDS_QUESTION, true)) {
+        credentialsJson = collectCredentials(warehouse);
+    }
+    print("\nWriting project files...\n");
+    const result = await init(projectDir, projectConfig, {
+        includeSample,
+        includeBigQuerySource,
+        credentialsJson
+    });
+    printInitResult(result);
+    const steps = [];
+    if (warehouse === "bigquery") {
+        steps.push(`sqlanvil init-creds ${projectDir}  (BigQuery credentials)`);
+    }
+    else if (!credentialsJson) {
+        steps.push(`Edit ${CREDENTIALS_FILENAME} (gitignored) with your warehouse credentials.`);
+    }
+    if (includeSample) {
+        steps.push("Point definitions/sources/app_orders.sqlx at a real table in your warehouse.");
+    }
+    if (isPostgresLike && includeBigQuerySource) {
+        steps.push("Replace REPLACE_WITH_YOUR_GCP_PROJECT in workflow_settings.yaml (billingProject for " +
+            "the BigQuery sample source).");
+    }
+    steps.push(`sqlanvil compile ${projectDir}`);
+    steps.push(`sqlanvil validate ${projectDir}  (checks every model against the warehouse without executing)`);
+    print("\nNext steps:");
+    steps.forEach((step, index) => print(`  ${index + 1}. ${step}`));
+    return 0;
+}
+async function runInteractiveInit(defaultProjectDir) {
+    if (!process.stdin.isTTY && process.env.DATAFORM_CLI_TEST_INPUTS === undefined) {
+        printError("init --interactive needs an interactive terminal (stdin is not a TTY). " +
+            "Use the non-interactive form instead: sqlanvil init [project-dir] --warehouse=... " +
+            '(see "sqlanvil help init").');
+        return 1;
+    }
+    const mode = askChoice(INIT_MODE_QUESTION, ["fresh", "convert"], "fresh");
+    if (mode === "convert") {
+        return runConvertFlow();
+    }
+    return runFreshFlow(defaultProjectDir);
+}
+
+const CHECKER_SOURCE = `
+import json, os, sys
+
+script_path, requirements_path, version_spec = sys.argv[1], sys.argv[2], sys.argv[3]
+errors = []
+
+import platform
+py_version = platform.python_version()
+
+def load_packaging():
+    try:
+        from packaging.specifiers import SpecifierSet
+        from packaging.requirements import Requirement
+        return SpecifierSet, Requirement
+    except ImportError:
+        pass
+    try:
+        from pip._vendor.packaging.specifiers import SpecifierSet
+        from pip._vendor.packaging.requirements import Requirement
+        return SpecifierSet, Requirement
+    except ImportError:
+        return None, None
+
+SpecifierSet, Requirement = load_packaging()
+
+def mini_parse(v):
+    import re
+    return [int(x) for x in re.findall(r"[0-9]+", v.split("+")[0])][:4]
+
+def mini_check(version, spec):
+    import re
+    ok = True
+    for clause in spec.split(","):
+        clause = clause.strip()
+        m = re.match(r"(===|==|!=|<=|>=|~=|<|>)\\s*(.+)", clause)
+        if not m:
+            return None
+        op, want = m.group(1), m.group(2).strip()
+        if want.endswith(".*"):
+            prefix = mini_parse(want[:-2])
+            have = mini_parse(version)[:len(prefix)]
+            eq = have == prefix
+            if (op in ("==", "===") and not eq) or (op == "!=" and eq):
+                ok = False
+            continue
+        a, b = mini_parse(version), mini_parse(want)
+        n = max(len(a), len(b))
+        a = a + [0] * (n - len(a))
+        b = b + [0] * (n - len(b))
+        if op in ("==", "==="):
+            res = a == b
+        elif op == "!=":
+            res = a != b
+        elif op == "<=":
+            res = a <= b
+        elif op == ">=":
+            res = a >= b
+        elif op == "<":
+            res = a < b
+        elif op == ">":
+            res = a > b
+        else:  # ~= : at least b, within b's series
+            wb = mini_parse(want)
+            res = a >= b and a[:max(len(wb) - 1, 1)] == b[:max(len(wb) - 1, 1)]
+        if not res:
+            ok = False
+    return ok
+
+def check_version(version, spec, what):
+    if SpecifierSet is not None:
+        try:
+            if version not in SpecifierSet(spec, prereleases=True):
+                errors.append('%s: installed %s does not satisfy "%s"' % (what, version, spec))
+            return
+        except Exception as e:
+            errors.append('%s: could not evaluate specifier "%s": %s' % (what, spec, e))
+            return
+    if mini_check(version, spec) is False:
+        errors.append('%s: installed %s does not satisfy "%s"' % (what, version, spec))
+
+if version_spec:
+    check_version(py_version, version_spec, "python interpreter")
+
+if requirements_path:
+    from importlib import metadata
+    try:
+        lines = open(requirements_path).read().splitlines()
+    except OSError as e:
+        errors.append("requirements: cannot read %s: %s" % (requirements_path, e))
+        lines = []
+    for raw in lines:
+        line = raw.split("#")[0].strip()
+        if not line or line.startswith("-"):
+            continue
+        if Requirement is not None:
+            try:
+                req = Requirement(line)
+            except Exception:
+                errors.append('requirements: cannot parse "%s"' % line)
+                continue
+            if req.marker is not None and not req.marker.evaluate():
+                continue
+            name, spec = req.name, str(req.specifier)
+        else:
+            import re
+            if ";" in line:
+                line = line.split(";")[0].strip()
+            m = re.match(r"^([A-Za-z0-9][A-Za-z0-9._-]*)\\s*(\\[[^\\]]*\\])?\\s*(.*)$", line)
+            if not m:
+                errors.append('requirements: cannot parse "%s"' % line)
+                continue
+            name, spec = m.group(1), (m.group(3) or "").strip()
+        try:
+            installed = metadata.version(name)
+        except metadata.PackageNotFoundError:
+            errors.append(
+                "requirements: %s is not installed%s" % (name, " (need %s)" % spec if spec else "")
+            )
+            continue
+        if spec:
+            check_version(installed, spec, "requirements: %s" % name)
+
+try:
+    with open(script_path, "rb") as f:
+        compile(f.read(), script_path, "exec")
+except SyntaxError as e:
+    errors.append("syntax: %s (line %s)" % (e.msg, e.lineno))
+except (OSError, ValueError) as e:
+    errors.append("syntax: cannot compile %s: %s" % (script_path, e))
+
+print(json.dumps({"interpreter_version": py_version, "errors": errors}))
+`;
+const defaultCheckerExec = (interpreter, args, cwd) => new Promise((resolve, reject) => {
+    childProcess.execFile(interpreter, args, { cwd, timeout: 60000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+        if (err) {
+            reject(new Error(`checker failed under ${interpreter}: ${err.message}\n${stderr}`.trim()));
+        }
+        else {
+            resolve(stdout);
+        }
+    });
+});
+const failure = (message) => ({
+    status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE,
+    error: { message }
+});
+async function checkScriptAction(script, projectDir, checkerExec = defaultCheckerExec) {
+    if (script.language !== "python") {
+        return [failure(`no validator for script language "${script.language}"`)];
+    }
+    let interpreter;
+    try {
+        interpreter = resolveInterpreter({ language: script.language, envRoot: script.envRoot }, projectDir);
+    }
+    catch (e) {
+        return [failure(e.message)];
+    }
+    let stdout;
+    try {
+        stdout = await checkerExec(interpreter, ["-c", CHECKER_SOURCE, script.scriptFilename, script.depsFile || "", script.runtimeVersion || ""], projectDir);
+    }
+    catch (e) {
+        return [failure(e.message)];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (e) {
+        return [failure(`checker returned unparseable output: ${stdout.slice(0, 500)}`)];
+    }
+    if (parsed.errors && parsed.errors.length > 0) {
+        return parsed.errors.map(failure);
+    }
+    return [{ status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS }];
+}
+
+function targetKey(target) {
+    return [target.database, target.schema, target.name].filter(Boolean).join(".");
+}
+function topoOrder(nodes) {
+    const byKey = new Map(nodes.map(n => [n.key, n]));
+    const indegree = new Map();
+    const dependents = new Map();
+    for (const n of nodes) {
+        const inGraphDeps = Array.from(new Set(n.dependencyKeys.filter(d => byKey.has(d) && d !== n.key)));
+        indegree.set(n.key, inGraphDeps.length);
+        for (const dep of inGraphDeps) {
+            dependents.set(dep, (dependents.get(dep) || []).concat(n.key));
+        }
+    }
+    const ready = nodes
+        .filter(n => (indegree.get(n.key) || 0) === 0)
+        .map(n => n.key)
+        .sort();
+    const ordered = [];
+    const emitted = new Set();
+    while (ready.length) {
+        const key = ready.shift();
+        if (emitted.has(key)) {
+            continue;
+        }
+        emitted.add(key);
+        ordered.push(byKey.get(key));
+        for (const dep of (dependents.get(key) || []).slice().sort()) {
+            indegree.set(dep, (indegree.get(dep) || 0) - 1);
+            if ((indegree.get(dep) || 0) <= 0 && !emitted.has(dep)) {
+                ready.push(dep);
+                ready.sort();
+            }
+        }
+    }
+    if (ordered.length < nodes.length) {
+        for (const n of nodes.slice().sort((a, b) => a.key.localeCompare(b.key))) {
+            if (!emitted.has(n.key)) {
+                emitted.add(n.key);
+                ordered.push(n);
+            }
+        }
+    }
+    return ordered;
+}
+function dependencyBlocked(dependencyKeys, statusByKey) {
+    return dependencyKeys.some(dep => {
+        const status = statusByKey.get(dep);
+        return status !== undefined && status !== "PASS";
+    });
+}
+const VALIDATE_SHADOW_PREFIX = "sqlanvil_validate_";
+function validateShadowSuffix(nowMs) {
+    return `${VALIDATE_SHADOW_PREFIX}${nowMs}`;
+}
+function parseShadowTimestamp(schemaName) {
+    const match = schemaName.match(/sqlanvil_validate_(\d+)/);
+    return match ? Number(match[1]) : null;
+}
+function shadowSchemasToSweep(schemaNames, nowMs, maxAgeMs) {
+    return schemaNames.filter(name => {
+        const ts = parseShadowTimestamp(name);
+        return ts !== null && nowMs - ts > maxAgeMs;
+    });
+}
+
+const SHADOW_MAX_AGE_MS = 60 * 60 * 1000;
+async function sweepOrphanShadows(deps, nowMs, maxAgeMs = SHADOW_MAX_AGE_MS) {
+    try {
+        const schemas = await deps.listSchemas();
+        for (const schema of shadowSchemasToSweep(schemas, nowMs, maxAgeMs)) {
+            try {
+                await deps.execute(deps.dropSchemaCascadeSql(schema));
+            }
+            catch (e) {
+            }
+        }
+    }
+    catch (e) {
+    }
+}
+function tableType(enumType) {
+    switch (enumType) {
+        case sqlanvil.TableType.VIEW:
+            return "view";
+        case sqlanvil.TableType.INCREMENTAL:
+            return "incremental";
+        default:
+            return "table";
+    }
+}
+function depKeys(deps) {
+    return (deps || []).map(targetKey);
+}
+async function validate(compiledGraph, deps, options = {}) {
+    const nodes = [];
+    for (const table of compiledGraph.tables || []) {
+        nodes.push({
+            key: targetKey(table.target),
+            dependencyKeys: depKeys(table.dependencyTargets),
+            kind: "table",
+            type: tableType(table.enumType),
+            target: table.target,
+            table,
+            action: table
+        });
+    }
+    for (const assertion of compiledGraph.assertions || []) {
+        nodes.push({
+            key: targetKey(assertion.target),
+            dependencyKeys: depKeys(assertion.dependencyTargets),
+            kind: "assertion",
+            type: "assertion",
+            target: assertion.target,
+            action: assertion
+        });
+    }
+    for (const operation of compiledGraph.operations || []) {
+        if (!operation.target) {
+            continue;
+        }
+        nodes.push({
+            key: targetKey(operation.target),
+            dependencyKeys: depKeys(operation.dependencyTargets),
+            kind: "operation",
+            type: "operation",
+            target: operation.target,
+            action: undefined
+        });
+    }
+    for (const imp of compiledGraph.imports || []) {
+        if (!imp.target) {
+            continue;
+        }
+        nodes.push({
+            key: targetKey(imp.target),
+            dependencyKeys: depKeys(imp.dependencyTargets),
+            kind: "import",
+            type: "import",
+            target: imp.target,
+            action: undefined
+        });
+    }
+    for (const script of compiledGraph.scripts || []) {
+        if (!script.target) {
+            continue;
+        }
+        nodes.push({
+            key: targetKey(script.target),
+            dependencyKeys: depKeys(script.dependencyTargets),
+            kind: "script",
+            type: "script",
+            target: script.target,
+            script,
+            action: undefined
+        });
+    }
+    const ordered = topoOrder(nodes);
+    const shadowSchemas = Array.from(new Set(nodes.filter(n => n.kind === "table").map(n => n.target.schema)));
+    const statusByKey = new Map();
+    const results = [];
+    try {
+        for (const schema of shadowSchemas) {
+            await deps.execute(deps.createSchemaSql(schema));
         }
-        case sqlanvil.ActionResult.ExecutionStatus.FAILED: {
-            switch (executionAction.type) {
-                case "table": {
-                    writeStdErr(`${errorOutput("Dataset creation failed: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    break;
-                }
-                case "assertion": {
-                    writeStdErr(`${errorOutput("Assertion failed: ")} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    break;
-                }
-                case "operation": {
-                    writeStdErr(`${errorOutput("Operation failed: ")} ${operationString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
-                    break;
-                }
+        for (const node of ordered) {
+            if (node.kind === "operation" ||
+                node.kind === "import" ||
+                (node.kind === "script" && !deps.checkScript)) {
+                statusByKey.set(node.key, "SKIPPED");
+                results.push({ target: node.target, type: node.type, status: "SKIPPED", errors: [] });
+                continue;
             }
-            printExecutedActionErrors(executedAction, executionAction);
-            return;
-        }
-        case sqlanvil.ActionResult.ExecutionStatus.SKIPPED: {
-            switch (executionAction.type) {
-                case "table": {
-                    writeStdOut(`${warningOutput("Skipping dataset creation: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}`);
-                    return;
-                }
-                case "assertion": {
-                    writeStdOut(`${warningOutput("Skipping assertion execution: ")} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}`);
-                    return;
+            if (dependencyBlocked(node.dependencyKeys, statusByKey)) {
+                statusByKey.set(node.key, "BLOCKED");
+                results.push({ target: node.target, type: node.type, status: "BLOCKED", errors: [] });
+                continue;
+            }
+            const evaluations = node.kind === "script"
+                ? await deps.checkScript(node.script)
+                : await deps.evaluate(node.action);
+            const failed = evaluations.some(e => e.status === sqlanvil.QueryEvaluation.QueryEvaluationStatus.FAILURE);
+            const status = failed ? "FAILURE" : "PASS";
+            statusByKey.set(node.key, status);
+            results.push({ target: node.target, type: node.type, status, errors: evaluations });
+            if (status === "PASS" && node.kind === "table") {
+                try {
+                    await deps.execute(deps.validationStubSql(node.table));
                 }
-                case "operation": {
-                    writeStdOut(`${warningOutput("Skipping operation execution: ")} ${operationString(executionAction.target, executionAction.tasks.length === 0)}`);
-                    return;
+                catch (e) {
                 }
             }
-            return;
         }
-        case sqlanvil.ActionResult.ExecutionStatus.DISABLED: {
-            switch (executionAction.type) {
-                case "table": {
-                    writeStdOut(`${warningOutput("Dataset creation disabled: ")} ${datasetString(executionAction.target, executionAction.tableType, executionAction.tasks.length === 0)}`);
-                    return;
-                }
-                case "assertion": {
-                    writeStdOut(`${warningOutput(`Assertion execution disabled: `)} ${assertionString(executionAction.target, executionAction.tasks.length === 0)}`);
-                    return;
+    }
+    finally {
+        if (!options.keepShadow) {
+            for (const schema of shadowSchemas.slice().reverse()) {
+                try {
+                    await deps.execute(deps.dropSchemaCascadeSql(schema));
                 }
-                case "operation": {
-                    writeStdOut(`${warningOutput(`Operation execution disabled: `)} ${operationString(executionAction.target, executionAction.tasks.length === 0)}`);
-                    return;
+                catch (e) {
                 }
             }
-            return;
         }
     }
+    return results;
 }
-function printFormatFilesResult(formatResults) {
-    const sorted = formatResults.sort((a, b) => a.filename.localeCompare(b.filename));
-    const successfulFormatResults = sorted.filter(result => !result.err && !result.needsFormatting);
-    const needsFormattingResults = sorted.filter(result => !result.err && result.needsFormatting);
-    const failedFormatResults = sorted.filter(result => !!result.err);
-    if (successfulFormatResults.length > 0) {
-        printSuccess("Successfully formatted:");
-        successfulFormatResults.forEach(result => writeStdOut(result.filename, 1));
-    }
-    if (needsFormattingResults.length > 0) {
-        printError("Files that need formatting:");
-        needsFormattingResults.forEach(result => writeStdErr(result.filename, 1));
+
+class SupabaseDbAdapter extends PostgresDbAdapter {
+    static async create(credentials, options) {
+        const sslMode = (credentials.sslMode || "").toLowerCase();
+        const sslEnabled = !(options === null || options === void 0 ? void 0 : options.disableSslForTestsOnly) && sslMode !== "disable";
+        const clientConfig = {
+            host: credentials.host,
+            port: credentials.port,
+            database: credentials.database,
+            user: credentials.user,
+            password: credentials.password,
+            ssl: sslEnabled
+                ? {
+                    rejectUnauthorized: sslMode === "verify-ca" || sslMode === "verify-full"
+                }
+                : false
+        };
+        const queryExecutor = new PgPoolExecutor(clientConfig, options);
+        try {
+            await queryExecutor.verifyConnection();
+        }
+        catch (e) {
+            await queryExecutor.close().catch(() => undefined);
+            throw new ErrorWithCause(`Could not connect to Supabase Postgres at ${credentials.host}:${credentials.port} ` +
+                `as "${credentials.user}": ${e.message}`, e);
+        }
+        return new SupabaseDbAdapter(queryExecutor);
     }
-    if (failedFormatResults.length > 0) {
-        printError("Errors encountered during formatting:");
-        failedFormatResults.forEach(result => writeStdOut(`${result.filename}: ${result.err.message}`, 1));
+    constructor(queryExecutor) {
+        super(queryExecutor);
     }
-}
-function datasetString(target, datasetType, disabled) {
-    return `${targetString(target)} [${datasetType}]${disabled ? " [disabled]" : ""}`;
-}
-function assertionString(target, disabled) {
-    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
-}
-function operationString(target, disabled) {
-    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
-}
-function plainTargetString(target) {
-    return `${target.schema}.${target.name}`;
-}
-function targetString(target) {
-    return calloutOutput(`${target.schema}.${target.name}`);
-}
-function dotRepresentation(graph, interactive) {
-    var _a, _b, _c;
-    const nodes = [];
-    const edges = [];
-    const formatTarget = interactive ? targetString : plainTargetString;
-    (_a = graph.tables) === null || _a === void 0 ? void 0 : _a.forEach(table => {
-        var _a;
-        const nodeName = `${formatTarget(table.target)}`;
-        nodes.push(`"${nodeName}" [label="${formatTarget(table.target)} [${tableTypeEnumToString(table.enumType)}]"]`);
-        (_a = table.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
-            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
-        });
-    });
-    (_b = graph.assertions) === null || _b === void 0 ? void 0 : _b.forEach(assertion => {
-        var _a;
-        const nodeName = `${formatTarget(assertion.target)}`;
-        nodes.push(`"${nodeName}" [label="${formatTarget(assertion.target)}"]`);
-        (_a = assertion.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
-            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
-        });
-    });
-    (_c = graph.operations) === null || _c === void 0 ? void 0 : _c.forEach(operation => {
+    async verifyServiceRolePermissions() {
         var _a;
-        const nodeName = `${formatTarget(operation.target)}`;
-        nodes.push(`"${nodeName}" [label="${formatTarget(operation.target)}"`);
-        (_a = operation.dependencyTargets) === null || _a === void 0 ? void 0 : _a.forEach(dependencyTarget => {
-            edges.push(`"${formatTarget(dependencyTarget)}" -> "${nodeName}"`);
-        });
-    });
-    return `digraph {\n${nodes.join(";\n")};\n${edges.join(";\n")};\n}`;
-}
-function printExecutedActionErrors(executedAction, executionAction) {
-    const failingTasks = executedAction.tasks.filter(task => task.status === sqlanvil.TaskResult.ExecutionStatus.FAILED);
-    failingTasks.forEach((task, i) => {
-        executionAction.tasks[i].statement.split("\n").forEach(line => {
-            writeStdErr(`${DEFAULT_PROMPT}${line}`, 1);
-        });
-        printError(task.errorMessage, 1);
-    });
+        try {
+            const result = await this.execute("select current_user");
+            const currentUser = (_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.current_user;
+            return !!currentUser;
+        }
+        catch (_b) {
+            return false;
+        }
+    }
+    async validatePublicationState(pubName = "supabase_realtime") {
+        try {
+            const result = await this.execute(`select 1 from pg_publication where pubname = $1`, {
+                params: [pubName]
+            });
+            return result.rows.length > 0;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
 }
 
 function getBigQueryCredentials() {
@@ -55990,6 +56817,18 @@ const icebergOption = option("iceberg", {
     type: "boolean",
     default: false
 });
+const bareOption = option("bare", {
+    describe: "Skip the sample project files — scaffold bare (gitkept) directories only.",
+    type: "boolean",
+    default: false
+});
+const interactiveOption = option("interactive", {
+    describe: "Guided Q&A setup: start a fresh project (warehouse, sample project, credentials) or " +
+        "convert an existing Dataform project. Other init arguments are ignored except " +
+        "[project-dir], which seeds the directory prompt.",
+    type: "boolean",
+    default: false
+});
 const warehouseOption = option("warehouse", {
     describe: "Target warehouse for the new project.",
     type: "string",
@@ -56239,14 +57078,17 @@ function runCli() {
             {
                 format: `init [${projectDirOption.name}] [${ProjectConfigOptions.defaultDatabase.name}]` +
                     ` [${ProjectConfigOptions.defaultLocation.name}]`,
-                description: "Create a new sqlanvil project (BigQuery, Postgres, Supabase, or MySQL/MariaDB).",
+                description: "Create a new sqlanvil project (BigQuery, Postgres, Supabase, or MySQL/MariaDB). " +
+                    "Use --interactive for a guided setup, including converting a Dataform project.",
                 positionalOptions: [
                     projectDirOption,
                     positionalOption(ProjectConfigOptions.defaultDatabase.name, {
                         describe: "The default database to use, equivalent to Google Cloud Project ID."
                     }, (argv) => {
                         const warehouse = argv[warehouseOption.name] || "bigquery";
-                        if (warehouse === "bigquery" && !argv[ProjectConfigOptions.defaultDatabase.name]) {
+                        if (warehouse === "bigquery" &&
+                            !argv[interactiveOption.name] &&
+                            !argv[ProjectConfigOptions.defaultDatabase.name]) {
                             throw new Error(`The ${ProjectConfigOptions.defaultDatabase.name} positional argument is ` +
                                 `required for BigQuery projects. Use "sqlanvil help init" for more info.`);
                         }
@@ -56256,15 +57098,20 @@ function runCli() {
                             "https://cloud.google.com/bigquery/docs/locations for supported values."
                     }, (argv) => {
                         const warehouse = argv[warehouseOption.name] || "bigquery";
-                        if (warehouse === "bigquery" && !argv[ProjectConfigOptions.defaultLocation.name]) {
+                        if (warehouse === "bigquery" &&
+                            !argv[interactiveOption.name] &&
+                            !argv[ProjectConfigOptions.defaultLocation.name]) {
                             throw new Error(`The ${ProjectConfigOptions.defaultLocation.name} positional argument is ` +
                                 `required for BigQuery projects. Use "sqlanvil help init" for more info.`);
                         }
                     })
                 ],
-                options: [warehouseOption, icebergOption],
+                options: [warehouseOption, icebergOption, bareOption, interactiveOption],
                 processFn: async (argv) => {
                     const projectDir = argv[projectDirOption.name];
+                    if (argv[interactiveOption.name]) {
+                        return runInteractiveInit(projectDir);
+                    }
                     const warehouse = argv[warehouseOption.name] || "bigquery";
                     const projectConfig = { warehouse };
                     if (warehouse === "bigquery") {
@@ -56278,7 +57125,9 @@ function runCli() {
                         }
                     }
                     print("Writing project files...\n");
-                    const initResult = await init(projectDir, projectConfig);
+                    const initResult = await init(projectDir, projectConfig, {
+                        includeSample: !argv[bareOption.name]
+                    });
                     printInitResult(initResult);
                     return 0;
                 }
@@ -56843,6 +57692,31 @@ function runCli() {
                     }
                     return 0;
                 }
+            },
+            {
+                format: "migrate-dataform <source-dir> <out-dir>",
+                description: "Convert a Dataform/BigQuery project into a sqlanvil-on-Postgres project. The source " +
+                    "directory is READ-ONLY; the converted project + migration-report.{md,json} land in " +
+                    "<out-dir> (must be empty). Sources stay in BigQuery as named connections; target SQL " +
+                    "gets safe rewrites + inline SQLANVIL-MIGRATE markers for dialect review.",
+                positionalOptions: [
+                    positionalOption("source-dir", {
+                        describe: "The Dataform project to convert (never modified)."
+                    }),
+                    positionalOption("out-dir", {
+                        describe: "Where the converted sqlanvil project is written (created; must be empty)."
+                    })
+                ],
+                options: [],
+                processFn: async (argv) => {
+                    const report = await migrateDataform({
+                        srcDir: argv["source-dir"],
+                        outDir: argv["out-dir"]
+                    });
+                    printMigrationSummary(report, argv["out-dir"]);
+                    print(`Next: sqlanvil compile ${argv["out-dir"]}`);
+                    return 0;
+                }
             }
         ]
     })