@sqlanvil/cli 1.22.0 → 1.23.0

package/bundle.js

@@ -50606,7 +50606,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.22.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")}.
@@ -54772,948 +54780,1170 @@ function renderReportMd(r) {
     return lines.join("\n");
 }
 
-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);
+function actuallyResolve(...filePaths) {
+    return path__namespace.resolve(...filePaths.map(filePath => untildify__default["default"](filePath)));
+}
+function assertPathExists(checkPath) {
+    if (!fs__namespace$1.existsSync(checkPath)) {
+        throw new Error(`${checkPath} does not exist!`);
     }
-    catch (e) {
-        return [failure(`checker returned unparseable output: ${stdout.slice(0, 500)}`)];
+}
+function compiledGraphHasErrors(graph) {
+    var _a, _b;
+    return ((_b = (_a = graph.graphErrors) === null || _a === void 0 ? void 0 : _a.compilationErrors) === null || _b === void 0 ? void 0 : _b.length) > 0;
+}
+function formatExecutionSuffix(jobIds, bytesBilled) {
+    const jobMetadataParts = [];
+    if (jobIds.length > 0) {
+        jobMetadataParts.push(`\n \t jobId: ${jobIds.join(", ")}`);
     }
-    if (parsed.errors && parsed.errors.length > 0) {
-        return parsed.errors.map(failure);
+    if (bytesBilled.length > 0) {
+        jobMetadataParts.push(`\n \t Bytes billed: ${bytesBilled.join(", ")}`);
     }
-    return [{ status: sqlanvil.QueryEvaluation.QueryEvaluationStatus.SUCCESS }];
-}
-
-function targetKey(target) {
-    return [target.database, target.schema, target.name].filter(Boolean).join(".");
+    return jobMetadataParts.length > 0 ? ` ${jobMetadataParts}` : "";
 }
-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));
-        }
+function formatBytesInHumanReadableFormat(bytes) {
+    if (bytes <= 0) {
+        return '0 B';
     }
-    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();
+    const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'];
+    const k = 1024;
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const value = (bytes / Math.pow(k, i)).toFixed(2);
+    return `${value} ${units[i]}`;
+}
+function promptForIcebergConfig() {
+    print(ICEBERG_CONFIG_PROMPT_TEXT);
+    print(ICEBERG_CONFIG_PROMPT_HINT);
+    const tempIcebergConfig = {};
+    let bucketName;
+    while (true) {
+        print(ICEBERG_BUCKET_NAME_HINT);
+        bucketName = interactiveQuestion(ICEBERG_BUCKET_NAME_PROMPT_QUESTION);
+        try {
+            if (bucketName) {
+                validateIcebergConfigBucketName(bucketName);
+                tempIcebergConfig.bucketName = bucketName;
             }
+            break;
         }
-    }
-    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);
-            }
+        catch (e) {
+            printError(`Validation Error: ${e.message}`);
+            print("Please try again.");
         }
     }
-    return ordered;
-}
-function dependencyBlocked(dependencyKeys, statusByKey) {
-    return dependencyKeys.some(dep => {
-        const status = statusByKey.get(dep);
-        return status !== undefined && status !== "PASS";
-    });
+    let tableFolderRoot;
+    while (true) {
+        print(ICEBERG_TABLE_FOLDER_ROOT_HINT);
+        tableFolderRoot = interactiveQuestion(ICEBERG_TABLE_FOLDER_ROOT_PROMPT_QUESTION);
+        try {
+            if (tableFolderRoot) {
+                validateIcebergConfigTableFolderRoot(tableFolderRoot);
+                tempIcebergConfig.tableFolderRoot = tableFolderRoot;
+            }
+            break;
+        }
+        catch (e) {
+            printError(`Validation Error: ${e.message}`);
+            print("Please try again.");
+        }
+    }
+    let tableFolderSubpath;
+    while (true) {
+        print(ICEBERG_TABLE_FOLDER_ROOT_SUBPATH_HINT);
+        tableFolderSubpath = interactiveQuestion(ICEBERG_TABLE_FOLDER_SUBPATH_PROMPT_QUESTION);
+        try {
+            if (tableFolderSubpath) {
+                validateIcebergConfigTableFolderSubpath(tableFolderSubpath);
+                tempIcebergConfig.tableFolderSubpath = tableFolderSubpath;
+            }
+            break;
+        }
+        catch (e) {
+            printError(`Validation Error: ${e.message}`);
+            print("Please try again.");
+        }
+    }
+    let connection;
+    while (true) {
+        print(ICEBERG_CONNECTION_HINT);
+        connection = interactiveQuestion(ICEBERG_CONNECTION_QUESTION);
+        try {
+            if (connection) {
+                validateConnectionFormat(connection);
+                tempIcebergConfig.connection = connection;
+            }
+            break;
+        }
+        catch (e) {
+            printError(`Validation Error: ${e.message}`);
+            print("Please try again.");
+        }
+    }
+    printSuccess(ICEBERG_CONFIG_COLLECTED_TEXT);
+    if (Object.keys(tempIcebergConfig).length > 0) {
+        return tempIcebergConfig;
+    }
+    return undefined;
 }
