@fabricorg/databricks-testkit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1152 @@
+'use strict';
+
+var databricks = require('@fabric-harness/databricks');
+var promises = require('fs/promises');
+var path = require('path');
+var experimentsDbPool = require('@fabricorg/experiments-db-pool');
+var crypto = require('crypto');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/fixtures.ts
+function parseFixtureColumns(schema) {
+  const columns = [];
+  let depth = 0;
+  let current = "";
+  const parts = [];
+  for (const ch of schema) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    const match = trimmed.match(/^("([^"]+)"|`([^`]+)`|(\w+))\s+(.+)$/s);
+    if (!match) throw new Error(`Unparseable fixture column: '${trimmed}'`);
+    columns.push({
+      name: match[2] ?? match[3] ?? match[4] ?? "",
+      type: (match[5] ?? "").trim()
+    });
+  }
+  if (columns.length === 0) throw new Error("Fixture schema declared no columns");
+  return columns;
+}
+async function resolveFixtureRows(fixture, columns) {
+  const raw = [...fixture.rows ?? []];
+  if (fixture.ndjsonFile) {
+    const fs = await import('fs/promises');
+    const text = await fs.readFile(fixture.ndjsonFile, "utf8");
+    for (const line of text.split("\n")) {
+      if (line.trim().length === 0) continue;
+      raw.push(JSON.parse(line));
+    }
+  }
+  return raw.map((row) => {
+    if (Array.isArray(row)) {
+      if (row.length !== columns.length) {
+        throw new Error(
+          `Fixture row for ${fixture.table} has ${row.length} values, expected ${columns.length}`
+        );
+      }
+      return [...row];
+    }
+    const record = row;
+    return columns.map((c) => c.name in record ? record[c.name] : null);
+  });
+}
+var init_fixtures = __esm({
+  "src/fixtures.ts"() {
+  }
+});
+
+// src/duckdb-context.ts
+var duckdb_context_exports = {};
+__export(duckdb_context_exports, {
+  createDuckDbContext: () => createDuckDbContext,
+  normalizeRow: () => normalizeRow
+});
+async function createDuckDbContext(options = {}) {
+  const factory = options.connectionFactory ?? defaultConnectionFactory;
+  const conn = await factory(options.path ?? ":memory:");
+  const schema = options.schema;
+  if (schema) await conn.run(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+  const qual = (table) => schema ? `${schema}.${table}` : table;
+  return {
+    profile: "local",
+    qual,
+    async exec(sql, params) {
+      await conn.run(sql, params ? [...params] : void 0);
+    },
+    async query(sql, params) {
+      const reader = await conn.runAndReadAll(sql, params ? [...params] : void 0);
+      return reader.getRowObjects().map(normalizeRow);
+    },
+    async loadFixture(fixture) {
+      if (fixture.schema) {
+        const columns2 = parseFixtureColumns(fixture.schema);
+        const ddl = columns2.map((c) => `"${c.name}" ${portableType(c.type)}`).join(", ");
+        await conn.run(`CREATE TABLE IF NOT EXISTS ${qual(fixture.table)} (${ddl})`);
+        const rows2 = await resolveFixtureRows(fixture, columns2);
+        for (const row of rows2) {
+          const casts = columns2.map((c) => isTimestamp(c.type) ? "CAST(? AS TIMESTAMP)" : "?").join(", ");
+          await conn.run(`INSERT INTO ${qual(fixture.table)} VALUES (${casts})`, row);
+        }
+        return;
+      }
+      const described = await conn.runAndReadAll(`DESCRIBE ${qual(fixture.table)}`);
+      const columns = described.getRowObjects().map((r) => ({ name: String(r.column_name), type: String(r.column_type) }));
+      const rows = await resolveFixtureRows(fixture, columns);
+      for (const row of rows) {
+        const casts = columns.map((c) => isTimestamp(c.type) ? "CAST(? AS TIMESTAMP)" : "?").join(", ");
+        await conn.run(`INSERT INTO ${qual(fixture.table)} VALUES (${casts})`, row);
+      }
+    },
+    async close() {
+      conn.closeSync();
+    }
+  };
+}
+function portableType(type) {
+  return type.replace(/\bSTRING\b/gi, "VARCHAR");
+}
+function isTimestamp(type) {
+  return /TIMESTAMP/i.test(type);
+}
+function normalizeRow(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    out[key] = normalizeValue(value);
+  }
+  return out;
+}
+function normalizeValue(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(-Number.MAX_SAFE_INTEGER)) {
+      return value.toString();
+    }
+    return Number(value);
+  }
+  if (value !== null && typeof value === "object") {
+    const v = value;
+    if (typeof v.micros === "bigint") {
+      const millis = Number(v.micros / 1000n);
+      return new Date(millis).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    }
+    if (typeof v.scale === "number" && typeof v.value === "bigint") {
+      return Number(v.value) / 10 ** v.scale;
+    }
+    return String(value);
+  }
+  return value;
+}
+async function defaultConnectionFactory(path) {
+  const moduleName = "@duckdb/node-api";
+  let mod;
+  try {
+    mod = await import(moduleName);
+  } catch {
+    throw new Error(
+      "createDuckDbContext requires the optional peer @duckdb/node-api \u2014 run: pnpm add -D @duckdb/node-api"
+    );
+  }
+  const instance = await mod.DuckDBInstance.create(path);
+  return await instance.connect();
+}
+var init_duckdb_context = __esm({
+  "src/duckdb-context.ts"() {
+    init_fixtures();
+  }
+});
+
+// src/workspace-context.ts
+var workspace_context_exports = {};
+__export(workspace_context_exports, {
+  createClientFromEnv: () => createClientFromEnv,
+  createWorkspaceContext: () => createWorkspaceContext,
+  parseStatementRows: () => parseStatementRows,
+  resolveTokenProvider: () => resolveTokenProvider,
+  toNamedParameters: () => toNamedParameters
+});
+async function createWorkspaceContext(options = {}) {
+  const env = options.env ?? process.env;
+  const warehouseId = resolveWarehouseId(env);
+  const catalog = env.DBX_TEST_CATALOG;
+  const schema = options.schema ?? env.DBX_TEST_SCHEMA;
+  const client = options.client ?? createClientFromEnv(env, options.fetchImpl);
+  const fixtureTables = /* @__PURE__ */ new Set();
+  const qual = (table) => [catalog, schema, table].filter((part) => Boolean(part)).join(".");
+  async function run(sql, params) {
+    const { statement, parameters } = toNamedParameters(sql, params ?? []);
+    const submitted = await client.post("/api/2.0/sql/statements", {
+      statement,
+      warehouse_id: warehouseId,
+      ...catalog ? { catalog } : {},
+      ...schema ? { schema } : {},
+      ...parameters.length > 0 ? { parameters } : {},
+      wait_timeout: "30s",
+      on_wait_timeout: "CONTINUE"
+    });
+    options.onStatement?.({
+      sql,
+      ...submitted.statement_id ? { statementId: submitted.statement_id } : {}
+    });
+    const state = submitted.status?.state;
+    let terminal = submitted;
+    if (state !== "SUCCEEDED" && state !== "FAILED" && state !== "CANCELED" && state !== "CLOSED") {
+      terminal = await databricks.waitForDatabricksStatement(
+        client,
+        submitted.statement_id ?? "",
+        { pollIntervalMs: options.pollIntervalMs, timeoutMs: options.timeoutMs }
+      );
+    }
+    if (terminal.status?.state !== "SUCCEEDED") {
+      throw new Error(
+        `Databricks statement ${terminal.status?.state ?? "UNKNOWN"}: ${terminal.status?.error?.message ?? sql.slice(0, 200)}`
+      );
+    }
+    return terminal;
+  }
+  return {
+    profile: "live",
+    qual,
+    async exec(sql, params) {
+      await run(sql, params);
+    },
+    async query(sql, params) {
+      const response = await run(sql, params);
+      return parseStatementRows(response);
+    },
+    async loadFixture(fixture) {
+      if (!schema) {
+        throw new Error(
+          "Live fixtures require DBX_TEST_SCHEMA (or a schema option) so tests cannot replace unscoped tables"
+        );
+      }
+      if (!fixture.schema) {
+        throw new Error(
+          `Live fixtures require explicit column DDL for ${fixture.table} (schema inference is local-only)`
+        );
+      }
+      const columns = parseFixtureColumns(fixture.schema);
+      const ddl = columns.map((c) => `\`${c.name}\` ${c.type}`).join(", ");
+      const target = qual(fixture.table);
+      await run(`CREATE OR REPLACE TABLE ${target} (${ddl}) USING DELTA`);
+      fixtureTables.add(target);
+      const rows = await resolveFixtureRows(fixture, columns);
+      for (const row of rows) {
+        const placeholders = columns.map((c) => /TIMESTAMP/i.test(c.type) ? "CAST(? AS TIMESTAMP)" : "?").join(", ");
+        await run(`INSERT INTO ${qual(fixture.table)} VALUES (${placeholders})`, row);
+      }
+    },
+    async close() {
+      if (options.cleanupFixtures !== false && env.DBX_TEST_KEEP_FIXTURES !== "1") {
+        for (const table of [...fixtureTables].reverse()) {
+          await run(`DROP TABLE IF EXISTS ${table}`);
+        }
+      }
+      fixtureTables.clear();
+    }
+  };
+}
+function toNamedParameters(sql, params) {
+  let out = "";
+  let index = 0;
+  let quote = null;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (quote) {
+      out += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    if (ch === "?") {
+      index += 1;
+      out += `:p${index}`;
+      continue;
+    }
+    out += ch;
+  }
+  if (index !== params.length) {
+    throw new Error(`SQL has ${index} placeholders but ${params.length} params were provided`);
+  }
+  return {
+    statement: out,
+    parameters: params.map((value, i) => ({
+      name: `p${i + 1}`,
+      value: value === null || value === void 0 ? null : String(value)
+    }))
+  };
+}
+function parseStatementRows(response) {
+  const columns = [...response.manifest?.schema?.columns ?? []].sort(
+    (a, b) => (a.position ?? 0) - (b.position ?? 0)
+  );
+  const data = response.result?.data_array ?? [];
+  return data.map((tuple) => {
+    const row = {};
+    columns.forEach((column, i) => {
+      row[column.name] = convertValue(tuple[i] ?? null, column.type_name ?? "STRING");
+    });
+    return row;
+  });
+}
+function convertValue(value, typeName) {
+  if (value === null) return null;
+  if (NUMERIC_TYPES.test(typeName)) return Number(value);
+  if (/^BOOLEAN/i.test(typeName)) return value === "true";
+  return value;
+}
+function resolveWarehouseId(env) {
+  if (env.DATABRICKS_WAREHOUSE_ID) return env.DATABRICKS_WAREHOUSE_ID;
+  const httpPath = env.DATABRICKS_HTTP_PATH;
+  const match = httpPath?.match(/\/warehouses\/([\w-]+)/);
+  if (match?.[1]) return match[1];
+  throw new Error(
+    "Live profile requires DATABRICKS_WAREHOUSE_ID or DATABRICKS_HTTP_PATH (/sql/1.0/warehouses/<id>)"
+  );
+}
+function createClientFromEnv(env, fetchImpl) {
+  const host = env.DATABRICKS_HOST;
+  if (!host) throw new Error("Live profile requires DATABRICKS_HOST");
+  return new databricks.DatabricksRestClient({
+    host,
+    token: resolveTokenProvider(host, env, fetchImpl),
+    ...fetchImpl ? { fetchImpl } : {}
+  });
+}
+function resolveTokenProvider(host, env, fetchImpl = fetch) {
+  if (env.DATABRICKS_BEARER) return env.DATABRICKS_BEARER;
+  const clientId = env.DATABRICKS_CLIENT_ID;
+  const clientSecret = env.DATABRICKS_CLIENT_SECRET;
+  if (clientId && clientSecret) {
+    let cached = null;
+    return async () => {
+      if (cached && Date.now() < cached.expiresAt) return cached.token;
+      const response = await fetchImpl(`${host.replace(/\/$/, "")}/oidc/v1/token`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/x-www-form-urlencoded",
+          authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`
+        },
+        body: new URLSearchParams({
+          grant_type: "client_credentials",
+          scope: env.DATABRICKS_SCOPE ?? "all-apis"
+        }).toString()
+      });
+      if (!response.ok) {
+        throw new Error(`OAuth M2M token exchange failed: ${response.status}`);
+      }
+      const body = await response.json();
+      cached = {
+        token: body.access_token,
+        expiresAt: Date.now() + ((body.expires_in ?? 3600) - 300) * 1e3
+      };
+      return body.access_token;
+    };
+  }
+  if (env.DATABRICKS_TOKEN) return env.DATABRICKS_TOKEN;
+  throw new Error(
+    "Live profile requires DATABRICKS_BEARER, DATABRICKS_CLIENT_ID/SECRET, or DATABRICKS_TOKEN"
+  );
+}
+var NUMERIC_TYPES;
+var init_workspace_context = __esm({
+  "src/workspace-context.ts"() {
+    init_fixtures();
+    NUMERIC_TYPES = /^(INT|LONG|SHORT|BYTE|FLOAT|DOUBLE|DECIMAL)/i;
+  }
+});
+
+// src/context.ts
+function resolveProfile(env = process.env) {
+  const profile = env.DBX_TEST_PROFILE ?? "local";
+  if (profile !== "local" && profile !== "live") {
+    throw new Error(`DBX_TEST_PROFILE must be 'local' or 'live', got '${profile}'`);
+  }
+  if (profile === "live" && env.DBX_TEST_LIVE !== "1") {
+    throw new Error(
+      "DBX_TEST_PROFILE=live requires DBX_TEST_LIVE=1 (live suites are always gated)"
+    );
+  }
+  return profile;
+}
+async function createExecutionContext(options = {}) {
+  const env = options.env ?? process.env;
+  const profile = options.profile ?? resolveProfile(env);
+  if (profile === "local") {
+    const { createDuckDbContext: createDuckDbContext2 } = await Promise.resolve().then(() => (init_duckdb_context(), duckdb_context_exports));
+    return createDuckDbContext2({ schema: options.schema });
+  }
+  const { createWorkspaceContext: createWorkspaceContext2 } = await Promise.resolve().then(() => (init_workspace_context(), workspace_context_exports));
+  return createWorkspaceContext2({
+    env,
+    schema: options.schema,
+    ...options.onStatement ? { onStatement: options.onStatement } : {}
+  });
+}
+
+// src/index.ts
+init_fixtures();
+init_duckdb_context();
+init_workspace_context();
+
+// src/golden.ts
+async function compareToGolden(goldenPath, actual, label, env = process.env) {
+  const fs = await import('fs/promises');
+  const serialized = `${JSON.stringify(actual, null, 2)}
+`;
+  if (env.DBX_TEST_UPDATE_GOLDEN === "1") {
+    const { dirname: dirname2 } = await import('path');
+    await fs.mkdir(dirname2(goldenPath), { recursive: true });
+    await fs.writeFile(goldenPath, serialized, "utf8");
+    return;
+  }
+  let expected;
+  try {
+    expected = await fs.readFile(goldenPath, "utf8");
+  } catch {
+    throw new Error(
+      `Golden file ${goldenPath} does not exist for ${label}. Run once with DBX_TEST_UPDATE_GOLDEN=1 to create it, then commit it.`
+    );
+  }
+  if (normalize(expected) !== normalize(serialized)) {
+    throw new Error(
+      `${label} diverges from golden ${goldenPath}.
+Expected:
+${expected}
+Actual:
+${serialized}
+If the change is intentional, re-run with DBX_TEST_UPDATE_GOLDEN=1 and commit the diff.`
+    );
+  }
+}
+function normalize(json) {
+  return JSON.stringify(JSON.parse(json));
+}
+
+// src/assert.ts
+function expectTable(ctx, table) {
+  const target = ctx.qual(table);
+  return {
+    async toHaveRowCount(expected) {
+      const rows = await ctx.query(`SELECT COUNT(*) AS n FROM ${target}`);
+      const actual = Number(rows[0]?.n ?? Number.NaN);
+      if (actual !== expected) {
+        throw new Error(`Expected ${target} to have ${expected} rows, found ${actual}`);
+      }
+    },
+    /** Every partial row must match at least one table row on its own keys. */
+    async toContainRows(partials) {
+      const rows = await ctx.query(`SELECT * FROM ${target}`);
+      for (const partial of partials) {
+        const hit = rows.some(
+          (row) => Object.entries(partial).every(([key, value]) => looselyEqual(row[key], value))
+        );
+        if (!hit) {
+          throw new Error(
+            `Expected ${target} to contain a row matching ${JSON.stringify(partial)}; have ${rows.length} rows: ${JSON.stringify(rows.slice(0, 5))}${rows.length > 5 ? " \u2026" : ""}`
+          );
+        }
+      }
+    },
+    /**
+     * Compare `SELECT * ORDER BY <orderBy>` against a committed golden JSON
+     * file. Set DBX_TEST_UPDATE_GOLDEN=1 to (re)write the golden instead —
+     * a reviewable, versioned event.
+     */
+    async toMatchGolden(goldenPath, options = {}) {
+      const orderBy = options.orderBy ? ` ORDER BY ${options.orderBy}` : "";
+      const rows = await ctx.query(`SELECT * FROM ${target}${orderBy}`);
+      await compareToGolden(goldenPath, rows, `table ${target}`);
+    }
+  };
+}
+async function expectQueryToMatchGolden(ctx, sql, params, goldenPath) {
+  const rows = await ctx.query(sql, params);
+  await compareToGolden(goldenPath, rows, "query");
+}
+function looselyEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) < 1e-9;
+  if (typeof a === "string" && typeof b === "string") {
+    return a.replace("T", " ").replace(/(\.\d+)?Z?$/, "") === b.replace("T", " ").replace(/(\.\d+)?Z?$/, "");
+  }
+  return false;
+}
+
+// src/mock-client.ts
+function createMockDatabricksClient() {
+  const queues = { GET: [], POST: [] };
+  const calls = [];
+  function take(method, path) {
+    const index = queues[method].findIndex((q) => path.startsWith(q.pathPrefix));
+    if (index === -1) {
+      throw new Error(
+        `MockDatabricksClient: no queued ${method} response for ${path}. Queued prefixes: ${queues[method].map((q) => q.pathPrefix).join(", ") || "(none)"}`
+      );
+    }
+    return queues[method].splice(index, 1)[0];
+  }
+  const client = {
+    async get(path, query) {
+      calls.push({ method: "GET", path, query });
+      const queued = take("GET", path);
+      if (queued.error) throw queued.error;
+      return queued.response;
+    },
+    async post(path, body, query) {
+      calls.push({ method: "POST", path, body, query });
+      const queued = take("POST", path);
+      if (queued.error) throw queued.error;
+      return queued.response;
+    },
+    queue(method, pathPrefix, response) {
+      queues[method].push({ pathPrefix, response });
+      return client;
+    },
+    queueError(method, pathPrefix, error) {
+      queues[method].push({ pathPrefix, error });
+      return client;
+    },
+    calls,
+    callsTo(method, pathPrefix) {
+      return calls.filter((c) => c.method === method && c.path.startsWith(pathPrefix));
+    }
+  };
+  return client;
+}
+
+// src/live-suite.ts
+init_workspace_context();
+function defineLiveSuite(spec) {
+  return { run: (runtime) => runLiveSuite(spec, runtime) };
+}
+async function runLiveSuite(spec, runtime = {}) {
+  const env = spec.env ?? process.env;
+  if (env.DBX_TEST_LIVE !== "1") return void 0;
+  const required2 = [...spec.required ?? []];
+  const known = new Set(spec.checks.map((check) => check.id));
+  for (const id of required2) {
+    if (!known.has(id)) throw new Error(`Required live check '${id}' is not defined`);
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const ownedWarehouse = runtime.warehouse === void 0;
+  const client = runtime.client ?? createClientFromEnv(env);
+  const warehouse = runtime.warehouse ?? await createWorkspaceContext({ env, client });
+  const results = [];
+  try {
+    for (const check of spec.checks) {
+      if (check.configured && !check.configured(env)) {
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "not-configured",
+          durationMs: 0
+        });
+        continue;
+      }
+      const before = performance.now();
+      try {
+        const details = await check.run({ env, warehouse, client });
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "pass",
+          durationMs: Math.round(performance.now() - before),
+          ...details === void 0 ? {} : { details: redactValue(details, env) }
+        });
+      } catch (error) {
+        results.push({
+          id: check.id,
+          description: check.description,
+          status: "fail",
+          durationMs: Math.round(performance.now() - before),
+          error: redactText(error instanceof Error ? error.message : String(error), env)
+        });
+      }
+    }
+  } finally {
+    if (ownedWarehouse) await warehouse.close();
+  }
+  const success = required2.every(
+    (id) => results.find((result) => result.id === id)?.status === "pass"
+  );
+  const evidence = {
+    schemaVersion: 1,
+    kind: "databricks-live-suite",
+    startedAt,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    success,
+    required: required2,
+    results
+  };
+  if (spec.evidencePath)
+    await writeReport(spec.evidencePath, `${JSON.stringify(evidence, null, 2)}
+`);
+  if (spec.junitPath) await writeReport(spec.junitPath, renderJUnit(evidence));
+  return evidence;
+}
+async function writeReport(path$1, contents) {
+  await promises.mkdir(path.dirname(path$1), { recursive: true });
+  await promises.writeFile(path$1, contents, "utf8");
+}
+function redactText(text, env) {
+  let output = text;
+  for (const [name, value] of Object.entries(env)) {
+    if (!value || value.length < 6 || !/(TOKEN|SECRET|PASSWORD|BEARER|KEY)/i.test(name)) continue;
+    output = output.split(value).join("[REDACTED]");
+  }
+  return output;
+}
+function redactValue(value, env) {
+  return JSON.parse(redactText(JSON.stringify(value), env));
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function renderJUnit(evidence) {
+  const failures = evidence.results.filter((result) => result.status === "fail").length;
+  const skipped = evidence.results.filter((result) => result.status === "not-configured").length;
+  const seconds = evidence.results.reduce((sum, result) => sum + result.durationMs, 0) / 1e3;
+  const cases = evidence.results.map((result) => {
+    const body = result.status === "fail" ? `<failure message="${xml(result.error ?? "check failed")}"/>` : result.status === "not-configured" ? '<skipped message="not configured"/>' : "";
+    return `  <testcase classname="databricks-live" name="${xml(result.id)}" time="${result.durationMs / 1e3}">${body}</testcase>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="databricks-live" tests="${evidence.results.length}" failures="${failures}" skipped="${skipped}" time="${seconds}">
+${cases}
+</testsuite>
+`;
+}
+
+// src/pollers.ts
+var TERMINAL_PIPELINE_STATES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELED"]);
+async function waitForPipelineUpdate(client, pipelineId, updateId, options = {}) {
+  const deadline = Date.now() + (options.timeoutMs ?? 9e5);
+  const interval = options.pollIntervalMs ?? 1e4;
+  const path = `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates/${encodeURIComponent(updateId)}`;
+  let update = await client.get(path);
+  while (!TERMINAL_PIPELINE_STATES.has(update.update?.state ?? "") && Date.now() < deadline) {
+    if (options.signal?.aborted) throw new Error(`Pipeline update ${updateId} was aborted`);
+    await abortableDelay(interval, options.signal);
+    update = await client.get(path);
+  }
+  const state = update.update?.state ?? "UNKNOWN";
+  if (state !== "COMPLETED") {
+    throw new Error(`Pipeline update ${updateId} ended in ${state} (wanted COMPLETED)`);
+  }
+  return update;
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Polling aborted"));
+      return;
+    }
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new Error("Polling aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/live-checks.ts
+function sqlRoundTripCheck() {
+  return {
+    id: "sql",
+    description: "SQL Statement Execution round-trip",
+    async run({ warehouse }) {
+      const rows = await warehouse.query("SELECT 1 AS dbx_test_ok");
+      if (Number(rows[0]?.dbx_test_ok) !== 1)
+        throw new Error("SQL round-trip returned an unexpected value");
+      return { rows: rows.length };
+    }
+  };
+}
+function assertDeltaContract(table, rows, columns) {
+  for (const expected of columns) {
+    const actual = rows.find((row) => String(row.col_name ?? row.column_name) === expected.name);
+    if (!actual) throw new Error(`Delta contract missing column '${expected.name}' in ${table}`);
+    const actualType = String(actual.data_type ?? actual.column_type ?? "").toLowerCase();
+    if (expected.type && actualType !== expected.type.toLowerCase()) {
+      throw new Error(
+        `Delta column ${expected.name} has type ${actualType}, expected ${expected.type}`
+      );
+    }
+  }
+}
+function deltaContractCheck(tableEnv = "DBX_TEST_DELTA_TABLE", columns = []) {
+  return {
+    id: "delta-contract",
+    description: "Delta table schema contract",
+    configured: (env) => Boolean(env[tableEnv]),
+    async run({ env, warehouse }) {
+      const table = env[tableEnv];
+      const rows = await warehouse.query(`DESCRIBE TABLE ${table}`);
+      assertDeltaContract(table, rows, columns);
+      return { table, columns: rows.length };
+    }
+  };
+}
+function unityCatalogAccessCheck() {
+  return {
+    id: "uc-grants",
+    description: "Unity Catalog allow/deny access assertions",
+    configured: (env) => Boolean(env.DBX_TEST_UC_ALLOWED_TABLE && env.DBX_TEST_UC_DENIED_TABLE),
+    async run({ env, warehouse }) {
+      await warehouse.query(`SELECT * FROM ${env.DBX_TEST_UC_ALLOWED_TABLE} LIMIT 1`);
+      try {
+        await warehouse.query(`SELECT * FROM ${env.DBX_TEST_UC_DENIED_TABLE} LIMIT 1`);
+      } catch (error) {
+        if (/permission.?denied|insufficient.?priv|403|unauthoriz/i.test(String(error))) {
+          return { allowed: env.DBX_TEST_UC_ALLOWED_TABLE, denied: env.DBX_TEST_UC_DENIED_TABLE };
+        }
+        throw error;
+      }
+      throw new Error(`Expected access to ${env.DBX_TEST_UC_DENIED_TABLE} to be denied`);
+    }
+  };
+}
+function jobRunCheck() {
+  return {
+    id: "jobs",
+    description: "Databricks Job run-now reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_JOB_ID),
+    async run({ env, client }) {
+      const jobId = Number(env.DBX_TEST_JOB_ID);
+      if (!Number.isFinite(jobId)) throw new Error("DBX_TEST_JOB_ID must be numeric");
+      const submitted = await client.post("/api/2.1/jobs/run-now", {
+        job_id: jobId
+      });
+      const run = await databricks.waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`Job ${jobId} ended in ${result ?? "UNKNOWN"}`);
+      return { jobId, runId: submitted.run_id };
+    }
+  };
+}
+function pipelineRefreshCheck() {
+  return {
+    id: "pipeline",
+    description: "Lakeflow telemetry pipeline refresh reaches COMPLETED",
+    configured: (env) => Boolean(env.DBX_TEST_PIPELINE_ID),
+    async run({ env, client }) {
+      const pipelineId = env.DBX_TEST_PIPELINE_ID;
+      const submitted = await client.post(
+        `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates`,
+        { full_refresh: false }
+      );
+      if (!submitted.update_id) {
+        throw new Error(`Pipeline ${pipelineId} did not return an update_id`);
+      }
+      await waitForPipelineUpdate(client, pipelineId, submitted.update_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      return { pipelineId, updateId: submitted.update_id };
+    }
+  };
+}
+function notebookSubmitCheck() {
+  return {
+    id: "notebook",
+    description: "Databricks notebook submit run reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_NOTEBOOK_PATH && env.DBX_TEST_CLUSTER_ID),
+    async run({ env, client }) {
+      if (!env.DBX_TEST_NOTEBOOK_PATH || !env.DBX_TEST_CLUSTER_ID) {
+        throw new Error("Notebook submit requires DBX_TEST_NOTEBOOK_PATH and DBX_TEST_CLUSTER_ID");
+      }
+      const submitted = await client.post("/api/2.1/jobs/runs/submit", {
+        run_name: `fabric-experiments-notebook-${Date.now()}`,
+        tasks: [
+          {
+            task_key: "notebook",
+            existing_cluster_id: env.DBX_TEST_CLUSTER_ID,
+            notebook_task: { notebook_path: env.DBX_TEST_NOTEBOOK_PATH }
+          }
+        ]
+      });
+      if (!submitted.run_id) throw new Error("Notebook submit returned no run_id");
+      const run = await databricks.waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`Notebook run ended in ${result ?? "UNKNOWN"}`);
+      return { runId: submitted.run_id, notebookPath: env.DBX_TEST_NOTEBOOK_PATH };
+    }
+  };
+}
+function dbtBuildCheck() {
+  return {
+    id: "dbt",
+    description: "Databricks dbt task reaches SUCCESS",
+    configured: (env) => Boolean(env.DBX_TEST_DBT_GIT_URL && env.DATABRICKS_WAREHOUSE_ID),
+    async run({ env, client }) {
+      if (!env.DBX_TEST_DBT_GIT_URL || !env.DATABRICKS_WAREHOUSE_ID) {
+        throw new Error("dbt build requires DBX_TEST_DBT_GIT_URL and DATABRICKS_WAREHOUSE_ID");
+      }
+      const submitted = await client.post("/api/2.1/jobs/runs/submit", {
+        run_name: `fabric-experiments-dbt-${Date.now()}`,
+        git_source: {
+          git_url: env.DBX_TEST_DBT_GIT_URL,
+          git_provider: env.DBX_TEST_DBT_GIT_PROVIDER ?? "gitHub",
+          git_branch: env.DBX_TEST_DBT_GIT_BRANCH ?? "main"
+        },
+        tasks: [
+          {
+            task_key: "dbt_build",
+            dbt_task: {
+              commands: ["dbt deps", "dbt build"],
+              warehouse_id: env.DATABRICKS_WAREHOUSE_ID,
+              ...env.DBX_TEST_DBT_PROJECT_DIR ? { project_directory: env.DBX_TEST_DBT_PROJECT_DIR } : {}
+            }
+          }
+        ]
+      });
+      if (!submitted.run_id) throw new Error("dbt submit returned no run_id");
+      const run = await databricks.waitForDatabricksRun(client, submitted.run_id, {
+        timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+        pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+      });
+      const result = run.state?.result_state;
+      if (result !== "SUCCESS") throw new Error(`dbt run ended in ${result ?? "UNKNOWN"}`);
+      return { runId: submitted.run_id, gitUrl: env.DBX_TEST_DBT_GIT_URL };
+    }
+  };
+}
+function customLiveCheck(id, description, run, configured) {
+  return { id, description, run, ...configured ? { configured } : {} };
+}
+
+// src/lakebase-checks.ts
+init_workspace_context();
+function required(env, name) {
+  const value = env[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+function createLakebaseTestProvider(env, options = {}) {
+  return new experimentsDbPool.LakebaseDatabaseProvider({
+    host: required(env, "DBX_TEST_LAKEBASE_HOST"),
+    database: required(env, "DBX_TEST_LAKEBASE_DATABASE"),
+    user: required(env, "DBX_TEST_LAKEBASE_USER"),
+    workspaceHost: required(env, "DATABRICKS_HOST"),
+    endpoint: required(env, "DBX_TEST_LAKEBASE_ENDPOINT"),
+    token: resolveTokenProvider(required(env, "DATABRICKS_HOST"), env, options.fetchImpl),
+    fetchImpl: options.fetchImpl,
+    poolFactory: options.poolFactory,
+    max: 1
+  });
+}
+async function workspaceToken(env, fetchImpl) {
+  const host = required(env, "DATABRICKS_HOST");
+  const provider = resolveTokenProvider(host, env, fetchImpl);
+  return typeof provider === "string" ? provider : provider();
+}
+function lakebaseCredentialCheck(options = {}) {
+  return {
+    id: "lakebase-credential",
+    description: "Lakebase OAuth credential exchange",
+    configured: (env) => Boolean(env.DBX_TEST_LAKEBASE_ENDPOINT),
+    async run({ env }) {
+      const credential = await experimentsDbPool.exchangeLakebaseCredential({
+        workspaceHost: required(env, "DATABRICKS_HOST"),
+        endpoint: required(env, "DBX_TEST_LAKEBASE_ENDPOINT"),
+        workspaceToken: await workspaceToken(env, options.fetchImpl),
+        fetchImpl: options.fetchImpl
+      });
+      if (credential.expiresAt <= Date.now()) {
+        throw new Error("Lakebase credential is already expired");
+      }
+      return { expiresAt: new Date(credential.expiresAt).toISOString() };
+    }
+  };
+}
+function lakebaseRoundTripCheck(options = {}) {
+  return {
+    id: "lakebase",
+    description: "Lakebase provider query and credential refresh round-trip",
+    configured: (env) => Boolean(
+      env.DBX_TEST_LAKEBASE_ENDPOINT && env.DBX_TEST_LAKEBASE_HOST && env.DBX_TEST_LAKEBASE_DATABASE && env.DBX_TEST_LAKEBASE_USER
+    ),
+    async run({ env }) {
+      const provider = createLakebaseTestProvider(env, options);
+      try {
+        const first = await provider.getPool().query("SELECT 1 AS dbx_test_ok");
+        if (Number(first.rows[0]?.dbx_test_ok) !== 1) {
+          throw new Error("Lakebase round-trip returned an unexpected value");
+        }
+        await provider.refreshCredentials();
+        const second = await provider.getPool().query("SELECT 1 AS dbx_test_ok");
+        if (Number(second.rows[0]?.dbx_test_ok) !== 1) {
+          throw new Error("Lakebase post-refresh round-trip returned an unexpected value");
+        }
+        return { queries: 2, refreshed: true };
+      } finally {
+        await provider.close();
+      }
+    }
+  };
+}
+
+// src/databricks-http.ts
+init_workspace_context();
+async function databricksFetch(env, pathOrUrl, init = {}, fetchImpl = fetch) {
+  const host = env.DATABRICKS_HOST?.replace(/\/$/, "");
+  if (!host) throw new Error("DATABRICKS_HOST is required");
+  const provider = resolveTokenProvider(host, env, fetchImpl);
+  const token = typeof provider === "string" ? provider : await provider();
+  const headers = new Headers(init.headers);
+  headers.set("authorization", `Bearer ${token}`);
+  const response = await fetchImpl(
+    /^https?:\/\//.test(pathOrUrl) ? pathOrUrl : `${host}${pathOrUrl}`,
+    {
+      ...init,
+      headers
+    }
+  );
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Databricks request failed: ${response.status} ${response.statusText}: ${body.slice(0, 500)}`
+    );
+  }
+  return response;
+}
+
+// src/platform-checks.ts
+function csv(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+function secretScopeCheck() {
+  return {
+    id: "secrets",
+    description: "Databricks secret scope contains expected keys",
+    configured: (env) => Boolean(env.DBX_TEST_SECRET_SCOPE && env.DBX_TEST_SECRET_KEYS),
+    async run({ env, client }) {
+      const scope = env.DBX_TEST_SECRET_SCOPE;
+      const expected = csv(env.DBX_TEST_SECRET_KEYS);
+      const response = await client.get("/api/2.0/secrets/list", {
+        scope
+      });
+      const actual = new Set((response.secrets ?? []).map((secret) => secret.key).filter(Boolean));
+      const missing = expected.filter((key) => !actual.has(key));
+      if (missing.length > 0) {
+        throw new Error(`Secret scope ${scope} is missing keys: ${missing.join(", ")}`);
+      }
+      return { scope, expectedKeys: expected.length };
+    }
+  };
+}
+function appHealthCheck(options = {}) {
+  return {
+    id: "app",
+    description: "Databricks App is running, bound, and healthy",
+    configured: (env) => Boolean(env.DBX_TEST_APP_NAME),
+    async run({ env, client }) {
+      const name = env.DBX_TEST_APP_NAME;
+      const app = await client.get(`/api/2.0/apps/${encodeURIComponent(name)}`);
+      if (app.app_status?.state !== "RUNNING") {
+        throw new Error(`Databricks App ${name} is ${app.app_status?.state ?? "UNKNOWN"}`);
+      }
+      const expected = csv(env.DBX_TEST_APP_RESOURCES);
+      const actual = new Set(
+        (app.resources ?? []).map((resource) => resource.name).filter(Boolean)
+      );
+      const missing = expected.filter((resource) => !actual.has(resource));
+      if (missing.length > 0) {
+        throw new Error(
+          `Databricks App ${name} is missing resource bindings: ${missing.join(", ")}`
+        );
+      }
+      const appUrl = env.DBX_TEST_APP_URL ?? app.url ?? app.app_url;
+      if (!appUrl) throw new Error(`Databricks App ${name} returned no URL`);
+      const healthUrl = new URL("/api/healthz", appUrl).toString();
+      const response = await databricksFetch(env, healthUrl, {}, options.fetchImpl);
+      const health = await response.json();
+      if (health.ok !== true && health.status !== "ok") {
+        throw new Error(`Databricks App ${name} health probe did not report ok`);
+      }
+      return { name, bindings: actual.size, health: "ok" };
+    }
+  };
+}
+function normalizeVolumeRoot(value) {
+  const normalized = value.replace(/\/$/, "");
+  if (!/^\/Volumes\/[^/]+\/[^/]+\/[^/]+$/.test(normalized)) {
+    throw new Error("DBX_TEST_VOLUME must be /Volumes/<catalog>/<schema>/<volume>");
+  }
+  return normalized;
+}
+async function ensureVolumeDirectory(env, directory, fetchImpl) {
+  await databricksFetch(env, `/api/2.0/fs/directories${directory}`, { method: "PUT" }, fetchImpl);
+}
+async function uploadVolumeFile(env, path, body, fetchImpl) {
+  await databricksFetch(
+    env,
+    `/api/2.0/fs/files${path}`,
+    { method: "PUT", body },
+    fetchImpl
+  );
+}
+async function deleteVolumeFile(env, path, fetchImpl) {
+  await databricksFetch(env, `/api/2.0/fs/files${path}`, { method: "DELETE" }, fetchImpl);
+}
+function volumeIOCheck(options = {}) {
+  return {
+    id: "volume-io",
+    description: "Unity Catalog volume Files API round-trip",
+    configured: (env) => Boolean(env.DBX_TEST_VOLUME),
+    async run({ env }) {
+      const root = normalizeVolumeRoot(env.DBX_TEST_VOLUME);
+      const prefix = (env.DBX_TEST_ENV_NAME ?? "fx-live").replace(/[^A-Za-z0-9_.-]/g, "_");
+      const id = (options.randomId ?? crypto.randomUUID)();
+      const directory = `${root}/${prefix}`;
+      const file = `${directory}/probe-${id}.txt`;
+      const filePath = `/api/2.0/fs/files${file}`;
+      const body = new TextEncoder().encode(`fabric-experiments-volume-probe:${id}`);
+      await ensureVolumeDirectory(env, directory, options.fetchImpl);
+      try {
+        await uploadVolumeFile(env, file, body, options.fetchImpl);
+        const downloaded = await databricksFetch(env, filePath, {}, options.fetchImpl);
+        const actual = new Uint8Array(await downloaded.arrayBuffer());
+        if (actual.length !== body.length || actual.some((value, index) => value !== body[index])) {
+          throw new Error("Volume round-trip returned different bytes");
+        }
+        return { volume: root, bytes: body.length };
+      } finally {
+        await deleteVolumeFile(env, file, options.fetchImpl).catch(() => void 0);
+      }
+    }
+  };
+}
+function autoLoaderIngestionCheck(options = {}) {
+  return {
+    id: "autoloader",
+    description: "Isolated Auto Loader fixture ingestion reaches Delta without rescued rows",
+    configured: (env) => Boolean(
+      env.DBX_TEST_AUTOLOADER_PIPELINE_ID && env.DBX_TEST_AUTOLOADER_TABLE && env.DBX_TEST_AUTOLOADER_FIXTURE && env.DBX_TEST_VOLUME
+    ),
+    async run({ env, client, warehouse }) {
+      const pipelineId = env.DBX_TEST_AUTOLOADER_PIPELINE_ID;
+      if (pipelineId === env.DBX_TEST_PIPELINE_ID) {
+        throw new Error("DBX_TEST_AUTOLOADER_PIPELINE_ID must not be the production pipeline");
+      }
+      const root = normalizeVolumeRoot(env.DBX_TEST_VOLUME);
+      const fixturePath = env.DBX_TEST_AUTOLOADER_FIXTURE;
+      const body = options.fixtureBody ?? new Uint8Array(await promises.readFile(path.resolve(fixturePath)));
+      const id = (options.randomId ?? crypto.randomUUID)();
+      const runName = (env.DBX_TEST_ENV_NAME ?? "autoloader").replace(/[^A-Za-z0-9_.-]/g, "_");
+      const directory = `${root}/exposures/${runName}/${id}`;
+      const destination = `${directory}/${path.basename(fixturePath)}`;
+      await ensureVolumeDirectory(env, directory, options.fetchImpl);
+      try {
+        await uploadVolumeFile(env, destination, body, options.fetchImpl);
+        const submitted = await client.post(
+          `/api/2.0/pipelines/${encodeURIComponent(pipelineId)}/updates`,
+          { full_refresh: true }
+        );
+        if (!submitted.update_id) throw new Error("Auto Loader pipeline returned no update_id");
+        await waitForPipelineUpdate(client, pipelineId, submitted.update_id, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+        const table = env.DBX_TEST_AUTOLOADER_TABLE;
+        const rows = await warehouse.query(
+          `SELECT COUNT(*) AS n, SUM(CASE WHEN _rescued_data IS NOT NULL THEN 1 ELSE 0 END) AS rescued FROM ${table}`
+        );
+        const count = Number(rows[0]?.n ?? 0);
+        const rescued = Number(rows[0]?.rescued ?? 0);
+        if (count < 1) throw new Error(`Auto Loader produced no rows in ${table}`);
+        if (rescued !== 0)
+          throw new Error(`Auto Loader produced ${rescued} rescued rows in ${table}`);
+        return { pipelineId, table, rows: count, rescued };
+      } finally {
+        await deleteVolumeFile(env, destination, options.fetchImpl).catch(() => void 0);
+      }
+    }
+  };
+}
+
+Object.defineProperty(exports, "waitForDatabricksRun", {
+  enumerable: true,
+  get: function () { return databricks.waitForDatabricksRun; }
+});
+Object.defineProperty(exports, "waitForDatabricksStatement", {
+  enumerable: true,
+  get: function () { return databricks.waitForDatabricksStatement; }
+});
+exports.appHealthCheck = appHealthCheck;
+exports.assertDeltaContract = assertDeltaContract;
+exports.autoLoaderIngestionCheck = autoLoaderIngestionCheck;
+exports.compareToGolden = compareToGolden;
+exports.createClientFromEnv = createClientFromEnv;
+exports.createDuckDbContext = createDuckDbContext;
+exports.createExecutionContext = createExecutionContext;
+exports.createLakebaseTestProvider = createLakebaseTestProvider;
+exports.createMockDatabricksClient = createMockDatabricksClient;
+exports.createWorkspaceContext = createWorkspaceContext;
+exports.customLiveCheck = customLiveCheck;
+exports.dbtBuildCheck = dbtBuildCheck;
+exports.defineLiveSuite = defineLiveSuite;
+exports.deleteVolumeFile = deleteVolumeFile;
+exports.deltaContractCheck = deltaContractCheck;
+exports.ensureVolumeDirectory = ensureVolumeDirectory;
+exports.expectQueryToMatchGolden = expectQueryToMatchGolden;
+exports.expectTable = expectTable;
+exports.jobRunCheck = jobRunCheck;
+exports.lakebaseCredentialCheck = lakebaseCredentialCheck;
+exports.lakebaseRoundTripCheck = lakebaseRoundTripCheck;
+exports.normalizeRow = normalizeRow;
+exports.normalizeVolumeRoot = normalizeVolumeRoot;
+exports.notebookSubmitCheck = notebookSubmitCheck;
+exports.parseFixtureColumns = parseFixtureColumns;
+exports.parseStatementRows = parseStatementRows;
+exports.pipelineRefreshCheck = pipelineRefreshCheck;
+exports.renderJUnit = renderJUnit;
+exports.resolveFixtureRows = resolveFixtureRows;
+exports.resolveProfile = resolveProfile;
+exports.resolveTokenProvider = resolveTokenProvider;
+exports.runLiveSuite = runLiveSuite;
+exports.secretScopeCheck = secretScopeCheck;
+exports.sqlRoundTripCheck = sqlRoundTripCheck;
+exports.toNamedParameters = toNamedParameters;
+exports.unityCatalogAccessCheck = unityCatalogAccessCheck;
+exports.uploadVolumeFile = uploadVolumeFile;
+exports.volumeIOCheck = volumeIOCheck;
+exports.waitForPipelineUpdate = waitForPipelineUpdate;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map