@fabricorg/databricks-testkit 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -600,15 +600,15 @@ function defineLiveSuite(spec) {
 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 required3 = [...spec.required ?? []];
   const known = new Set(spec.checks.map((check) => check.id));
-  for (const id of required2) {
+  for (const id of required3) {
     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 ?? (hasWarehouseConfig(env) ? await createWorkspaceContext({ env, client }) : unavailableWarehouseContext());
+  const warehouse2 = runtime.warehouse ?? (hasWarehouseConfig(env) ? await createWorkspaceContext({ env, client }) : unavailableWarehouseContext());
   const results = [];
   try {
     for (const check of spec.checks) {
@@ -623,7 +623,7 @@ async function runLiveSuite(spec, runtime = {}) {
       }
       const before = performance.now();
       try {
-        const details = await check.run({ env, warehouse, client });
+        const details = await check.run({ env, warehouse: warehouse2, client });
         results.push({
           id: check.id,
           description: check.description,
@@ -642,9 +642,9 @@ async function runLiveSuite(spec, runtime = {}) {
       }
     }
   } finally {
-    if (ownedWarehouse) await warehouse.close();
+    if (ownedWarehouse) await warehouse2.close();
   }
-  const success = required2.every(
+  const success = required3.every(
     (id) => results.find((result) => result.id === id)?.status === "pass"
   );
   const evidence = {
@@ -653,7 +653,7 @@ async function runLiveSuite(spec, runtime = {}) {
     startedAt,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
     success,
-    required: required2,
+    required: required3,
     results,
     ...spec.targetPack ? { targetPack: spec.targetPack } : {}
   };
@@ -756,8 +756,8 @@ function sqlRoundTripCheck() {
     id: "sql",
     description: "SQL Statement Execution round-trip",
     configured: (env) => Boolean(env.DATABRICKS_WAREHOUSE_ID || env.DATABRICKS_HTTP_PATH),
-    async run({ warehouse }) {
-      const rows = await warehouse.query("SELECT 1 AS dbx_test_ok");
+    async run({ warehouse: warehouse2 }) {
+      const rows = await warehouse2.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 };
@@ -801,9 +801,9 @@ function deltaContractCheck(tableEnv = "DBX_TEST_DELTA_TABLE", columns = []) {
     id: "delta-contract",
     description: "Delta table schema contract",
     configured: (env) => Boolean(env[tableEnv]),
-    async run({ env, warehouse }) {
+    async run({ env, warehouse: warehouse2 }) {
       const table = env[tableEnv];
-      const rows = await warehouse.query(`DESCRIBE TABLE ${table}`);
+      const rows = await warehouse2.query(`DESCRIBE TABLE ${table}`);
       assertDeltaContract(table, rows, columns);
       return { table, columns: rows.length };
     }
@@ -814,10 +814,10 @@ function unityCatalogAccessCheck() {
     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`);
+    async run({ env, warehouse: warehouse2 }) {
+      await warehouse2.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`);
+        await warehouse2.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 };
@@ -1282,7 +1282,7 @@ function autoLoaderIngestionCheck(options = {}) {
     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 }) {
+    async run({ env, client, warehouse: warehouse2 }) {
       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");
@@ -1307,7 +1307,7 @@ function autoLoaderIngestionCheck(options = {}) {
           pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
         });
         const table = env.DBX_TEST_AUTOLOADER_TABLE;
-        const rows = await warehouse.query(
+        const rows = await warehouse2.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);
@@ -1330,7 +1330,7 @@ function performanceBudgetCheck() {
     id: "performance",
     description: "SQL Statement Execution p95 stays within the configured latency budget",
     configured: (env) => Boolean(env.DBX_TEST_PERFORMANCE_P95_MS),
-    async run({ env, warehouse }) {
+    async run({ env, warehouse: warehouse2 }) {
       const budgetMs = Number(env.DBX_TEST_PERFORMANCE_P95_MS);
       const runs = Number(env.DBX_TEST_PERFORMANCE_RUNS ?? 7);
       if (!Number.isFinite(budgetMs) || budgetMs <= 0) {
@@ -1339,11 +1339,11 @@ function performanceBudgetCheck() {
       if (!Number.isInteger(runs) || runs < 3 || runs > 100) {
         throw new Error("DBX_TEST_PERFORMANCE_RUNS must be an integer from 3 to 100");
       }
-      await warehouse.query("SELECT 1 AS warmup");
+      await warehouse2.query("SELECT 1 AS warmup");
       const durations = [];
       for (let index = 0; index < runs; index += 1) {
         const started = performance.now();
-        await warehouse.query("SELECT 1 AS performance_probe");
+        await warehouse2.query("SELECT 1 AS performance_probe");
         durations.push(performance.now() - started);
       }
       durations.sort((left, right) => left - right);
@@ -1365,15 +1365,15 @@ function failureRecoveryCheck() {
     id: "failure-recovery",
     description: "A failed statement is isolated and a subsequent statement recovers",
     configured: (env) => Boolean(env.DATABRICKS_WAREHOUSE_ID || env.DATABRICKS_HTTP_PATH),
-    async run({ warehouse }) {
+    async run({ warehouse: warehouse2 }) {
       let failedAsExpected = false;
       try {
-        await warehouse.query("SELECT * FROM __fabric_experiments_expected_missing_table__");
+        await warehouse2.query("SELECT * FROM __fabric_experiments_expected_missing_table__");
       } catch {
         failedAsExpected = true;
       }
       if (!failedAsExpected) throw new Error("Injected failure unexpectedly succeeded");
-      const rows = await warehouse.query("SELECT 1 AS recovered");
+      const rows = await warehouse2.query("SELECT 1 AS recovered");
       if (Number(rows[0]?.recovered) !== 1) {
         throw new Error("Statement execution did not recover after the injected failure");
       }
@@ -1411,20 +1411,20 @@ function backupRestoreCheck() {
     id: "backup-restore",
     description: "Delta DEEP CLONE backup restores a dropped scratch table",
     configured: (env) => Boolean(env.DATABRICKS_WAREHOUSE_ID || env.DATABRICKS_HTTP_PATH),
-    async run({ warehouse }) {
-      const source = warehouse.qual(safeName("backup_source"));
-      const backup = warehouse.qual(safeName("backup_clone"));
+    async run({ warehouse: warehouse2 }) {
+      const source = warehouse2.qual(safeName("backup_source"));
+      const backup = warehouse2.qual(safeName("backup_clone"));
       try {
-        await warehouse.exec(`CREATE TABLE ${source} USING DELTA AS SELECT 7 AS value`);
-        await warehouse.exec(`CREATE TABLE ${backup} DEEP CLONE ${source}`);
-        await warehouse.exec(`DROP TABLE ${source}`);
-        await warehouse.exec(`CREATE TABLE ${source} DEEP CLONE ${backup}`);
-        const rows = await warehouse.query(`SELECT value FROM ${source}`);
+        await warehouse2.exec(`CREATE TABLE ${source} USING DELTA AS SELECT 7 AS value`);
+        await warehouse2.exec(`CREATE TABLE ${backup} DEEP CLONE ${source}`);
+        await warehouse2.exec(`DROP TABLE ${source}`);
+        await warehouse2.exec(`CREATE TABLE ${source} DEEP CLONE ${backup}`);
+        const rows = await warehouse2.query(`SELECT value FROM ${source}`);
         if (Number(rows[0]?.value) !== 7) throw new Error("Restored Delta table lost its data");
         return { restoredRows: rows.length, deepClone: true };
       } finally {
-        await warehouse.exec(`DROP TABLE IF EXISTS ${source}`).catch(() => void 0);
-        await warehouse.exec(`DROP TABLE IF EXISTS ${backup}`).catch(() => void 0);
+        await warehouse2.exec(`DROP TABLE IF EXISTS ${source}`).catch(() => void 0);
+        await warehouse2.exec(`DROP TABLE IF EXISTS ${backup}`).catch(() => void 0);
       }
     }
   };
@@ -1434,25 +1434,25 @@ function rollbackCheck() {
     id: "rollback",
     description: "Delta time-travel rollback restores a known-good table version",
     configured: (env) => Boolean(env.DATABRICKS_WAREHOUSE_ID || env.DATABRICKS_HTTP_PATH),
-    async run({ warehouse }) {
-      const table = warehouse.qual(safeName("rollback_probe"));
+    async run({ warehouse: warehouse2 }) {
+      const table = warehouse2.qual(safeName("rollback_probe"));
       try {
-        await warehouse.exec(`CREATE TABLE ${table} (value INT) USING DELTA`);
-        await warehouse.exec(`INSERT INTO ${table} VALUES (1)`);
-        const history = await warehouse.query(`DESCRIBE HISTORY ${table} LIMIT 1`);
+        await warehouse2.exec(`CREATE TABLE ${table} (value INT) USING DELTA`);
+        await warehouse2.exec(`INSERT INTO ${table} VALUES (1)`);
+        const history = await warehouse2.query(`DESCRIBE HISTORY ${table} LIMIT 1`);
         const knownGoodVersion = Number(history[0]?.version);
         if (!Number.isInteger(knownGoodVersion)) {
           throw new Error("Delta history did not return a known-good version");
         }
-        await warehouse.exec(`INSERT INTO ${table} VALUES (999)`);
-        await warehouse.exec(`RESTORE TABLE ${table} TO VERSION AS OF ${knownGoodVersion}`);
-        const rows = await warehouse.query(`SELECT value FROM ${table} ORDER BY value`);
+        await warehouse2.exec(`INSERT INTO ${table} VALUES (999)`);
+        await warehouse2.exec(`RESTORE TABLE ${table} TO VERSION AS OF ${knownGoodVersion}`);
+        const rows = await warehouse2.query(`SELECT value FROM ${table} ORDER BY value`);
         if (rows.length !== 1 || Number(rows[0]?.value) !== 1) {
           throw new Error("Delta rollback did not restore the known-good contents");
         }
         return { knownGoodVersion, restoredRows: rows.length };
       } finally {
-        await warehouse.exec(`DROP TABLE IF EXISTS ${table}`).catch(() => void 0);
+        await warehouse2.exec(`DROP TABLE IF EXISTS ${table}`).catch(() => void 0);
       }
     }
   };
@@ -1462,13 +1462,13 @@ function serverlessComputeCheck() {
     id: "azure-serverless",
     description: "Azure Databricks serverless SQL warehouse is enabled and executes SQL",
     configured: (env) => Boolean(env.DATABRICKS_WAREHOUSE_ID),
-    async run({ env, client, warehouse }) {
+    async run({ env, client, warehouse: warehouse2 }) {
       const id = env.DATABRICKS_WAREHOUSE_ID;
       const details = await client.get(`/api/2.0/sql/warehouses/${encodeURIComponent(id)}`);
       if (details.enable_serverless_compute !== true) {
         throw new Error(`SQL warehouse ${id} is not configured for serverless compute`);
       }
-      const rows = await warehouse.query("SELECT current_catalog() AS catalog");
+      const rows = await warehouse2.query("SELECT current_catalog() AS catalog");
       return { warehouseId: id, name: details.name, state: details.state, rows: rows.length };
     }
   };
@@ -1563,9 +1563,9 @@ function defineTargetPack(spec) {
       }
       ids.add(check.id);
     }
-    for (const required2 of spec.requiredChecks ?? []) {
-      if (!ids.has(required2)) {
-        throw new Error(`Target pack '${spec.id}' requires unknown check '${required2}'`);
+    for (const required3 of spec.requiredChecks ?? []) {
+      if (!ids.has(required3)) {
+        throw new Error(`Target pack '${spec.id}' requires unknown check '${required3}'`);
       }
     }
     return checks;
@@ -1589,25 +1589,25 @@ function createTargetPackRegistry(packs) {
   return registry;
 }
 function doctorTargetPack(pack, env = process.env, requiredChecks = pack.requiredChecks ?? []) {
-  const requirements = (pack.requirements ?? []).map((requirement) => ({
-    id: requirement.id,
-    description: requirement.description,
-    satisfied: requirement.anyOf.some((name) => Boolean(env[name]?.trim())),
-    required: requirement.required !== false,
-    variables: [...requirement.anyOf]
+  const requirements = (pack.requirements ?? []).map((requirement2) => ({
+    id: requirement2.id,
+    description: requirement2.description,
+    satisfied: requirement2.anyOf.some((name) => Boolean(env[name]?.trim())),
+    required: requirement2.required !== false,
+    variables: [...requirement2.anyOf]
   }));
-  const required2 = new Set(requiredChecks);
+  const required3 = new Set(requiredChecks);
   const checks = pack.checks().map((check) => ({
     id: check.id,
     description: check.description,
     configured: check.configured ? check.configured(env) : true,
-    required: required2.has(check.id)
+    required: required3.has(check.id)
   }));
   const known = new Set(checks.map((check) => check.id));
-  const missingRequirements = requirements.filter((requirement) => requirement.required && !requirement.satisfied).map((requirement) => requirement.id);
+  const missingRequirements = requirements.filter((requirement2) => requirement2.required && !requirement2.satisfied).map((requirement2) => requirement2.id);
   const missingRequiredChecks = [
     ...checks.filter((check) => check.required && !check.configured).map((check) => check.id),
-    ...[...required2].filter((id) => !known.has(id))
+    ...[...required3].filter((id) => !known.has(id))
   ];
   return {
     pack: {
@@ -1722,7 +1722,7 @@ function createSqlDeltaFoundationPack() {
     ],
     requiredChecks: ["sql"],
     requirements: [workspaceRequirement, authRequirement, warehouseRequirement],
-    docsUrl: `${DOCS}#existing-foundation-to-migrate-into-packs`,
+    docsUrl: `${DOCS}#sql-and-delta-foundation`,
     certificationScopes: [AZURE_SCOPE]
   });
 }
@@ -1747,7 +1747,7 @@ function createLakeflowFoundationPack() {
     ],
     requiredChecks: ["pipeline"],
     requirements: [workspaceRequirement, authRequirement],
-    docsUrl: `${DOCS}#existing-foundation-to-migrate-into-packs`,
+    docsUrl: `${DOCS}#lakeflow-ingestion-foundation`,
     certificationScopes: [AZURE_SCOPE]
   });
 }
@@ -1775,7 +1775,7 @@ function createJobsCodeFoundationPack() {
     ],
     requiredChecks: ["jobs"],
     requirements: [workspaceRequirement, authRequirement],
-    docsUrl: `${DOCS}#existing-foundation-to-migrate-into-packs`,
+    docsUrl: `${DOCS}#jobs-and-code-foundation`,
     certificationScopes: [AZURE_SCOPE]
   });
 }
@@ -1801,7 +1801,7 @@ function createUnityStorageFoundationPack() {
     ],
     requiredChecks: ["uc-grants"],
     requirements: [workspaceRequirement, authRequirement, warehouseRequirement],
-    docsUrl: `${DOCS}#existing-foundation-to-migrate-into-packs`,
+    docsUrl: `${DOCS}#unity-catalog-and-storage-foundation`,
     certificationScopes: [AZURE_SCOPE]
   });
 }
@@ -1827,7 +1827,7 @@ function createAppsOperationalFoundationPack() {
     ],
     requiredChecks: ["app"],
     requirements: [workspaceRequirement, authRequirement],
-    docsUrl: `${DOCS}#existing-foundation-to-migrate-into-packs`,
+    docsUrl: `${DOCS}#apps-and-operational-data-foundation`,
     certificationScopes: [AZURE_SCOPE]
   });
 }
@@ -1858,7 +1858,8 @@ var DatabricksJobsAdapter = class {
   async get(runId) {
     const raw = await this.client.get("/api/2.1/jobs/runs/get", {
       run_id: runId,
-      include_history: true
+      include_history: true,
+      include_resolved_values: true
     });
     return normalizeJobRun(runId, raw);
   }
@@ -1872,15 +1873,46 @@ var DatabricksJobsAdapter = class {
   async cancel(runId) {
     await this.client.post("/api/2.1/jobs/runs/cancel", { run_id: runId });
   }
+  async waitUntilActive(runId, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const pollIntervalMs = options.pollIntervalMs ?? 2e3;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const run = await this.get(runId);
+      if (run.lifeCycleState === "RUNNING") return run;
+      if (isTerminal(run.lifeCycleState)) {
+        throw new Error(
+          `Databricks run ${runId} reached ${run.lifeCycleState}/${run.resultState} before it could be canceled`
+        );
+      }
+      await delay2(pollIntervalMs);
+    }
+    throw new Error(`Databricks run ${runId} did not become active within ${timeoutMs}ms`);
+  }
   async repair(runId, options = {}) {
     const response = await this.client.post("/api/2.1/jobs/runs/repair", {
       run_id: runId,
       ...options.latestRepairId ? { latest_repair_id: options.latestRepairId } : {},
+      ...options.rerunDependentTasks ? { rerun_dependent_tasks: true } : {},
       ...options.rerunTasks?.length ? { rerun_tasks: options.rerunTasks } : { rerun_all_failed_tasks: true }
     });
     if (!response.repair_id) throw new Error("Databricks Jobs repair returned no repair_id");
     return response.repair_id;
   }
+  async waitForRepair(runId, repairId, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 9e5;
+    const pollIntervalMs = options.pollIntervalMs ?? 5e3;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const run = await this.get(runId);
+      const repair = run.repairs.find((candidate) => candidate.repairId === repairId);
+      if (repair && isTerminal(repair.lifeCycleState)) return run;
+      await delay2(pollIntervalMs);
+    }
+    throw new Error(
+      `Databricks repair ${repairId} for run ${runId} timed out after ${timeoutMs}ms`
+    );
+  }
 };
 function validateJobGraph(tasks) {
   if (tasks.length === 0) throw new Error("Jobs orchestration requires at least one task");
@@ -1926,16 +1958,20 @@ function jobsOrchestrationCheck() {
       const configured = env.DBX_TEST_JOBS_ORCHESTRATION_JSON;
       if (!configured) throw new Error("DBX_TEST_JOBS_ORCHESTRATION_JSON is required");
       const spec = parseJobOrchestrationLiveSpec(configured);
-      const adapter = new DatabricksJobsAdapter(client);
-      const runId = await adapter.submit(spec.request);
-      let run = await adapter.wait(runId, {
+      const adapter2 = new DatabricksJobsAdapter(client);
+      const runId = await adapter2.submit(spec.request);
+      let run = await adapter2.wait(runId, {
         timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
         pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
       });
+      let repairId;
       if (spec.repairFailedTasks && run.resultState !== "SUCCESS") {
         const failed = run.tasks.filter((task) => task.resultState === "FAILED").map((task) => task.taskKey);
-        await adapter.repair(runId, { rerunTasks: failed.length > 0 ? failed : void 0 });
-        run = await adapter.wait(runId, {
+        repairId = await adapter2.repair(runId, {
+          rerunTasks: failed.length > 0 ? failed : void 0,
+          rerunDependentTasks: true
+        });
+        run = await adapter2.waitForRepair(runId, repairId, {
           timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
           pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
         });
@@ -1953,10 +1989,32 @@ function jobsOrchestrationCheck() {
           throw new Error(`Task '${taskKey}' ended in ${task.resultState}, expected ${expected}`);
         }
       }
+      let cancellation;
+      if (spec.cancellation) {
+        const cancellationRunId = await adapter2.submit(spec.cancellation.request);
+        await adapter2.waitUntilActive(cancellationRunId, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+        await adapter2.cancel(cancellationRunId);
+        const canceled = await adapter2.wait(cancellationRunId, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+        const expectedCancellation = spec.cancellation.expectedResult ?? "CANCELED";
+        if (canceled.resultState !== expectedCancellation) {
+          throw new Error(
+            `Cancellation run ${cancellationRunId} ended in ${canceled.resultState}, expected ${expectedCancellation}`
+          );
+        }
+        cancellation = { runId: cancellationRunId, resultState: canceled.resultState };
+      }
       return {
         runId,
+        ...repairId ? { repairId } : {},
         resultState: run.resultState,
-        tasks: run.tasks
+        tasks: run.tasks,
+        ...cancellation ? { cancellation } : {}
       };
     }
   };
@@ -1976,11 +2034,24 @@ function parseJobOrchestrationLiveSpec(value) {
     throw new Error("Jobs orchestration spec requires request.tasks");
   }
   validateJobGraph(spec.request.tasks);
+  if (spec.cancellation) {
+    if (typeof spec.cancellation !== "object" || !spec.cancellation.request || !Array.isArray(spec.cancellation.request.tasks)) {
+      throw new Error("Jobs orchestration cancellation requires request.tasks");
+    }
+    validateJobGraph(spec.cancellation.request.tasks);
+  }
   return spec;
 }
 function normalizeJobRun(fallbackRunId, raw) {
   const state = objectOf(raw.state);
-  const tasks = Array.isArray(raw.tasks) ? raw.tasks.filter(
+  const repairEntries = Array.isArray(raw.repair_history) ? raw.repair_history.filter(
+    (repair) => Boolean(repair && typeof repair === "object")
+  ) : [];
+  const taskRunRanks = /* @__PURE__ */ new Map();
+  for (const [rank, repair] of repairEntries.entries()) {
+    for (const runId of numberArray(repair.task_run_ids)) taskRunRanks.set(runId, rank);
+  }
+  const taskAttempts = Array.isArray(raw.tasks) ? raw.tasks.filter(
     (task) => Boolean(task && typeof task === "object")
   ).map((task) => {
     const taskState = objectOf(task.state);
@@ -1989,20 +2060,236 @@ function normalizeJobRun(fallbackRunId, raw) {
       ...Number.isFinite(Number(task.run_id)) ? { runId: Number(task.run_id) } : {},
       lifeCycleState: String(taskState.life_cycle_state ?? "UNKNOWN"),
       resultState: String(taskState.result_state ?? "UNKNOWN"),
-      ...typeof taskState.state_message === "string" ? { stateMessage: taskState.state_message } : {}
+      ...typeof taskState.state_message === "string" ? { stateMessage: taskState.state_message } : {},
+      ...Number.isFinite(Number(task.attempt_number)) ? { attemptNumber: Number(task.attempt_number) } : {}
     };
   }) : [];
+  const latestTasks = /* @__PURE__ */ new Map();
+  for (const task of taskAttempts) {
+    const current = latestTasks.get(task.taskKey);
+    const currentAttempt = current?.attemptNumber ?? -1;
+    const candidateAttempt = task.attemptNumber ?? -1;
+    const currentRank = current?.runId ? taskRunRanks.get(current.runId) ?? -1 : -1;
+    const candidateRank = task.runId ? taskRunRanks.get(task.runId) ?? -1 : -1;
+    if (!current || candidateAttempt > currentAttempt || candidateAttempt === currentAttempt && candidateRank >= currentRank) {
+      latestTasks.set(task.taskKey, task);
+    }
+  }
+  const tasks = [...latestTasks.values()];
+  const repairs = repairEntries.map((repair) => {
+    const repairState = objectOf(repair.state);
+    return {
+      repairId: Number(repair.id ?? repair.repair_id ?? 0),
+      type: String(repair.type ?? "UNKNOWN"),
+      lifeCycleState: String(repairState.life_cycle_state ?? "UNKNOWN"),
+      resultState: String(repairState.result_state ?? "UNKNOWN"),
+      taskRunIds: numberArray(repair.task_run_ids)
+    };
+  });
   return {
     runId: Number(raw.run_id ?? fallbackRunId),
     lifeCycleState: String(state.life_cycle_state ?? "UNKNOWN"),
     resultState: String(state.result_state ?? "UNKNOWN"),
     tasks,
+    repairs,
     raw
   };
 }
+function isTerminal(state) {
+  return ["TERMINATED", "SKIPPED", "INTERNAL_ERROR", "BLOCKED"].includes(state);
+}
+function delay2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 function objectOf(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function numberArray(value) {
+  return Array.isArray(value) ? value.map(Number).filter((candidate) => Number.isFinite(candidate)) : [];
+}
+
+// src/jobs-certification-check.ts
+var NOTEBOOKS = {
+  seed: `# Databricks notebook source
+dbutils.jobs.taskValues.set(key="branch", value="run")
+dbutils.jobs.taskValues.set(key="items", value=["alpha", "beta"])
+dbutils.notebook.exit("seeded")
+`,
+  process: `# Databricks notebook source
+dbutils.widgets.text("item", "")
+item = dbutils.widgets.get("item")
+assert item, "item parameter is required"
+dbutils.notebook.exit(item)
+`,
+  retry: `# Databricks notebook source
+dbutils.widgets.text("execution_count", "0")
+execution_count = int(dbutils.widgets.get("execution_count"))
+if execution_count <= 1:
+    raise RuntimeError("intentional retryable failure")
+dbutils.notebook.exit("retried")
+`,
+  repair: `# Databricks notebook source
+dbutils.widgets.text("repair_count", "0")
+repair_count = int(dbutils.widgets.get("repair_count"))
+if repair_count == 0:
+    raise RuntimeError("intentional first-run failure")
+dbutils.notebook.exit("repaired")
+`,
+  sleep: `# Databricks notebook source
+import time
+time.sleep(300)
+`
+};
+function jobsCertificationCheck() {
+  return {
+    id: "jobs-certification",
+    description: "Disposable Lakeflow Jobs branch, loop, failure, repair, cancellation, and cleanup certification",
+    configured: (env) => env.DBX_TEST_JOBS_CERTIFY === "1",
+    async run({ env, client }) {
+      const root = `${env.DBX_TEST_JOBS_FIXTURE_ROOT ?? "/Workspace/Shared/fabric-experiments-target-pack"}/${crypto.randomUUID()}`;
+      const paths = Object.fromEntries(
+        Object.keys(NOTEBOOKS).map((name) => [name, `${root}/${name}`])
+      );
+      try {
+        await importNotebooks(client, paths);
+        const adapter2 = new DatabricksJobsAdapter(client);
+        const runId = await adapter2.submit(certificationRequest(paths));
+        const initial = await adapter2.wait(runId, waitOptions(env));
+        if (initial.resultState !== "FAILED") {
+          throw new Error(
+            `Certification run ${runId} expected FAILED before repair, got ${initial.resultState}`
+          );
+        }
+        const retried = assertTask(initial.tasks, "retry", "SUCCESS");
+        if ((retried.attemptNumber ?? 0) < 1) {
+          throw new Error("Certification retry task did not record a second attempt");
+        }
+        assertTask(initial.tasks, "seed", "SUCCESS");
+        assertTask(initial.tasks, "branch", "SUCCESS");
+        assertTask(initial.tasks, "foreach", "SUCCESS");
+        assertTask(initial.tasks, "repair", "FAILED");
+        const repairId = await adapter2.repair(runId, {
+          rerunTasks: ["repair"],
+          rerunDependentTasks: true
+        });
+        const repaired = await adapter2.waitForRepair(runId, repairId, waitOptions(env));
+        if (repaired.resultState !== "SUCCESS") {
+          throw new Error(`Certification repair ${repairId} ended in ${repaired.resultState}`);
+        }
+        assertTask(repaired.tasks, "repair", "SUCCESS");
+        const cancellationRunId = await adapter2.submit(cancellationRequest(paths));
+        await adapter2.waitUntilActive(cancellationRunId, waitOptions(env));
+        await adapter2.cancel(cancellationRunId);
+        const canceled = await adapter2.wait(cancellationRunId, waitOptions(env));
+        if (canceled.resultState !== "CANCELED") {
+          throw new Error(`Certification cancellation ended in ${canceled.resultState}`);
+        }
+        return {
+          runId,
+          repairId,
+          cancellationRunId,
+          taskValues: true,
+          retry: true,
+          condition: true,
+          forEach: true,
+          repair: true,
+          cancellation: true,
+          fixtureRoot: root
+        };
+      } finally {
+        await client.post("/api/2.0/workspace/delete", { path: root, recursive: true });
+      }
+    }
+  };
+}
+async function importNotebooks(client, paths) {
+  await client.post("/api/2.0/workspace/mkdirs", {
+    path: paths.seed.slice(0, paths.seed.lastIndexOf("/"))
+  });
+  for (const [name, source] of Object.entries(NOTEBOOKS)) {
+    await client.post("/api/2.0/workspace/import", {
+      path: paths[name],
+      format: "SOURCE",
+      language: "PYTHON",
+      overwrite: true,
+      content: Buffer.from(source).toString("base64")
+    });
+  }
+}
+function certificationRequest(paths) {
+  return {
+    run_name: "fabric-experiments-jobs-certification",
+    tasks: [
+      {
+        task_key: "retry",
+        notebook_task: {
+          notebook_path: paths.retry,
+          base_parameters: { execution_count: "{{task.execution_count}}" }
+        },
+        max_retries: 1
+      },
+      {
+        task_key: "seed",
+        depends_on: [{ task_key: "retry" }],
+        notebook_task: { notebook_path: paths.seed }
+      },
+      {
+        task_key: "branch",
+        depends_on: [{ task_key: "seed" }],
+        condition_task: {
+          left: "{{tasks.seed.values.branch}}",
+          op: "EQUAL_TO",
+          right: "run"
+        }
+      },
+      {
+        task_key: "foreach",
+        depends_on: [{ task_key: "branch", outcome: "true" }],
+        for_each_task: {
+          inputs: "{{tasks.seed.values.items}}",
+          concurrency: 2,
+          task: {
+            task_key: "process_item",
+            notebook_task: {
+              notebook_path: paths.process,
+              base_parameters: { item: "{{input}}" }
+            }
+          }
+        }
+      },
+      {
+        task_key: "repair",
+        depends_on: [{ task_key: "foreach" }],
+        notebook_task: {
+          notebook_path: paths.repair,
+          base_parameters: { repair_count: "{{job.repair_count}}" }
+        }
+      }
+    ]
+  };
+}
+function cancellationRequest(paths) {
+  return {
+    run_name: "fabric-experiments-jobs-cancellation-certification",
+    tasks: [{ task_key: "sleep", notebook_task: { notebook_path: paths.sleep } }]
+  };
+}
+function waitOptions(env) {
+  return {
+    timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+    pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 5e3)
+  };
+}
+function assertTask(tasks, taskKey, resultState) {
+  const task = tasks.find((candidate) => candidate.taskKey === taskKey);
+  if (!task) throw new Error(`Certification result did not contain task '${taskKey}'`);
+  if (task.resultState !== resultState) {
+    throw new Error(
+      `Certification task '${taskKey}' ended in ${task.resultState}, expected ${resultState}`
+    );
+  }
+  return task;
+}
 
 // src/jobs-target-pack.ts
 function createLakeflowJobsTargetPack() {
@@ -2010,8 +2297,8 @@ function createLakeflowJobsTargetPack() {
     id: "lakeflow-jobs",
     name: "Lakeflow Jobs orchestration",
     description: "Typed multi-task DAG, branch/loop, retry, cancellation, repair and task-outcome validation.",
-    version: "0.1.0",
-    maturity: "shipped",
+    version: "0.2.0",
+    maturity: "live-gated",
     capabilities: [
       "jobs.multi-task-dag",
       "jobs.dependencies",
@@ -2022,7 +2309,12 @@ function createLakeflowJobsTargetPack() {
       "jobs.repair",
       "jobs.task-outcomes"
     ],
-    checks: () => [restrictedPrincipalCheck(), jobRunCheck(), jobsOrchestrationCheck()],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      jobRunCheck(),
+      jobsOrchestrationCheck(),
+      jobsCertificationCheck()
+    ],
     requiredChecks: ["jobs-orchestration"],
     requirements: [
       {
@@ -2045,17 +2337,812 @@ function createLakeflowJobsTargetPack() {
       {
         id: "orchestration-spec",
         description: "JSON multi-task orchestration scenario",
-        anyOf: ["DBX_TEST_JOBS_ORCHESTRATION_JSON"]
+        anyOf: ["DBX_TEST_JOBS_ORCHESTRATION_JSON"],
+        required: false
       }
     ],
-    docsUrl: "https://experiments.fabric.pro/docs/testing/target-packs/#pack-1--lakeflow-jobs-orchestration",
-    certificationScopes: []
+    docsUrl: "https://experiments.fabric.pro/docs/testing/target-packs/#lakeflow-jobs-orchestration",
+    certificationScopes: [
+      "Azure Databricks serverless Jobs, West US, workspace OAuth, public network path"
+    ]
   });
 }
 
+// src/advanced-workload-checks.ts
+init_workspace_context();
+var DatabricksAdvancedWorkloadsAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  pipeline(id) {
+    return this.client.get(`/api/2.0/pipelines/${segment(id)}`);
+  }
+  table(fullName) {
+    return this.client.get(`/api/2.1/unity-catalog/tables/${segment(fullName)}`);
+  }
+  dashboard(id) {
+    return this.client.get(`/api/2.0/lakeview/dashboards/${segment(id)}`);
+  }
+  genieSpace(id) {
+    return this.client.get(`/api/2.0/genie/spaces/${segment(id)}`);
+  }
+  startGenieConversation(spaceId, question) {
+    return this.client.post(`/api/2.0/genie/spaces/${segment(spaceId)}/start-conversation`, {
+      content: question
+    });
+  }
+  experiment(id) {
+    return this.client.get("/api/2.0/mlflow/experiments/get", { experiment_id: id });
+  }
+  registeredModel(fullName) {
+    return this.client.get(`/api/2.1/unity-catalog/models/${segment(fullName)}`);
+  }
+  modelVersion(fullName, version) {
+    return this.client.get(
+      `/api/2.1/unity-catalog/models/${segment(fullName)}/versions/${segment(version)}`
+    );
+  }
+  onlineTable(fullName) {
+    return this.client.get(`/api/2.0/online-tables/${segment(fullName)}`);
+  }
+  servingEndpoint(name) {
+    return this.client.get(`/api/2.0/serving-endpoints/${segment(name)}`);
+  }
+  invokeServingEndpoint(name, request) {
+    return this.client.post(`/serving-endpoints/${segment(name)}/invocations`, request);
+  }
+  vectorSearchEndpoint(name) {
+    return this.client.get(`/api/2.0/vector-search/endpoints/${segment(name)}`);
+  }
+  vectorSearchIndex(name) {
+    return this.client.get(`/api/2.0/vector-search/indexes/${segment(name)}`);
+  }
+  queryVectorSearchIndex(name, request) {
+    return this.client.post(`/api/2.0/vector-search/indexes/${segment(name)}/query`, request);
+  }
+  connection(name) {
+    return this.client.get(`/api/2.1/unity-catalog/connections/${segment(name)}`);
+  }
+  share(name) {
+    return this.client.get(`/api/2.1/unity-catalog/shares/${segment(name)}`);
+  }
+  cleanRoom(name) {
+    return this.client.get(`/api/2.0/clean-rooms/${segment(name)}`);
+  }
+  ipAccessList(id) {
+    return this.client.get(`/api/2.0/ip-access-lists/${segment(id)}`);
+  }
+  clusterPolicy(id) {
+    return this.client.get("/api/2.0/policies/clusters/get", { policy_id: id });
+  }
+  warehouse(id) {
+    return this.client.get(`/api/2.0/sql/warehouses/${segment(id)}`);
+  }
+};
+function segment(value) {
+  return encodeURIComponent(value);
+}
+function adapter(client) {
+  return new DatabricksAdvancedWorkloadsAdapter(client);
+}
+function required2(env, names) {
+  return names.filter((name) => !env[name]?.trim());
+}
+function requireEnv(env, names) {
+  const missing = required2(env, names);
+  if (missing.length > 0) throw new Error(`Missing required configuration: ${missing.join(", ")}`);
+}
+function parseJson(value, name) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`${name} must contain valid JSON`);
+  }
+}
+function assertNotFailed(label, state) {
+  if (typeof state === "string" && /FAIL|ERROR|DELET/i.test(state)) {
+    throw new Error(`${label} is ${state}`);
+  }
+}
+function assertReady(label, state, accepted) {
+  if (typeof state !== "string" || !accepted.includes(state.toUpperCase())) {
+    throw new Error(`${label} is ${String(state ?? "UNKNOWN")}; expected ${accepted.join(" or ")}`);
+  }
+}
+async function booleanSql(label, sql, query) {
+  if (!sql) return;
+  const rows = await query(sql);
+  const first = rows[0] ? Object.values(rows[0])[0] : void 0;
+  if (!(first === true || first === 1 || first === "1" || first === "true")) {
+    throw new Error(`${label} assertion did not return a truthy first column`);
+  }
+}
+function advancedStreamingCdcCheck() {
+  const names = [
+    "DBX_TEST_STREAMING_PIPELINE_ID",
+    "DBX_TEST_STREAMING_TABLE",
+    "DBX_TEST_CDC_ASSERTION_SQL",
+    "DBX_TEST_STREAMING_ASSERTION_SQL"
+  ];
+  return {
+    id: "streaming-cdc",
+    description: "Streaming pipeline, streaming table and CDC assertions are healthy",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client, warehouse: warehouse2 }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const pipeline = await api.pipeline(env.DBX_TEST_STREAMING_PIPELINE_ID);
+      assertNotFailed("Streaming pipeline", pipeline.state);
+      const table = await api.table(env.DBX_TEST_STREAMING_TABLE);
+      const tableType = String(table.table_type ?? table.data_source_format ?? "").toUpperCase();
+      if (!["STREAMING_TABLE", "MATERIALIZED_VIEW", "DELTA"].includes(tableType)) {
+        throw new Error(`Streaming target has unsupported table type ${tableType || "UNKNOWN"}`);
+      }
+      await booleanSql("CDC", env.DBX_TEST_CDC_ASSERTION_SQL, warehouse2.query);
+      await booleanSql(
+        "Streaming freshness",
+        env.DBX_TEST_STREAMING_ASSERTION_SQL,
+        warehouse2.query
+      );
+      return { pipelineId: pipeline.pipeline_id, table: env.DBX_TEST_STREAMING_TABLE, tableType };
+    }
+  };
+}
+function lakeflowConnectCheck() {
+  const names = ["DBX_TEST_CONNECT_PIPELINE_ID", "DBX_TEST_CONNECT_ASSERTION_SQL"];
+  return {
+    id: "lakeflow-connect",
+    description: "Lakeflow Connect ingestion pipeline exists and is not failed",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client, warehouse: warehouse2 }) {
+      requireEnv(env, names);
+      const id = env.DBX_TEST_CONNECT_PIPELINE_ID;
+      const pipeline = await adapter(client).pipeline(id);
+      assertNotFailed("Lakeflow Connect pipeline", pipeline.state);
+      await booleanSql(
+        "Lakeflow Connect replication",
+        env.DBX_TEST_CONNECT_ASSERTION_SQL,
+        warehouse2.query
+      );
+      return { pipelineId: pipeline.pipeline_id ?? id, state: pipeline.state ?? "IDLE" };
+    }
+  };
+}
+function aiBiDashboardCheck() {
+  return {
+    id: "aibi-dashboard",
+    description: "Published AI/BI dashboard is accessible",
+    configured: (env) => Boolean(env.DBX_TEST_DASHBOARD_ID),
+    async run({ env, client }) {
+      const dashboard = await adapter(client).dashboard(env.DBX_TEST_DASHBOARD_ID);
+      assertNotFailed("AI/BI dashboard", dashboard.lifecycle_state);
+      return {
+        dashboardId: dashboard.dashboard_id ?? env.DBX_TEST_DASHBOARD_ID,
+        name: dashboard.display_name
+      };
+    }
+  };
+}
+function genieCheck() {
+  const names = ["DBX_TEST_GENIE_SPACE_ID", "DBX_TEST_GENIE_QUESTION"];
+  return {
+    id: "genie",
+    description: "Genie space is accessible and can optionally start a grounded conversation",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const id = env.DBX_TEST_GENIE_SPACE_ID;
+      const space = await api.genieSpace(id);
+      let conversation;
+      if (env.DBX_TEST_GENIE_QUESTION) {
+        conversation = await api.startGenieConversation(id, env.DBX_TEST_GENIE_QUESTION);
+        if (!conversation.conversation_id && !conversation.message_id) {
+          throw new Error("Genie did not return a conversation or message identifier");
+        }
+      }
+      return {
+        spaceId: space.space_id ?? id,
+        title: space.title,
+        conversationStarted: Boolean(conversation)
+      };
+    }
+  };
+}
+function mlflowLifecycleCheck() {
+  const names = [
+    "DBX_TEST_MLFLOW_EXPERIMENT_ID",
+    "DBX_TEST_REGISTERED_MODEL",
+    "DBX_TEST_MODEL_VERSION"
+  ];
+  return {
+    id: "mlflow-lifecycle",
+    description: "MLflow experiment and Unity Catalog model version are accessible",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const experiment = await api.experiment(env.DBX_TEST_MLFLOW_EXPERIMENT_ID);
+      const model = await api.registeredModel(env.DBX_TEST_REGISTERED_MODEL);
+      const version = await api.modelVersion(
+        env.DBX_TEST_REGISTERED_MODEL,
+        env.DBX_TEST_MODEL_VERSION
+      );
+      assertNotFailed("Model version", version.status);
+      return {
+        experimentId: experiment.experiment?.experiment_id ?? env.DBX_TEST_MLFLOW_EXPERIMENT_ID,
+        model: model.full_name ?? model.name ?? env.DBX_TEST_REGISTERED_MODEL,
+        version: version.version ?? env.DBX_TEST_MODEL_VERSION
+      };
+    }
+  };
+}
+function featureEngineeringServingCheck() {
+  return {
+    id: "feature-engineering",
+    description: "Feature table and online materialization are healthy",
+    configured: (env) => Boolean(
+      env.DBX_TEST_FEATURE_TABLE && env.DBX_TEST_FEATURE_ASSERTION_SQL && (env.DBX_TEST_ONLINE_TABLE || env.DBX_TEST_FEATURE_SERVING_PIPELINE_ID)
+    ),
+    async run({ env, client, warehouse: warehouse2 }) {
+      requireEnv(env, ["DBX_TEST_FEATURE_TABLE"]);
+      if (!env.DBX_TEST_ONLINE_TABLE && !env.DBX_TEST_FEATURE_SERVING_PIPELINE_ID) {
+        throw new Error(
+          "Feature serving requires DBX_TEST_ONLINE_TABLE or DBX_TEST_FEATURE_SERVING_PIPELINE_ID"
+        );
+      }
+      const api = adapter(client);
+      const source = await api.table(env.DBX_TEST_FEATURE_TABLE);
+      let state;
+      let servingResource;
+      if (env.DBX_TEST_ONLINE_TABLE) {
+        const online = await api.onlineTable(env.DBX_TEST_ONLINE_TABLE);
+        const status = online.status;
+        state = status?.state ?? status?.detailed_state ?? online.state;
+        assertReady("Online table", state, ["ONLINE", "ACTIVE", "READY", "PROVISIONED"]);
+        servingResource = env.DBX_TEST_ONLINE_TABLE;
+      } else {
+        const pipelineId = env.DBX_TEST_FEATURE_SERVING_PIPELINE_ID;
+        const pipeline = await api.pipeline(pipelineId);
+        state = pipeline.state ?? "IDLE";
+        assertNotFailed("Synced Table pipeline", state);
+        servingResource = pipeline.pipeline_id ?? pipelineId;
+      }
+      await booleanSql("Feature freshness", env.DBX_TEST_FEATURE_ASSERTION_SQL, warehouse2.query);
+      return {
+        featureTable: source.full_name ?? env.DBX_TEST_FEATURE_TABLE,
+        servingResource,
+        state
+      };
+    }
+  };
+}
+function modelServingCheck() {
+  const names = [
+    "DBX_TEST_SERVING_ENDPOINT",
+    "DBX_TEST_SERVING_REQUEST_JSON",
+    "DBX_TEST_AI_GATEWAY_REQUIRED"
+  ];
+  return {
+    id: "model-serving",
+    description: "Model Serving endpoint is ready and can optionally serve an inference request",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client }) {
+      requireEnv(env, names);
+      if (env.DBX_TEST_AI_GATEWAY_REQUIRED !== "1") {
+        throw new Error("DBX_TEST_AI_GATEWAY_REQUIRED must be 1 for the Model Serving target pack");
+      }
+      const api = adapter(client);
+      const name = env.DBX_TEST_SERVING_ENDPOINT;
+      const endpoint = await api.servingEndpoint(name);
+      assertReady("Serving endpoint", endpoint.state?.ready, ["READY"]);
+      if (env.DBX_TEST_AI_GATEWAY_REQUIRED === "1" && !endpoint.ai_gateway) {
+        throw new Error(`Serving endpoint ${name} has no AI Gateway configuration`);
+      }
+      let response;
+      if (env.DBX_TEST_SERVING_REQUEST_JSON) {
+        response = await api.invokeServingEndpoint(
+          name,
+          parseJson(env.DBX_TEST_SERVING_REQUEST_JSON, "DBX_TEST_SERVING_REQUEST_JSON")
+        );
+        if (Object.keys(response).length === 0)
+          throw new Error("Serving invocation returned an empty response");
+      }
+      return {
+        endpoint: endpoint.name ?? name,
+        ready: endpoint.state?.ready,
+        aiGateway: Boolean(endpoint.ai_gateway),
+        invoked: Boolean(response)
+      };
+    }
+  };
+}
+function vectorSearchCheck() {
+  const names = ["DBX_TEST_VECTOR_ENDPOINT", "DBX_TEST_VECTOR_INDEX"];
+  return {
+    id: "vector-search",
+    description: "Vector Search endpoint and index are online",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const endpoint = await api.vectorSearchEndpoint(env.DBX_TEST_VECTOR_ENDPOINT);
+      assertReady("Vector Search endpoint", endpoint.endpoint_status?.state, ["ONLINE", "READY"]);
+      const index = await api.vectorSearchIndex(env.DBX_TEST_VECTOR_INDEX);
+      if (index.status?.ready !== true)
+        throw new Error(`Vector Search index is not ready: ${index.status?.message ?? "UNKNOWN"}`);
+      return {
+        endpoint: endpoint.name ?? env.DBX_TEST_VECTOR_ENDPOINT,
+        index: index.name ?? env.DBX_TEST_VECTOR_INDEX,
+        indexedRows: index.status.indexed_row_count
+      };
+    }
+  };
+}
+function ragAgentCheck() {
+  const names = [
+    "DBX_TEST_VECTOR_INDEX",
+    "DBX_TEST_VECTOR_QUERY_JSON",
+    "DBX_TEST_AGENT_ENDPOINT",
+    "DBX_TEST_AGENT_REQUEST_JSON"
+  ];
+  return {
+    id: "rag-agent",
+    description: "RAG retrieval and agent serving endpoint return non-empty responses",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      let retrieval;
+      if (env.DBX_TEST_VECTOR_QUERY_JSON) {
+        retrieval = await api.queryVectorSearchIndex(
+          env.DBX_TEST_VECTOR_INDEX,
+          parseJson(env.DBX_TEST_VECTOR_QUERY_JSON, "DBX_TEST_VECTOR_QUERY_JSON")
+        );
+        if (!retrieval.result && !retrieval.data_array && !retrieval.manifest) {
+          throw new Error("Vector query returned no result payload");
+        }
+      }
+      let agent;
+      if (env.DBX_TEST_AGENT_ENDPOINT) {
+        const endpoint = await api.servingEndpoint(env.DBX_TEST_AGENT_ENDPOINT);
+        assertReady("Agent endpoint", endpoint.state?.ready, ["READY"]);
+        if (env.DBX_TEST_AGENT_REQUEST_JSON) {
+          agent = await api.invokeServingEndpoint(
+            env.DBX_TEST_AGENT_ENDPOINT,
+            parseJson(env.DBX_TEST_AGENT_REQUEST_JSON, "DBX_TEST_AGENT_REQUEST_JSON")
+          );
+          if (Object.keys(agent).length === 0)
+            throw new Error("Agent invocation returned an empty response");
+        }
+      }
+      return {
+        retrieval: Boolean(retrieval),
+        agentEndpoint: env.DBX_TEST_AGENT_ENDPOINT,
+        agentInvoked: Boolean(agent)
+      };
+    }
+  };
+}
+function federationSharingCleanRoomsCheck() {
+  const names = [
+    "DBX_TEST_CONNECTION",
+    "DBX_TEST_SHARE",
+    "DBX_TEST_CLEAN_ROOM",
+    "DBX_TEST_FEDERATION_ASSERTION_SQL"
+  ];
+  return {
+    id: "federation-sharing-cleanrooms",
+    description: "Lakehouse Federation connection, Delta Share and Clean Room are accessible",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client, warehouse: warehouse2 }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const connection = await api.connection(env.DBX_TEST_CONNECTION);
+      const share = await api.share(env.DBX_TEST_SHARE);
+      const room = await api.cleanRoom(env.DBX_TEST_CLEAN_ROOM);
+      await booleanSql("Federated query", env.DBX_TEST_FEDERATION_ASSERTION_SQL, warehouse2.query);
+      return {
+        connection: connection.name ?? env.DBX_TEST_CONNECTION,
+        share: share.name ?? env.DBX_TEST_SHARE,
+        cleanRoom: room.name ?? env.DBX_TEST_CLEAN_ROOM
+      };
+    }
+  };
+}
+function securityPostureCostCheck() {
+  const names = [
+    "DBX_TEST_IP_ACCESS_LIST_ID",
+    "DBX_TEST_CLUSTER_POLICY_ID",
+    "DBX_TEST_COST_ASSERTION_SQL"
+  ];
+  return {
+    id: "security-cost",
+    description: "Network access controls, compute policy and cost guardrail are enforced",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env, client, warehouse: warehouse2 }) {
+      requireEnv(env, names);
+      const api = adapter(client);
+      const access = await api.ipAccessList(env.DBX_TEST_IP_ACCESS_LIST_ID);
+      if (access.enabled === false) throw new Error("Configured IP access list is disabled");
+      const policy = await api.clusterPolicy(env.DBX_TEST_CLUSTER_POLICY_ID);
+      if (!policy.policy_id && !policy.name)
+        throw new Error("Cluster policy response has no identity");
+      if (env.DBX_TEST_EXPECT_HOST_SUFFIX && !env.DATABRICKS_HOST?.endsWith(env.DBX_TEST_EXPECT_HOST_SUFFIX)) {
+        throw new Error(`Workspace host does not end with ${env.DBX_TEST_EXPECT_HOST_SUFFIX}`);
+      }
+      await booleanSql("Cost guardrail", env.DBX_TEST_COST_ASSERTION_SQL, warehouse2.query);
+      return {
+        ipAccessList: access.list_id ?? env.DBX_TEST_IP_ACCESS_LIST_ID,
+        policy: policy.policy_id ?? policy.name,
+        costGuardrail: "pass"
+      };
+    }
+  };
+}
+function regionalDrCheck(options = {}) {
+  const names = [
+    "DBX_TEST_DR_HOST",
+    "DBX_TEST_DR_WAREHOUSE_ID",
+    "DBX_TEST_DR_ASSERTION_SQL"
+  ];
+  return {
+    id: "regional-dr",
+    description: "Secondary-region workspace authentication and SQL warehouse are reachable",
+    configured: (env) => required2(env, names).length === 0,
+    async run({ env }) {
+      requireEnv(env, names);
+      const drEnv = {
+        ...env,
+        DATABRICKS_HOST: env.DBX_TEST_DR_HOST,
+        DATABRICKS_WAREHOUSE_ID: env.DBX_TEST_DR_WAREHOUSE_ID,
+        DATABRICKS_HTTP_PATH: void 0,
+        DATABRICKS_BEARER: env.DBX_TEST_DR_BEARER,
+        DATABRICKS_TOKEN: env.DBX_TEST_DR_TOKEN,
+        DATABRICKS_CLIENT_ID: env.DBX_TEST_DR_CLIENT_ID ?? env.DATABRICKS_CLIENT_ID,
+        DATABRICKS_CLIENT_SECRET: env.DBX_TEST_DR_CLIENT_SECRET ?? env.DATABRICKS_CLIENT_SECRET
+      };
+      const client = options.clientFactory?.(drEnv) ?? createClientFromEnv(drEnv);
+      const secondary = await adapter(client).warehouse(env.DBX_TEST_DR_WAREHOUSE_ID);
+      assertReady("DR SQL warehouse", secondary.state, ["RUNNING"]);
+      const drWarehouse = await createWorkspaceContext({ env: drEnv, client });
+      try {
+        await booleanSql("Regional DR workload", env.DBX_TEST_DR_ASSERTION_SQL, drWarehouse.query);
+      } finally {
+        await drWarehouse.close();
+      }
+      return {
+        secondaryWorkspace: "reachable",
+        warehouseId: secondary.id ?? env.DBX_TEST_DR_WAREHOUSE_ID,
+        state: secondary.state
+      };
+    }
+  };
+}
+
+// src/advanced-target-packs.ts
+var DOCS2 = "https://experiments.fabric.pro/docs/testing/target-packs/";
+var SHIPPED_SCOPE = "Typed adapter and offline contract tests shipped; live certification requires customer-owned test resources";
+var AZURE_USER_SCOPE = "Azure Databricks, West US, interactive user OAuth, public network path; existing certification fixtures";
+var workspace = {
+  id: "workspace",
+  description: "Databricks workspace host",
+  anyOf: ["DATABRICKS_HOST"]
+};
+var auth = {
+  id: "authentication",
+  description: "Databricks OAuth, OIDC, bearer, or PAT authentication",
+  anyOf: [
+    "DATABRICKS_BEARER",
+    "DATABRICKS_TOKEN",
+    "DATABRICKS_CLIENT_ID",
+    "DATABRICKS_OIDC_TOKEN",
+    "DATABRICKS_OIDC_TOKEN_FILEPATH"
+  ],
+  secret: true
+};
+var warehouse = {
+  id: "warehouse",
+  description: "SQL warehouse for data-plane assertions",
+  anyOf: ["DATABRICKS_WAREHOUSE_ID", "DATABRICKS_HTTP_PATH"]
+};
+var requirement = (id, description, ...anyOf) => ({
+  id,
+  description,
+  anyOf
+});
+function createAdvancedStreamingTargetPack() {
+  return defineTargetPack({
+    id: "streaming-cdc-connect",
+    name: "Advanced streaming, CDC and Lakeflow Connect",
+    description: "Streaming tables, pipeline health, CDC correctness, freshness and managed connector replication.",
+    version: "0.1.0",
+    maturity: "shipped",
+    capabilities: [
+      "streaming.tables",
+      "streaming.freshness",
+      "cdc.correctness",
+      "lakeflow-connect.replication"
+    ],
+    checks: () => [restrictedPrincipalCheck(), advancedStreamingCdcCheck(), lakeflowConnectCheck()],
+    requiredChecks: ["streaming-cdc", "lakeflow-connect"],
+    requirements: [
+      workspace,
+      auth,
+      warehouse,
+      requirement("streaming-pipeline", "Streaming pipeline ID", "DBX_TEST_STREAMING_PIPELINE_ID"),
+      requirement("streaming-table", "Streaming target table", "DBX_TEST_STREAMING_TABLE"),
+      requirement(
+        "connect-pipeline",
+        "Lakeflow Connect ingestion pipeline",
+        "DBX_TEST_CONNECT_PIPELINE_ID"
+      ),
+      requirement(
+        "streaming-assertion",
+        "Streaming freshness SQL",
+        "DBX_TEST_STREAMING_ASSERTION_SQL"
+      ),
+      requirement("cdc-assertion", "CDC correctness SQL", "DBX_TEST_CDC_ASSERTION_SQL"),
+      requirement(
+        "connect-assertion",
+        "Lakeflow Connect replication SQL",
+        "DBX_TEST_CONNECT_ASSERTION_SQL"
+      )
+    ],
+    docsUrl: `${DOCS2}#advanced-streaming-cdc-and-lakeflow-connect`,
+    certificationScopes: [SHIPPED_SCOPE]
+  });
+}
+function createAiBiGenieTargetPack() {
+  return defineTargetPack({
+    id: "aibi-genie",
+    name: "AI/BI dashboards and Genie",
+    description: "Dashboard accessibility and authenticated Genie space/conversation behavior.",
+    version: "0.1.0",
+    maturity: "live-gated",
+    capabilities: ["aibi.dashboard", "genie.space", "genie.conversation"],
+    checks: () => [restrictedPrincipalCheck(), aiBiDashboardCheck(), genieCheck()],
+    requiredChecks: ["aibi-dashboard", "genie"],
+    requirements: [
+      workspace,
+      auth,
+      requirement("dashboard", "AI/BI dashboard ID", "DBX_TEST_DASHBOARD_ID"),
+      requirement("genie-space", "Genie space ID", "DBX_TEST_GENIE_SPACE_ID"),
+      requirement(
+        "genie-question",
+        "Grounded Genie certification question",
+        "DBX_TEST_GENIE_QUESTION"
+      )
+    ],
+    docsUrl: `${DOCS2}#aibi-dashboards-and-genie`,
+    certificationScopes: [
+      `${AZURE_USER_SCOPE}; AI/BI dashboard metadata and Genie conversation start`
+    ]
+  });
+}
+function createMlflowLifecycleTargetPack() {
+  return defineTargetPack({
+    id: "mlflow-lifecycle",
+    name: "MLflow and model lifecycle",
+    description: "MLflow experiments plus Unity Catalog registered-model and model-version lifecycle evidence.",
+    version: "0.1.0",
+    maturity: "live-gated",
+    capabilities: [
+      "mlflow.experiments",
+      "models.unity-catalog",
+      "models.versions",
+      "models.lifecycle"
+    ],
+    checks: () => [restrictedPrincipalCheck(), mlflowLifecycleCheck()],
+    requiredChecks: ["mlflow-lifecycle"],
+    requirements: [
+      workspace,
+      auth,
+      requirement("experiment", "MLflow experiment ID", "DBX_TEST_MLFLOW_EXPERIMENT_ID"),
+      requirement(
+        "registered-model",
+        "Unity Catalog registered model",
+        "DBX_TEST_REGISTERED_MODEL"
+      ),
+      requirement("model-version", "Registered model version", "DBX_TEST_MODEL_VERSION")
+    ],
+    docsUrl: `${DOCS2}#mlflow-and-model-lifecycle`,
+    certificationScopes: [
+      `${AZURE_USER_SCOPE}; MLflow experiment and Unity Catalog model version 20`
+    ]
+  });
+}
+function createFeatureEngineeringTargetPack() {
+  return defineTargetPack({
+    id: "feature-engineering-serving",
+    name: "Feature engineering and serving",
+    description: "Unity Catalog feature tables, online materialization state and freshness assertions.",
+    version: "0.1.0",
+    maturity: "live-gated",
+    capabilities: [
+      "features.tables",
+      "features.online-tables",
+      "features.freshness",
+      "features.serving"
+    ],
+    checks: () => [restrictedPrincipalCheck(), featureEngineeringServingCheck()],
+    requiredChecks: ["feature-engineering"],
+    requirements: [
+      workspace,
+      auth,
+      warehouse,
+      requirement("feature-table", "Unity Catalog feature table", "DBX_TEST_FEATURE_TABLE"),
+      requirement(
+        "online-materialization",
+        "Databricks Online Table or Synced Table pipeline",
+        "DBX_TEST_ONLINE_TABLE",
+        "DBX_TEST_FEATURE_SERVING_PIPELINE_ID"
+      ),
+      requirement(
+        "feature-assertion",
+        "Feature freshness/correctness SQL",
+        "DBX_TEST_FEATURE_ASSERTION_SQL"
+      )
+    ],
+    docsUrl: `${DOCS2}#feature-engineering-and-serving`,
+    certificationScopes: [
+      `${AZURE_USER_SCOPE}; Delta feature table, PostgreSQL-backed Synced Table, and SQL freshness`
+    ]
+  });
+}
+function createModelServingTargetPack() {
+  return defineTargetPack({
+    id: "model-serving-gateway",
+    name: "Model Serving and AI Gateway",
+    description: "Serving readiness, inference behavior and optional AI Gateway policy presence.",
+    version: "0.1.0",
+    maturity: "live-gated",
+    capabilities: [
+      "model-serving.readiness",
+      "model-serving.inference",
+      "ai-gateway.configuration"
+    ],
+    checks: () => [restrictedPrincipalCheck(), modelServingCheck()],
+    requiredChecks: ["model-serving"],
+    requirements: [
+      workspace,
+      auth,
+      requirement("serving-endpoint", "Model Serving endpoint name", "DBX_TEST_SERVING_ENDPOINT"),
+      requirement(
+        "serving-request",
+        "Safe inference request JSON",
+        "DBX_TEST_SERVING_REQUEST_JSON"
+      ),
+      requirement(
+        "ai-gateway",
+        "AI Gateway enforcement flag set to 1",
+        "DBX_TEST_AI_GATEWAY_REQUIRED"
+      )
+    ],
+    docsUrl: `${DOCS2}#model-serving-and-ai-gateway`,
+    certificationScopes: [
+      `${AZURE_USER_SCOPE}; custom-model inference and AI Gateway inference-table configuration`
+    ]
+  });
+}
+function createVectorRagAgentsTargetPack() {
+  return defineTargetPack({
+    id: "vector-rag-agents",
+    name: "Vector Search, RAG and agents",
+    description: "Vector endpoint/index readiness, retrieval behavior and agent endpoint inference.",
+    version: "0.1.0",
+    maturity: "live-gated",
+    capabilities: [
+      "vector-search.endpoint",
+      "vector-search.index",
+      "rag.retrieval",
+      "agents.serving"
+    ],
+    checks: () => [restrictedPrincipalCheck(), vectorSearchCheck(), ragAgentCheck()],
+    requiredChecks: ["vector-search", "rag-agent"],
+    requirements: [
+      workspace,
+      auth,
+      requirement("vector-endpoint", "Vector Search endpoint", "DBX_TEST_VECTOR_ENDPOINT"),
+      requirement("vector-index", "Vector Search index", "DBX_TEST_VECTOR_INDEX"),
+      requirement("vector-query", "Vector retrieval request JSON", "DBX_TEST_VECTOR_QUERY_JSON"),
+      requirement("agent-endpoint", "Agent serving endpoint", "DBX_TEST_AGENT_ENDPOINT"),
+      requirement("agent-request", "Safe agent request JSON", "DBX_TEST_AGENT_REQUEST_JSON")
+    ],
+    docsUrl: `${DOCS2}#vector-search-rag-and-agents`,
+    certificationScopes: [
+      `${AZURE_USER_SCOPE}; Delta Sync vector retrieval and custom PyFunc agent invocation`
+    ]
+  });
+}
+function createFederationSharingTargetPack() {
+  return defineTargetPack({
+    id: "federation-sharing-cleanrooms",
+    name: "Federation, Delta Sharing and Clean Rooms",
+    description: "Federated connection, data-plane query, Delta Share and Clean Room governance access.",
+    version: "0.1.0",
+    maturity: "shipped",
+    capabilities: [
+      "federation.connections",
+      "federation.query",
+      "delta-sharing.shares",
+      "clean-rooms.access"
+    ],
+    checks: () => [restrictedPrincipalCheck(), federationSharingCleanRoomsCheck()],
+    requiredChecks: ["federation-sharing-cleanrooms"],
+    requirements: [
+      workspace,
+      auth,
+      warehouse,
+      requirement("connection", "Lakehouse Federation connection", "DBX_TEST_CONNECTION"),
+      requirement("share", "Delta Sharing share", "DBX_TEST_SHARE"),
+      requirement("clean-room", "Clean Room name", "DBX_TEST_CLEAN_ROOM"),
+      requirement(
+        "federation-assertion",
+        "Federated data-plane SQL",
+        "DBX_TEST_FEDERATION_ASSERTION_SQL"
+      )
+    ],
+    docsUrl: `${DOCS2}#federation-delta-sharing-and-clean-rooms`,
+    certificationScopes: [SHIPPED_SCOPE]
+  });
+}
+function createSecurityCostDrTargetPack() {
+  return defineTargetPack({
+    id: "security-cost-dr",
+    name: "Networking, security posture, cost and regional DR",
+    description: "IP controls, compute policy, cost guardrail and authenticated secondary-region readiness.",
+    version: "0.1.0",
+    maturity: "shipped",
+    capabilities: [
+      "network.ip-access",
+      "security.compute-policy",
+      "cost.system-tables",
+      "dr.secondary-region"
+    ],
+    checks: () => [restrictedPrincipalCheck(), securityPostureCostCheck(), regionalDrCheck()],
+    requiredChecks: ["security-cost", "regional-dr"],
+    requirements: [
+      workspace,
+      auth,
+      warehouse,
+      requirement(
+        "ip-access-list",
+        "Enabled workspace IP access list",
+        "DBX_TEST_IP_ACCESS_LIST_ID"
+      ),
+      requirement("cluster-policy", "Compute policy ID", "DBX_TEST_CLUSTER_POLICY_ID"),
+      requirement("cost-assertion", "Boolean SQL cost guardrail", "DBX_TEST_COST_ASSERTION_SQL"),
+      requirement("dr-workspace", "Secondary workspace host", "DBX_TEST_DR_HOST"),
+      requirement("dr-warehouse", "Running secondary-region warehouse", "DBX_TEST_DR_WAREHOUSE_ID"),
+      requirement("dr-assertion", "Secondary-region workload SQL", "DBX_TEST_DR_ASSERTION_SQL")
+    ],
+    docsUrl: `${DOCS2}#networking-security-cost-and-regional-dr`,
+    certificationScopes: [SHIPPED_SCOPE]
+  });
+}
+function createAdvancedTargetPacks() {
+  return [
+    createAdvancedStreamingTargetPack(),
+    createAiBiGenieTargetPack(),
+    createMlflowLifecycleTargetPack(),
+    createFeatureEngineeringTargetPack(),
+    createModelServingTargetPack(),
+    createVectorRagAgentsTargetPack(),
+    createFederationSharingTargetPack(),
+    createSecurityCostDrTargetPack()
+  ];
+}
+
 // src/builtin-packs.ts
 function createBuiltinTargetPacks() {
-  return [...createFoundationTargetPacks(), createLakeflowJobsTargetPack()];
+  return [
+    ...createFoundationTargetPacks(),
+    createLakeflowJobsTargetPack(),
+    ...createAdvancedTargetPacks()
+  ];
 }
 var builtinTargetPacks = createBuiltinTargetPacks();
 
@@ -2067,7 +3154,10 @@ Object.defineProperty(exports, "waitForDatabricksStatement", {
   enumerable: true,
   get: function () { return databricks.waitForDatabricksStatement; }
 });
+exports.DatabricksAdvancedWorkloadsAdapter = DatabricksAdvancedWorkloadsAdapter;
 exports.DatabricksJobsAdapter = DatabricksJobsAdapter;
+exports.advancedStreamingCdcCheck = advancedStreamingCdcCheck;
+exports.aiBiDashboardCheck = aiBiDashboardCheck;
 exports.appHealthCheck = appHealthCheck;
 exports.assertDeltaContract = assertDeltaContract;
 exports.autoLoaderIngestionCheck = autoLoaderIngestionCheck;
@@ -2075,21 +3165,30 @@ exports.backupRestoreCheck = backupRestoreCheck;
 exports.builtinTargetPacks = builtinTargetPacks;
 exports.classicComputeCheck = classicComputeCheck;
 exports.compareToGolden = compareToGolden;
+exports.createAdvancedStreamingTargetPack = createAdvancedStreamingTargetPack;
+exports.createAdvancedTargetPacks = createAdvancedTargetPacks;
+exports.createAiBiGenieTargetPack = createAiBiGenieTargetPack;
 exports.createAppsOperationalFoundationPack = createAppsOperationalFoundationPack;
 exports.createBuiltinTargetPacks = createBuiltinTargetPacks;
 exports.createClientFromEnv = createClientFromEnv;
 exports.createDuckDbContext = createDuckDbContext;
 exports.createEphemeralLakebaseBranch = createEphemeralLakebaseBranch;
 exports.createExecutionContext = createExecutionContext;
+exports.createFeatureEngineeringTargetPack = createFeatureEngineeringTargetPack;
+exports.createFederationSharingTargetPack = createFederationSharingTargetPack;
 exports.createFoundationTargetPacks = createFoundationTargetPacks;
 exports.createJobsCodeFoundationPack = createJobsCodeFoundationPack;
 exports.createLakebaseTestProvider = createLakebaseTestProvider;
 exports.createLakeflowFoundationPack = createLakeflowFoundationPack;
 exports.createLakeflowJobsTargetPack = createLakeflowJobsTargetPack;
+exports.createMlflowLifecycleTargetPack = createMlflowLifecycleTargetPack;
 exports.createMockDatabricksClient = createMockDatabricksClient;
+exports.createModelServingTargetPack = createModelServingTargetPack;
+exports.createSecurityCostDrTargetPack = createSecurityCostDrTargetPack;
 exports.createSqlDeltaFoundationPack = createSqlDeltaFoundationPack;
 exports.createTargetPackRegistry = createTargetPackRegistry;
 exports.createUnityStorageFoundationPack = createUnityStorageFoundationPack;
+exports.createVectorRagAgentsTargetPack = createVectorRagAgentsTargetPack;
 exports.createWorkspaceContext = createWorkspaceContext;
 exports.customLiveCheck = customLiveCheck;
 exports.dbtBuildCheck = dbtBuildCheck;
@@ -2104,11 +3203,18 @@ exports.ensureVolumeDirectory = ensureVolumeDirectory;
 exports.expectQueryToMatchGolden = expectQueryToMatchGolden;
 exports.expectTable = expectTable;
 exports.failureRecoveryCheck = failureRecoveryCheck;
+exports.featureEngineeringServingCheck = featureEngineeringServingCheck;
+exports.federationSharingCleanRoomsCheck = federationSharingCleanRoomsCheck;
 exports.foundationTargetPacks = foundationTargetPacks;
+exports.genieCheck = genieCheck;
 exports.jobRunCheck = jobRunCheck;
+exports.jobsCertificationCheck = jobsCertificationCheck;
 exports.jobsOrchestrationCheck = jobsOrchestrationCheck;
 exports.lakebaseCredentialCheck = lakebaseCredentialCheck;
 exports.lakebaseRoundTripCheck = lakebaseRoundTripCheck;
+exports.lakeflowConnectCheck = lakeflowConnectCheck;
+exports.mlflowLifecycleCheck = mlflowLifecycleCheck;
+exports.modelServingCheck = modelServingCheck;
 exports.normalizeJobRun = normalizeJobRun;
 exports.normalizeRow = normalizeRow;
 exports.normalizeVolumeRoot = normalizeVolumeRoot;
@@ -2118,6 +3224,8 @@ exports.parseJobOrchestrationLiveSpec = parseJobOrchestrationLiveSpec;
 exports.parseStatementRows = parseStatementRows;
 exports.performanceBudgetCheck = performanceBudgetCheck;
 exports.pipelineRefreshCheck = pipelineRefreshCheck;
+exports.ragAgentCheck = ragAgentCheck;
+exports.regionalDrCheck = regionalDrCheck;
 exports.renderJUnit = renderJUnit;
 exports.resolveFixtureRows = resolveFixtureRows;
 exports.resolveLakebaseProject = resolveLakebaseProject;
@@ -2129,6 +3237,7 @@ exports.runLiveSuite = runLiveSuite;
 exports.runTargetPack = runTargetPack;
 exports.secretRotationCheck = secretRotationCheck;
 exports.secretScopeCheck = secretScopeCheck;
+exports.securityPostureCostCheck = securityPostureCostCheck;
 exports.serverlessComputeCheck = serverlessComputeCheck;
 exports.sqlRoundTripCheck = sqlRoundTripCheck;
 exports.toLakebaseBranchId = toLakebaseBranchId;
@@ -2136,6 +3245,7 @@ exports.toNamedParameters = toNamedParameters;
 exports.unityCatalogAccessCheck = unityCatalogAccessCheck;
 exports.uploadVolumeFile = uploadVolumeFile;
 exports.validateJobGraph = validateJobGraph;
+exports.vectorSearchCheck = vectorSearchCheck;
 exports.volumeIOCheck = volumeIOCheck;
 exports.waitForPipelineUpdate = waitForPipelineUpdate;
 //# sourceMappingURL=index.cjs.map