-const VALIDATE_SHADOW_PREFIX = "sqlanvil_validate_";
-function validateShadowSuffix(nowMs) {
-    return `${VALIDATE_SHADOW_PREFIX}${nowMs}`;
+function validateIcebergConfigBucketName(bucketName) {
+    if (bucketName.length < 3 || bucketName.length > 63) {
+        throw new Error("Bucket name must be between 3 and 63 characters long.");
+    }
+    if (!/^[a-z0-9][a-z0-9-._]{1,220}[a-z0-9]$/.test(bucketName) || bucketName.includes("..")) {
+        throw new Error("Invalid bucket name. Must start and end with a letter or number, contain only lowercase letters, numbers, hyphens (-), underscores (_), and periods (.).");
+    }
+    if (bucketName.startsWith("goog") || bucketName.includes("--")) {
+        throw new Error("Bucket name cannot start with 'goog' or contain '--'.");
+    }
+    if (bucketName.includes("google") || bucketName.includes("g00gle")) {
+        throw new Error("Bucket name cannot contain 'google' or close misspellings such as 'g00gle'.");
+    }
 }
-function parseShadowTimestamp(schemaName) {
-    const match = schemaName.match(/sqlanvil_validate_(\d+)/);
-    return match ? Number(match[1]) : null;
+function validateIcebergConfigTableFolderRoot(tableFolderRoot) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9-._]{1,220}[a-zA-Z0-9]$/.test(tableFolderRoot) || tableFolderRoot.includes("..")) {
+        throw new Error("Invalid input. Must start and end with a letter or number, contain only letters (a-z, A-Z), numbers, hyphens (-), underscores (_), and periods (.).");
+    }
 }
-function shadowSchemasToSweep(schemaNames, nowMs, maxAgeMs) {
-    return schemaNames.filter(name => {
-        const ts = parseShadowTimestamp(name);
-        return ts !== null && nowMs - ts > maxAgeMs;
-    });
+function validateIcebergConfigTableFolderSubpath(tableFolderSubpath) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9-._/]{1,220}[a-zA-Z0-9]$/.test(tableFolderSubpath) || tableFolderSubpath.includes("..")) {
+        throw new Error("Invalid input. Must start and end with a letter or number, contain only letters (a-z, A-Z), numbers, hyphens (-), underscores (_), periods (.), and forward slashes (/). The sequence '..' is also disallowed.");
+    }
+    if (tableFolderSubpath.includes("./") || tableFolderSubpath.includes("../")) {
+        throw new Error("Input cannot contain './' or '../'.");
+    }
 }
+const ICEBERG_BUCKET_NAME_HINT = "The bucket name must comply with https://cloud.google.com/storage/docs/buckets#naming. If you do not want to provide a workflow-level default bucket name, leave this input empty.\n";
+const ICEBERG_TABLE_FOLDER_ROOT_HINT = "Table folder root must start and end with a letter or a number. It can only contain letters, numbers, hyphens, underscores and periods. If you do not want to provide a workflow_level default table folder root, leave this input empty.\n";
+const ICEBERG_TABLE_FOLDER_ROOT_SUBPATH_HINT = "Table folder subpath must start and end with a letter or a number. It can only contain letters, numbers, hyphens, underscores, periods and forward slashes. If you do not want to provide a workflow_level default table folder subpath, leave this input empty.\n";
+const ICEBERG_CONFIG_PROMPT_HINT = "Set repository-level configuration for Iceberg bucket name, table folder root,  table folder subpath and connection. If you do not want to set a field, enter an empty string in response to the prompt.\n";
+const ICEBERG_CONFIG_PROMPT_TEXT = "\n--- Iceberg Configuration ---\n";
+const ICEBERG_CONFIG_COLLECTED_TEXT = "Iceberg configuration collected.\n";
+const ICEBERG_BUCKET_NAME_PROMPT_QUESTION = "Enter the default Iceberg bucket name:";
+const ICEBERG_TABLE_FOLDER_ROOT_PROMPT_QUESTION = "Enter the default Iceberg table folder root:";
+const ICEBERG_TABLE_FOLDER_SUBPATH_PROMPT_QUESTION = "Enter the default Iceberg table folder subpath:";
+const ICEBERG_CONNECTION_HINT = "The connection can have the form `{project}.{location}.{connection_id}` or `projects/{project}/locations/{location}/connections/{connection_id} or be set to DEFAULT. If you do not want to provide a workflow-level default connection, leave this input empty.\n";
+const ICEBERG_CONNECTION_QUESTION = "Enter the default connection:";
 
-const SHADOW_MAX_AGE_MS = 60 * 60 * 1000;
-async function sweepOrphanShadows(deps, nowMs, maxAgeMs = SHADOW_MAX_AGE_MS) {
+const noColor = process.env.NO_COLOR && ["1", "true", "yes"].includes(process.env.NO_COLOR.toLowerCase());
+const ansiColorCodes = Object.freeze({
+    red: 91,
+    green: 32,
+    yellow: 93,
+    cyan: 36
+});
+function output(text, ansiColorCode) {
+    if (noColor) {
+        return text;
+    }
+    return `\x1b[${ansiColorCode}m${text}\x1b[0m`;
+}
+const successOutput = (text) => output(text, ansiColorCodes.green);
+const warningOutput = (text) => output(text, ansiColorCodes.yellow);
+const errorOutput = (text) => output(text, ansiColorCodes.red);
+const calloutOutput = (text) => output(text, ansiColorCodes.cyan);
+const write = (stream, text, indentCount) => stream.write(`${"  ".repeat(indentCount)}${text}\n`);
+const writeStdOut = (text, indentCount = 0) => write(process.stdout, text, indentCount);
+const writeStdErr = (text, indentCount = 0) => write(process.stderr, text, indentCount);
+const DEFAULT_PROMPT = "> ";
+function question(questionText) {
+    return prompt(questionText);
+}
+function interactiveQuestion(questionText) {
+    if (!process.stdin.isTTY && process.env.DATAFORM_CLI_TEST_INPUTS !== undefined) {
+        const testInput = getTestInput(questionText);
+        print(`${questionText} ${testInput}\n`);
+        return testInput;
+    }
+    print(`${questionText} `);
+    return readlineSync__namespace.question("");
+}
+function getTestInput(questionText) {
+    const envVar = process.env.DATAFORM_CLI_TEST_INPUTS;
+    if (!envVar) {
+        throw new Error("Environment variable DATAFORM_CLI_TEST_INPUTS not set.");
+    }
     try {
-        const schemas = await deps.listSchemas();
-        for (const schema of shadowSchemasToSweep(schemas, nowMs, maxAgeMs)) {
-            try {
-                await deps.execute(deps.dropSchemaCascadeSql(schema));
+        const parsed = JSON.parse(envVar);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            const inputs = new Map(Object.entries(parsed).map(([key, value]) => [key, String(value)]));
+            const trimmedQuestion = questionText.trim();
+            const answer = inputs.get(trimmedQuestion);
+            if (answer !== undefined) {
+                print(`[TEST_INPUT for "${trimmedQuestion}"]: "${answer}"`);
+                return answer;
             }
-            catch (e) {
+            else {
+                throw new Error(`[MISSING TEST_INPUT for "${trimmedQuestion}"]`);
             }
         }
+        else {
+            throw new Error(`Failed to parse DATAFORM_CLI_TEST_INPUTS: Expected a JSON object, but got ${typeof parsed}.`);
+        }
     }
     catch (e) {
+        throw new Error(`Failed to parse DATAFORM_CLI_TEST_INPUTS: ${e.message || e}`);
     }
 }
-function tableType(enumType) {
-    switch (enumType) {
-        case sqlanvil.TableType.VIEW:
-            return "view";
-        case sqlanvil.TableType.INCREMENTAL:
-            return "incremental";
-        default:
-            return "table";
+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 depKeys(deps) {
-    return (deps || []).map(targetKey);
+function selectionQuestion(questionText, options) {
+    return readlineSync__namespace.keyInSelect(options, `${questionText}\n`, {
+        cancel: false
+    });
 }
-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
-        });
+function prompt(questionText, options) {
+    writeStdOut(questionText);
+    return readlineSync__namespace.prompt(Object.assign(Object.assign({}, options), { prompt: (options && options.prompt && options.prompt + DEFAULT_PROMPT) || DEFAULT_PROMPT }));
+}
+function print(text) {
+    writeStdOut(text);
+}
+function printSuccess(text) {
+    writeStdOut(successOutput(text));
+}
+function printError(errorText, indentCount = 0) {
+    writeStdErr(errorOutput(errorText), indentCount);
+}
+function printInitResult(result) {
+    if (result.dirsCreated && result.dirsCreated.length) {
+        writeStdOut(successOutput("Directories successfully created:"));
+        result.dirsCreated.forEach(dir => writeStdOut(dir, 1));
     }
-    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
-        });
+    if (result.filesWritten && result.filesWritten.length) {
+        writeStdOut(successOutput("Files successfully written:"));
+        result.filesWritten.forEach(file => writeStdOut(file, 1));
     }
-    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
-        });
+}
+function printInitCredsResult(writtenFilePath) {
+    writeStdOut(successOutput("Credentials file successfully written:"));
+    writeStdOut(writtenFilePath, 1);
+    writeStdOut("To change connection settings, edit this file directly.");
+}
+function isInteractive({ stream = process.stdout } = {}) {
+    return Boolean(stream && stream.isTTY &&
+        process.env.TERM !== 'dumb' &&
+        !('CI' in process.env));
+}
+var compiledGraphOutputType;
+(function (compiledGraphOutputType) {
+    compiledGraphOutputType["Json"] = "json";
+    compiledGraphOutputType["Dot"] = "dot";
+    compiledGraphOutputType["Summary"] = "summary";
+})(compiledGraphOutputType || (compiledGraphOutputType = {}));
+function printCompiledGraph(graph, outputType, quietCompilation) {
+    const interactive = isInteractive();
+    if (outputType === compiledGraphOutputType.Json) {
+        writeStdOut(prettyJsonStringify(graph));
     }
-    for (const imp of compiledGraph.imports || []) {
-        if (!imp.target) {
-            continue;
+    else if (outputType === compiledGraphOutputType.Dot) {
+        writeStdOut(dotRepresentation(graph, interactive));
+    }
+    else {
+        const actionCount = 0 +
+            (graph.tables ? graph.tables.length : 0) +
+            (graph.assertions ? graph.assertions.length : 0) +
+            (graph.operations ? graph.operations.length : 0);
+        writeStdOut(successOutput(`Compiled ${actionCount} action(s).`));
+        if (graph.tables && graph.tables.length) {
+            graph.tables.forEach(setOrValidateTableEnumType);
+            writeStdOut(`${graph.tables.length} dataset(s)${quietCompilation ? "." : ":"}`);
+            if (!quietCompilation) {
+                graph.tables.forEach(compiledTable => {
+                    writeStdOut(`${datasetString(compiledTable.target, tableTypeEnumToString(compiledTable.enumType), compiledTable.disabled)}`, 1);
+                });
+            }
+        }
+        if (graph.assertions && graph.assertions.length) {
+            writeStdOut(`${graph.assertions.length} assertion(s)${quietCompilation ? "." : ":"}`);
+            if (!quietCompilation) {
+                graph.assertions.forEach(assertion => {
+                    writeStdOut(assertionString(assertion.target, assertion.disabled), 1);
+                });
+            }
+        }
+        if (graph.operations && graph.operations.length) {
+            writeStdOut(`${graph.operations.length} operation(s)${quietCompilation ? "." : ":"}`);
+            if (!quietCompilation) {
+                graph.operations.forEach(operation => {
+                    writeStdOut(operationString(operation.target, operation.disabled), 1);
+                });
+            }
         }
-        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;
+}
+function formatStackTraceForQuietCompilation(compileError) {
+    var _a, _b;
+    if ((_a = compileError === null || compileError === void 0 ? void 0 : compileError.message) === null || _a === void 0 ? void 0 : _a.includes("Unexpected identifier")) {
+        if (!compileError.stack) {
+            return "";
         }
-        nodes.push({
-            key: targetKey(script.target),
-            dependencyKeys: depKeys(script.dependencyTargets),
-            kind: "script",
-            type: "script",
-            target: script.target,
-            script,
-            action: undefined
+        const stackLines = ((_b = compileError.stack) === null || _b === void 0 ? void 0 : _b.split("\n")) || [];
+        return stackLines.slice(0, Math.min(3, stackLines.length)).join("\n");
+    }
+    return "";
+}
+function printCompiledGraphErrors(graphErrors, quietCompilation) {
+    if (graphErrors.compilationErrors && graphErrors.compilationErrors.length > 0) {
+        printError("Compilation errors:", 1);
+        graphErrors.compilationErrors.forEach(compileError => {
+            writeStdErr(`${calloutOutput(compileError.fileName)}: ${errorOutput(quietCompilation ? (compileError.message + " " + formatStackTraceForQuietCompilation(compileError) || compileError.stack) : (compileError.stack || compileError.message))}`, 1);
         });
     }
-    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;
+}
+function printTestResult(testResult) {
+    writeStdOut(`${testResult.name}: ${testResult.successful ? successOutput("passed") : errorOutput("failed")}`);
+    if (!testResult.successful) {
+        testResult.messages.forEach(message => writeStdErr(message, 1));
+    }
+}
+function printExecutionGraph(executionGraph, asJson) {
+    if (asJson) {
+        writeStdOut(prettyJsonStringify(executionGraph.toJSON()));
+    }
+    else {
+        const actionsByType = {
+            table: [],
+            assertion: [],
+            operation: []
+        };
+        executionGraph.actions.forEach(action => {
+            if (!(action.type === "table" || action.type === "assertion" || action.type === "operation")) {
+                throw new Error(`Unrecognized action type: ${action.type}`);
             }
-            if (dependencyBlocked(node.dependencyKeys, statusByKey)) {
-                statusByKey.set(node.key, "BLOCKED");
-                results.push({ target: node.target, type: node.type, status: "BLOCKED", errors: [] });
-                continue;
+            actionsByType[action.type].push(action);
+        });
+        const datasetActions = actionsByType.table;
+        if (datasetActions && datasetActions.length) {
+            writeStdOut(`${datasetActions.length} dataset(s):`);
+            datasetActions.forEach(datasetAction => writeStdOut(datasetString(datasetAction.target, datasetAction.type, datasetAction.tasks.length === 0), 1));
+        }
+        const assertionActions = actionsByType.assertion;
+        if (assertionActions && assertionActions.length) {
+            writeStdOut(`${assertionActions.length} assertion(s):`);
+            assertionActions.forEach(assertionAction => writeStdOut(assertionString(assertionAction.target, assertionAction.tasks.length === 0), 1));
+        }
+        const operationActions = actionsByType.operation;
+        if (operationActions && operationActions.length) {
+            writeStdOut(`${operationActions.length} operation(s):`);
+            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;
+                }
             }
-            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 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;
                 }
-                catch (e) {
+                case "operation": {
+                    writeStdErr(`${errorOutput("Operation failed: ")} ${operationString(executionAction.target, executionAction.tasks.length === 0)}${executionSuffix}`);
+                    break;
                 }
             }
+            printExecutedActionErrors(executedAction, executionAction);
+            return;
         }
-    }
-    finally {
-        if (!options.keepShadow) {
-            for (const schema of shadowSchemas.slice().reverse()) {
-                try {
-                    await deps.execute(deps.dropSchemaCascadeSql(schema));
+        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;
                 }
-                catch (e) {
+                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;
         }
-    }
-    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"
+        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;
                 }
-                : 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);
+                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;
         }
-        return new SupabaseDbAdapter(queryExecutor);
     }
-    constructor(queryExecutor) {
-        super(queryExecutor);
+}
+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));
     }
-    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;
-        }
+    if (needsFormattingResults.length > 0) {
+        printError("Files that need formatting:");
+        needsFormattingResults.forEach(result => writeStdErr(result.filename, 1));
     }
-    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;
-        }
+    if (failedFormatResults.length > 0) {
+        printError("Errors encountered during formatting:");
+        failedFormatResults.forEach(result => writeStdOut(`${result.filename}: ${result.err.message}`, 1));
     }
 }
-
-function actuallyResolve(...filePaths) {
-    return path__namespace.resolve(...filePaths.map(filePath => untildify__default["default"](filePath)));
+function datasetString(target, datasetType, disabled) {
+    return `${targetString(target)} [${datasetType}]${disabled ? " [disabled]" : ""}`;
 }
-function assertPathExists(checkPath) {
-    if (!fs__namespace$1.existsSync(checkPath)) {
-        throw new Error(`${checkPath} does not exist!`);
-    }
+function assertionString(target, disabled) {
+    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
 }
-function compiledGraphHasErrors(graph) {
-    var _a, _b;
-    return ((_b = (_a = graph.graphErrors) === null || _a === void 0 ? void 0 : _a.compilationErrors) === null || _b === void 0 ? void 0 : _b.length) > 0;
+function operationString(target, disabled) {
+    return `${targetString(target)}${disabled ? " [disabled]" : ""}`;
 }
-function formatExecutionSuffix(jobIds, bytesBilled) {
-    const jobMetadataParts = [];
-    if (jobIds.length > 0) {
-        jobMetadataParts.push(`\n \t jobId: ${jobIds.join(", ")}`);
-    }
-    if (bytesBilled.length > 0) {
-        jobMetadataParts.push(`\n \t Bytes billed: ${bytesBilled.join(", ")}`);
-    }
-    return jobMetadataParts.length > 0 ? ` ${jobMetadataParts}` : "";
+function plainTargetString(target) {
+    return `${target.schema}.${target.name}`;
 }
-function formatBytesInHumanReadableFormat(bytes) {
-    if (bytes <= 0) {
-        return '0 B';
-    }
-    const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'];
-    const k = 1024;
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    const value = (bytes / Math.pow(k, i)).toFixed(2);
-    return `${value} ${units[i]}`;
+function targetString(target) {
+    return calloutOutput(`${target.schema}.${target.name}`);
 }
-function promptForIcebergConfig() {
-    print(ICEBERG_CONFIG_PROMPT_TEXT);
-    print(ICEBERG_CONFIG_PROMPT_HINT);
-    const tempIcebergConfig = {};
-    let bucketName;
-    while (true) {
-        print(ICEBERG_BUCKET_NAME_HINT);
-        bucketName = interactiveQuestion(ICEBERG_BUCKET_NAME_PROMPT_QUESTION);
-        try {
-            if (bucketName) {
-                validateIcebergConfigBucketName(bucketName);
-                tempIcebergConfig.bucketName = bucketName;
-            }
-            break;
-        }
-        catch (e) {
-            printError(`Validation Error: ${e.message}`);
-            print("Please try again.");
-        }
-    }
-    let tableFolderRoot;
-    while (true) {
-        print(ICEBERG_TABLE_FOLDER_ROOT_HINT);
-        tableFolderRoot = interactiveQuestion(ICEBERG_TABLE_FOLDER_ROOT_PROMPT_QUESTION);
-        try {
-            if (tableFolderRoot) {
-                validateIcebergConfigTableFolderRoot(tableFolderRoot);
-                tempIcebergConfig.tableFolderRoot = tableFolderRoot;
-            }
-            break;
-        }
-        catch (e) {
-            printError(`Validation Error: ${e.message}`);
-            print("Please try again.");
-        }
-    }
-    let tableFolderSubpath;
-    while (true) {
-        print(ICEBERG_TABLE_FOLDER_ROOT_SUBPATH_HINT);
-        tableFolderSubpath = interactiveQuestion(ICEBERG_TABLE_FOLDER_SUBPATH_PROMPT_QUESTION);
-        try {
-            if (tableFolderSubpath) {
-                validateIcebergConfigTableFolderSubpath(tableFolderSubpath);
-                tempIcebergConfig.tableFolderSubpath = tableFolderSubpath;
-            }
-            break;
-        }
-        catch (e) {
-            printError(`Validation Error: ${e.message}`);
-            print("Please try again.");
-        }
-    }
-    let connection;
-    while (true) {
-        print(ICEBERG_CONNECTION_HINT);
-        connection = interactiveQuestion(ICEBERG_CONNECTION_QUESTION);
-        try {
-            if (connection) {
-                validateConnectionFormat(connection);
-                tempIcebergConfig.connection = connection;
-            }
-            break;
-        }
-        catch (e) {
-            printError(`Validation Error: ${e.message}`);
-            print("Please try again.");
+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.");
     }
-    printSuccess(ICEBERG_CONFIG_COLLECTED_TEXT);
-    if (Object.keys(tempIcebergConfig).length > 0) {
-        return tempIcebergConfig;
-    }
-    return undefined;
+    throw new Error(`No answer provided for: ${question}`);
 }
-function validateIcebergConfigBucketName(bucketName) {
-    if (bucketName.length < 3 || bucketName.length > 63) {
-        throw new Error("Bucket name must be between 3 and 63 characters long.");
-    }
-    if (!/^[a-z0-9][a-z0-9-._]{1,220}[a-z0-9]$/.test(bucketName) || bucketName.includes("..")) {
-        throw new Error("Invalid bucket name. Must start and end with a letter or number, contain only lowercase letters, numbers, hyphens (-), underscores (_), and periods (.).");
-    }
-    if (bucketName.startsWith("goog") || bucketName.includes("--")) {
-        throw new Error("Bucket name cannot start with 'goog' or contain '--'.");
-    }
-    if (bucketName.includes("google") || bucketName.includes("g00gle")) {
-        throw new Error("Bucket name cannot contain 'google' or close misspellings such as 'g00gle'.");
+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 validateIcebergConfigTableFolderRoot(tableFolderRoot) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9-._]{1,220}[a-zA-Z0-9]$/.test(tableFolderRoot) || tableFolderRoot.includes("..")) {
-        throw new Error("Invalid input. Must start and end with a letter or number, contain only letters (a-z, A-Z), numbers, hyphens (-), underscores (_), and periods (.).");
+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 validateIcebergConfigTableFolderSubpath(tableFolderSubpath) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9-._/]{1,220}[a-zA-Z0-9]$/.test(tableFolderSubpath) || tableFolderSubpath.includes("..")) {
-        throw new Error("Invalid input. Must start and end with a letter or number, contain only letters (a-z, A-Z), numbers, hyphens (-), underscores (_), periods (.), and forward slashes (/). The sequence '..' is also disallowed.");
+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.");
     }
-    if (tableFolderSubpath.includes("./") || tableFolderSubpath.includes("../")) {
-        throw new Error("Input cannot contain './' or '../'.");
+    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`;
 }
-const ICEBERG_BUCKET_NAME_HINT = "The bucket name must comply with https://cloud.google.com/storage/docs/buckets#naming. If you do not want to provide a workflow-level default bucket name, leave this input empty.\n";
-const ICEBERG_TABLE_FOLDER_ROOT_HINT = "Table folder root must start and end with a letter or a number. It can only contain letters, numbers, hyphens, underscores and periods. If you do not want to provide a workflow_level default table folder root, leave this input empty.\n";
-const ICEBERG_TABLE_FOLDER_ROOT_SUBPATH_HINT = "Table folder subpath must start and end with a letter or a number. It can only contain letters, numbers, hyphens, underscores, periods and forward slashes. If you do not want to provide a workflow_level default table folder subpath, leave this input empty.\n";
-const ICEBERG_CONFIG_PROMPT_HINT = "Set repository-level configuration for Iceberg bucket name, table folder root,  table folder subpath and connection. If you do not want to set a field, enter an empty string in response to the prompt.\n";
-const ICEBERG_CONFIG_PROMPT_TEXT = "\n--- Iceberg Configuration ---\n";
-const ICEBERG_CONFIG_COLLECTED_TEXT = "Iceberg configuration collected.\n";
-const ICEBERG_BUCKET_NAME_PROMPT_QUESTION = "Enter the default Iceberg bucket name:";
-const ICEBERG_TABLE_FOLDER_ROOT_PROMPT_QUESTION = "Enter the default Iceberg table folder root:";
-const ICEBERG_TABLE_FOLDER_SUBPATH_PROMPT_QUESTION = "Enter the default Iceberg table folder subpath:";
-const ICEBERG_CONNECTION_HINT = "The connection can have the form `{project}.{location}.{connection_id}` or `projects/{project}/locations/{location}/connections/{connection_id} or be set to DEFAULT. If you do not want to provide a workflow-level default connection, leave this input empty.\n";
-const ICEBERG_CONNECTION_QUESTION = "Enter the default connection:";
-
-const noColor = process.env.NO_COLOR && ["1", "true", "yes"].includes(process.env.NO_COLOR.toLowerCase());
-const ansiColorCodes = Object.freeze({
-    red: 91,
-    green: 32,
-    yellow: 93,
-    cyan: 36
-});
-function output(text, ansiColorCode) {
-    if (noColor) {
-        return text;
+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;
     }
-    return `\x1b[${ansiColorCode}m${text}\x1b[0m`;
+    const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    fs__namespace$1.writeFileSync(gitignorePath, `${existing}${separator}.df-credentials*.json\n`);
 }
-const successOutput = (text) => output(text, ansiColorCodes.green);
-const warningOutput = (text) => output(text, ansiColorCodes.yellow);
-const errorOutput = (text) => output(text, ansiColorCodes.red);
-const calloutOutput = (text) => output(text, ansiColorCodes.cyan);
-const write = (stream, text, indentCount) => stream.write(`${"  ".repeat(indentCount)}${text}\n`);
-const writeStdOut = (text, indentCount = 0) => write(process.stdout, text, indentCount);
-const writeStdErr = (text, indentCount = 0) => write(process.stderr, text, indentCount);
-const DEFAULT_PROMPT = "> ";
-function question(questionText) {
-    return prompt(questionText);
+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;
 }
-function interactiveQuestion(questionText) {
-    if (!process.stdin.isTTY && process.env.DATAFORM_CLI_TEST_INPUTS !== undefined) {
-        const testInput = getTestInput(questionText);
-        print(`${questionText} ${testInput}\n`);
-        return testInput;
+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)`);
     }
-    print(`${questionText} `);
-    return readlineSync__namespace.question("");
+    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;
 }
-function getTestInput(questionText) {
-    const envVar = process.env.DATAFORM_CLI_TEST_INPUTS;
-    if (!envVar) {
-        throw new Error("Environment variable DATAFORM_CLI_TEST_INPUTS not set.");
+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;
     }
-    try {
-        const parsed = JSON.parse(envVar);
-        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-            const inputs = new Map(Object.entries(parsed).map(([key, value]) => [key, String(value)]));
-            const trimmedQuestion = questionText.trim();
-            const answer = inputs.get(trimmedQuestion);
-            if (answer !== undefined) {
-                print(`[TEST_INPUT for "${trimmedQuestion}"]: "${answer}"`);
-                return answer;
-            }
-            else {
-                throw new Error(`[MISSING TEST_INPUT for "${trimmedQuestion}"]`);
-            }
+    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 {
-            throw new Error(`Failed to parse DATAFORM_CLI_TEST_INPUTS: Expected a JSON object, but got ${typeof parsed}.`);
+            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) {
-        throw new Error(`Failed to parse DATAFORM_CLI_TEST_INPUTS: ${e.message || e}`);
+        return [failure(e.message)];
     }
-}
-function selectionQuestion(questionText, options) {
-    return readlineSync__namespace.keyInSelect(options, `${questionText}\n`, {
-        cancel: false
-    });
-}
-function prompt(questionText, options) {
-    writeStdOut(questionText);
-    return readlineSync__namespace.prompt(Object.assign(Object.assign({}, options), { prompt: (options && options.prompt && options.prompt + DEFAULT_PROMPT) || DEFAULT_PROMPT }));
-}
-function print(text) {
-    writeStdOut(text);
-}
-function printSuccess(text) {
-    writeStdOut(successOutput(text));
-}
-function printError(errorText, indentCount = 0) {
-    writeStdErr(errorOutput(errorText), indentCount);
-}
-function printInitResult(result) {
-    if (result.dirsCreated && result.dirsCreated.length) {
-        writeStdOut(successOutput("Directories successfully created:"));
-        result.dirsCreated.forEach(dir => writeStdOut(dir, 1));
+    let stdout;
+    try {
+        stdout = await checkerExec(interpreter, ["-c", CHECKER_SOURCE, script.scriptFilename, script.depsFile || "", script.runtimeVersion || ""], projectDir);
     }
-    if (result.filesWritten && result.filesWritten.length) {
-        writeStdOut(successOutput("Files successfully written:"));
-        result.filesWritten.forEach(file => writeStdOut(file, 1));
+    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 printInitCredsResult(writtenFilePath) {
-    writeStdOut(successOutput("Credentials file successfully written:"));
-    writeStdOut(writtenFilePath, 1);
-    writeStdOut("To change connection settings, edit this file directly.");
-}
-function isInteractive({ stream = process.stdout } = {}) {
-    return Boolean(stream && stream.isTTY &&
-        process.env.TERM !== 'dumb' &&
-        !('CI' in process.env));
+
+function targetKey(target) {
+    return [target.database, target.schema, target.name].filter(Boolean).join(".");
 }
-var compiledGraphOutputType;
-(function (compiledGraphOutputType) {
-    compiledGraphOutputType["Json"] = "json";
-    compiledGraphOutputType["Dot"] = "dot";
-    compiledGraphOutputType["Summary"] = "summary";
-})(compiledGraphOutputType || (compiledGraphOutputType = {}));
-function printCompiledGraph(graph, outputType, quietCompilation) {
-    const interactive = isInteractive();
-    if (outputType === compiledGraphOutputType.Json) {
-        writeStdOut(prettyJsonStringify(graph));
-    }
-    else if (outputType === compiledGraphOutputType.Dot) {
-        writeStdOut(dotRepresentation(graph, interactive));
+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));
+        }
     }
-    else {
-        const actionCount = 0 +
-            (graph.tables ? graph.tables.length : 0) +
-            (graph.assertions ? graph.assertions.length : 0) +
-            (graph.operations ? graph.operations.length : 0);
-        writeStdOut(successOutput(`Compiled ${actionCount} action(s).`));
-        if (graph.tables && graph.tables.length) {
-            graph.tables.forEach(setOrValidateTableEnumType);
-            writeStdOut(`${graph.tables.length} dataset(s)${quietCompilation ? "." : ":"}`);
-            if (!quietCompilation) {
-                graph.tables.forEach(compiledTable => {
-                    writeStdOut(`${datasetString(compiledTable.target, tableTypeEnumToString(compiledTable.enumType), compiledTable.disabled)}`, 1);
-                });
-            }
+    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;
         }
-        if (graph.assertions && graph.assertions.length) {
-            writeStdOut(`${graph.assertions.length} assertion(s)${quietCompilation ? "." : ":"}`);
-            if (!quietCompilation) {
-                graph.assertions.forEach(assertion => {
-                    writeStdOut(assertionString(assertion.target, assertion.disabled), 1);
-                });
+        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 (graph.operations && graph.operations.length) {
-            writeStdOut(`${graph.operations.length} operation(s)${quietCompilation ? "." : ":"}`);
-            if (!quietCompilation) {
-                graph.operations.forEach(operation => {
-                    writeStdOut(operationString(operation.target, operation.disabled), 1);
-                });
+    }
+    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 formatStackTraceForQuietCompilation(compileError) {
-    var _a, _b;
-    if ((_a = compileError === null || compileError === void 0 ? void 0 : compileError.message) === null || _a === void 0 ? void 0 : _a.includes("Unexpected identifier")) {
-        if (!compileError.stack) {
-            return "";
+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) {
+            }
         }
-        const stackLines = ((_b = compileError.stack) === null || _b === void 0 ? void 0 : _b.split("\n")) || [];
-        return stackLines.slice(0, Math.min(3, stackLines.length)).join("\n");
     }
-    return "";
-}
-function printCompiledGraphErrors(graphErrors, quietCompilation) {
-    if (graphErrors.compilationErrors && graphErrors.compilationErrors.length > 0) {
-        printError("Compilation errors:", 1);
-        graphErrors.compilationErrors.forEach(compileError => {
-            writeStdErr(`${calloutOutput(compileError.fileName)}: ${errorOutput(quietCompilation ? (compileError.message + " " + formatStackTraceForQuietCompilation(compileError) || compileError.stack) : (compileError.stack || compileError.message))}`, 1);
-        });
+    catch (e) {
     }
 }
-function printTestResult(testResult) {
-    writeStdOut(`${testResult.name}: ${testResult.successful ? successOutput("passed") : errorOutput("failed")}`);
-    if (!testResult.successful) {
-        testResult.messages.forEach(message => writeStdErr(message, 1));
+function tableType(enumType) {
+    switch (enumType) {
+        case sqlanvil.TableType.VIEW:
+            return "view";
+        case sqlanvil.TableType.INCREMENTAL:
+            return "incremental";
+        default:
+            return "table";
     }
 }
-function printExecutionGraph(executionGraph, asJson) {
-    if (asJson) {
-        writeStdOut(prettyJsonStringify(executionGraph.toJSON()));
+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 {
-        const actionsByType = {
-            table: [],
-            assertion: [],
-            operation: []
-        };
-        executionGraph.actions.forEach(action => {
-            if (!(action.type === "table" || action.type === "assertion" || action.type === "operation")) {
-                throw new Error(`Unrecognized action type: ${action.type}`);
-            }
-            actionsByType[action.type].push(action);
+    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
         });
-        const datasetActions = actionsByType.table;
-        if (datasetActions && datasetActions.length) {
-            writeStdOut(`${datasetActions.length} dataset(s):`);
-            datasetActions.forEach(datasetAction => writeStdOut(datasetString(datasetAction.target, datasetAction.type, datasetAction.tasks.length === 0), 1));
+    }
+    for (const operation of compiledGraph.operations || []) {
+        if (!operation.target) {
+            continue;
         }
-        const assertionActions = actionsByType.assertion;
-        if (assertionActions && assertionActions.length) {
-            writeStdOut(`${assertionActions.length} assertion(s):`);
-            assertionActions.forEach(assertionAction => writeStdOut(assertionString(assertionAction.target, assertionAction.tasks.length === 0), 1));
+        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;
         }
-        const operationActions = actionsByType.operation;
-        if (operationActions && operationActions.length) {
-            writeStdOut(`${operationActions.length} operation(s):`);
-            operationActions.forEach(operationAction => writeStdOut(operationString(operationAction.target, operationAction.tasks.length === 0), 1));
+        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
+        });
     }
-}
-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;
-                }
-            }
+    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() {
@@ -56587,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",
@@ -56836,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.`);
                         }
@@ -56853,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") {
@@ -56875,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;
                 }
@@ -57461,13 +57713,7 @@ function runCli() {
                         srcDir: argv["source-dir"],
                         outDir: argv["out-dir"]
                     });
-                    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(argv["out-dir"], "migration-report.md")}`);
+                    printMigrationSummary(report, argv["out-dir"]);
                     print(`Next: sqlanvil compile ${argv["out-dir"]}`);
                     return 0;
                 }