@fabricorg/databricks-testkit 0.2.4 → 0.4.0

package/dist/index.js

@@ -196,7 +196,8 @@ async function runLiveSuite(spec, runtime = {}) {
     finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
     success,
     required: required2,
-    results
+    results,
+    ...spec.targetPack ? { targetPack: spec.targetPack } : {}
   };
   if (spec.evidencePath)
     await writeReport(spec.evidencePath, `${JSON.stringify(evidence, null, 2)}
@@ -1072,6 +1073,824 @@ function classicComputeCheck() {
   };
 }
 
-export { appHealthCheck, assertDeltaContract, autoLoaderIngestionCheck, backupRestoreCheck, classicComputeCheck, createEphemeralLakebaseBranch, createExecutionContext, createLakebaseTestProvider, createMockDatabricksClient, customLiveCheck, dbtBuildCheck, defineLiveSuite, deleteEphemeralLakebaseBranch, deleteVolumeFile, deltaContractCheck, ensureVolumeDirectory, expectQueryToMatchGolden, expectTable, failureRecoveryCheck, jobRunCheck, lakebaseCredentialCheck, lakebaseRoundTripCheck, normalizeVolumeRoot, notebookSubmitCheck, performanceBudgetCheck, pipelineRefreshCheck, renderJUnit, resolveLakebaseProject, resolveProfile, restrictedPrincipalCheck, rollbackCheck, runLiveSuite, secretRotationCheck, secretScopeCheck, serverlessComputeCheck, sqlRoundTripCheck, toLakebaseBranchId, unityCatalogAccessCheck, uploadVolumeFile, volumeIOCheck, waitForPipelineUpdate };
+// src/target-packs.ts
+var TARGET_PACK_ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+function defineTargetPack(spec) {
+  if (!TARGET_PACK_ID.test(spec.id)) {
+    throw new Error(`Target pack id '${spec.id}' must be lowercase kebab-case`);
+  }
+  if (!spec.name.trim()) throw new Error(`Target pack '${spec.id}' requires a name`);
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(spec.version)) {
+    throw new Error(
+      `Target pack '${spec.id}' version '${spec.version}' is not semantic versioning`
+    );
+  }
+  if (spec.capabilities.length === 0) {
+    throw new Error(`Target pack '${spec.id}' must declare at least one capability`);
+  }
+  const createChecks = typeof spec.checks === "function" ? spec.checks : () => spec.checks;
+  const validateChecks = () => {
+    const checks = [...createChecks()];
+    const ids = /* @__PURE__ */ new Set();
+    for (const check of checks) {
+      if (!check.id.trim())
+        throw new Error(`Target pack '${spec.id}' contains a check without an id`);
+      if (ids.has(check.id)) {
+        throw new Error(`Target pack '${spec.id}' contains duplicate check '${check.id}'`);
+      }
+      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}'`);
+      }
+    }
+    return checks;
+  };
+  validateChecks();
+  return Object.freeze({
+    ...spec,
+    capabilities: Object.freeze([...spec.capabilities]),
+    requiredChecks: Object.freeze([...spec.requiredChecks ?? []]),
+    requirements: Object.freeze([...spec.requirements ?? []]),
+    certificationScopes: Object.freeze([...spec.certificationScopes ?? []]),
+    checks: validateChecks
+  });
+}
+function createTargetPackRegistry(packs) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const pack of packs) {
+    if (registry.has(pack.id)) throw new Error(`Duplicate target pack '${pack.id}'`);
+    registry.set(pack.id, pack);
+  }
+  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 required2 = 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)
+  }));
+  const known = new Set(checks.map((check) => check.id));
+  const missingRequirements = requirements.filter((requirement) => requirement.required && !requirement.satisfied).map((requirement) => requirement.id);
+  const missingRequiredChecks = [
+    ...checks.filter((check) => check.required && !check.configured).map((check) => check.id),
+    ...[...required2].filter((id) => !known.has(id))
+  ];
+  return {
+    pack: {
+      id: pack.id,
+      name: pack.name,
+      version: pack.version,
+      maturity: pack.maturity
+    },
+    ready: missingRequirements.length === 0 && missingRequiredChecks.length === 0,
+    requirements,
+    checks,
+    missingRequirements,
+    missingRequiredChecks
+  };
+}
+function defineTargetPackRun(pack, options = {}) {
+  const env = options.env ?? process.env;
+  const requiredChecks = [...options.requiredChecks ?? pack.requiredChecks ?? []];
+  const doctor = doctorTargetPack(pack, env, requiredChecks);
+  if (!doctor.ready) {
+    const missing = [...doctor.missingRequirements, ...doctor.missingRequiredChecks].join(", ");
+    throw new Error(`Target pack '${pack.id}' is not configured: ${missing}`);
+  }
+  const targetPack = evidenceMetadata(pack, env);
+  const suite = defineLiveSuite({
+    checks: pack.checks(),
+    required: requiredChecks,
+    env,
+    evidencePath: options.evidencePath,
+    junitPath: options.junitPath,
+    targetPack
+  });
+  return { pack, run: (runtime) => suite.run(runtime) };
+}
+async function runTargetPack(pack, options = {}, runtime) {
+  return defineTargetPackRun(pack, options).run(runtime);
+}
+function evidenceMetadata(pack, env) {
+  return {
+    id: pack.id,
+    name: pack.name,
+    version: pack.version,
+    maturity: pack.maturity,
+    capabilities: [...pack.capabilities],
+    ...pack.docsUrl ? { docsUrl: pack.docsUrl } : {},
+    certificationScopes: [...pack.certificationScopes ?? []],
+    target: compact({
+      cloud: env.DBX_TEST_CLOUD,
+      region: env.DBX_TEST_REGION,
+      workspace: env.DATABRICKS_HOST,
+      runtime: env.DBX_TEST_RUNTIME_VERSION,
+      compute: env.DBX_TEST_COMPUTE
+    })
+  };
+}
+function compact(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => Boolean(entry[1]))
+  );
+}
+
+// src/foundation-packs.ts
+var DOCS = "https://experiments.fabric.pro/docs/testing/target-packs/";
+var AZURE_SCOPE = "Azure Databricks live-gated; see certification evidence for exact runtime";
+var workspaceRequirement = {
+  id: "workspace",
+  description: "Databricks workspace host",
+  anyOf: ["DATABRICKS_HOST"]
+};
+var authRequirement = {
+  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 warehouseRequirement = {
+  id: "warehouse",
+  description: "SQL warehouse ID or HTTP path",
+  anyOf: ["DATABRICKS_WAREHOUSE_ID", "DATABRICKS_HTTP_PATH"]
+};
+function createSqlDeltaFoundationPack() {
+  return defineTargetPack({
+    id: "sql-delta",
+    name: "SQL and Delta foundation",
+    description: "SQL Statement Execution, Delta contracts, performance, recovery, backup and rollback.",
+    version: "1.0.0",
+    maturity: "live-gated",
+    capabilities: [
+      "sql.statement-execution",
+      "delta.contract",
+      "delta.time-travel",
+      "performance.sql",
+      "recovery.sql",
+      "backup-restore.delta",
+      "rollback.delta"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      sqlRoundTripCheck(),
+      deltaContractCheck(),
+      serverlessComputeCheck(),
+      performanceBudgetCheck(),
+      failureRecoveryCheck(),
+      backupRestoreCheck(),
+      rollbackCheck()
+    ],
+    requiredChecks: ["sql"],
+    requirements: [workspaceRequirement, authRequirement, warehouseRequirement],
+    docsUrl: `${DOCS}#sql-and-delta-foundation`,
+    certificationScopes: [AZURE_SCOPE]
+  });
+}
+function createLakeflowFoundationPack() {
+  return defineTargetPack({
+    id: "lakeflow-ingestion",
+    name: "Lakeflow ingestion foundation",
+    description: "Lakeflow refresh, Volumes, Auto Loader ingestion and rescued-row evidence.",
+    version: "1.0.0",
+    maturity: "live-gated",
+    capabilities: [
+      "lakeflow.refresh",
+      "autoloader.ingestion",
+      "volumes.files",
+      "delta.rescued-data"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      pipelineRefreshCheck(),
+      volumeIOCheck(),
+      autoLoaderIngestionCheck()
+    ],
+    requiredChecks: ["pipeline"],
+    requirements: [workspaceRequirement, authRequirement],
+    docsUrl: `${DOCS}#lakeflow-ingestion-foundation`,
+    certificationScopes: [AZURE_SCOPE]
+  });
+}
+function createJobsCodeFoundationPack() {
+  return defineTargetPack({
+    id: "jobs-code",
+    name: "Jobs and code foundation",
+    description: "Jobs, notebooks, dbt, serverless compute and classic compute probes.",
+    version: "1.0.0",
+    maturity: "live-gated",
+    capabilities: [
+      "jobs.run-now",
+      "jobs.submit.notebook",
+      "jobs.submit.dbt",
+      "compute.serverless",
+      "compute.classic"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      jobRunCheck(),
+      notebookSubmitCheck(),
+      dbtBuildCheck(),
+      serverlessComputeCheck(),
+      classicComputeCheck()
+    ],
+    requiredChecks: ["jobs"],
+    requirements: [workspaceRequirement, authRequirement],
+    docsUrl: `${DOCS}#jobs-and-code-foundation`,
+    certificationScopes: [AZURE_SCOPE]
+  });
+}
+function createUnityStorageFoundationPack() {
+  return defineTargetPack({
+    id: "unity-storage",
+    name: "Unity Catalog and storage foundation",
+    description: "Unity Catalog allow/deny, Volumes, secret metadata and secret rotation.",
+    version: "1.0.0",
+    maturity: "live-gated",
+    capabilities: [
+      "unity-catalog.permissions",
+      "volumes.files",
+      "secrets.metadata",
+      "secrets.rotation"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      unityCatalogAccessCheck(),
+      volumeIOCheck(),
+      secretScopeCheck(),
+      secretRotationCheck()
+    ],
+    requiredChecks: ["uc-grants"],
+    requirements: [workspaceRequirement, authRequirement, warehouseRequirement],
+    docsUrl: `${DOCS}#unity-catalog-and-storage-foundation`,
+    certificationScopes: [AZURE_SCOPE]
+  });
+}
+function createAppsOperationalFoundationPack() {
+  return defineTargetPack({
+    id: "apps-operational",
+    name: "Apps and operational data foundation",
+    description: "Databricks Apps resources and health plus Lakebase OAuth and pool refresh.",
+    version: "1.0.0",
+    maturity: "live-gated",
+    capabilities: [
+      "apps.health",
+      "apps.resources",
+      "lakebase.credentials",
+      "lakebase.round-trip",
+      "lakebase.pool-refresh"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      appHealthCheck(),
+      lakebaseCredentialCheck(),
+      lakebaseRoundTripCheck()
+    ],
+    requiredChecks: ["app"],
+    requirements: [workspaceRequirement, authRequirement],
+    docsUrl: `${DOCS}#apps-and-operational-data-foundation`,
+    certificationScopes: [AZURE_SCOPE]
+  });
+}
+function createFoundationTargetPacks() {
+  return [
+    createSqlDeltaFoundationPack(),
+    createLakeflowFoundationPack(),
+    createJobsCodeFoundationPack(),
+    createUnityStorageFoundationPack(),
+    createAppsOperationalFoundationPack()
+  ];
+}
+var foundationTargetPacks = createFoundationTargetPacks();
+var DatabricksJobsAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async submit(request) {
+    validateJobGraph(request.tasks);
+    const response = await this.client.post(
+      "/api/2.1/jobs/runs/submit",
+      request
+    );
+    if (!response.run_id) throw new Error("Databricks Jobs submit returned no run_id");
+    return response.run_id;
+  }
+  async get(runId) {
+    const raw = await this.client.get("/api/2.1/jobs/runs/get", {
+      run_id: runId,
+      include_history: true,
+      include_resolved_values: true
+    });
+    return normalizeJobRun(runId, raw);
+  }
+  async wait(runId, options = {}) {
+    const raw = await waitForDatabricksRun(this.client, runId, {
+      timeoutMs: options.timeoutMs,
+      pollIntervalMs: options.pollIntervalMs
+    });
+    return normalizeJobRun(runId, raw);
+  }
+  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");
+  const keys = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    if (!/^[A-Za-z0-9_-]{1,100}$/.test(task.task_key)) {
+      throw new Error(`Invalid task key '${task.task_key}'`);
+    }
+    if (keys.has(task.task_key)) throw new Error(`Duplicate task key '${task.task_key}'`);
+    keys.add(task.task_key);
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const dependencies = (task.depends_on ?? []).map((dependency) => dependency.task_key);
+    for (const dependency of dependencies) {
+      if (!keys.has(dependency)) {
+        throw new Error(`Task '${task.task_key}' depends on unknown task '${dependency}'`);
+      }
+      if (dependency === task.task_key) {
+        throw new Error(`Task '${task.task_key}' cannot depend on itself`);
+      }
+    }
+    edges.set(task.task_key, dependencies);
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (key) => {
+    if (visiting.has(key)) throw new Error(`Jobs task graph contains a cycle at '${key}'`);
+    if (visited.has(key)) return;
+    visiting.add(key);
+    for (const dependency of edges.get(key) ?? []) visit(dependency);
+    visiting.delete(key);
+    visited.add(key);
+  };
+  for (const key of keys) visit(key);
+}
+function jobsOrchestrationCheck() {
+  return {
+    id: "jobs-orchestration",
+    description: "Lakeflow Jobs multi-task orchestration reaches expected task outcomes",
+    configured: (env) => Boolean(env.DBX_TEST_JOBS_ORCHESTRATION_JSON),
+    async run({ env, client }) {
+      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, {
+        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);
+        repairId = await adapter.repair(runId, {
+          rerunTasks: failed.length > 0 ? failed : void 0,
+          rerunDependentTasks: true
+        });
+        run = await adapter.waitForRepair(runId, repairId, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+      }
+      const expectedResult = spec.expectedResult ?? "SUCCESS";
+      if (run.resultState !== expectedResult) {
+        throw new Error(
+          `Job orchestration run ${runId} ended in ${run.resultState}, expected ${expectedResult}`
+        );
+      }
+      for (const [taskKey, expected] of Object.entries(spec.expectedTasks ?? {})) {
+        const task = run.tasks.find((candidate) => candidate.taskKey === taskKey);
+        if (!task) throw new Error(`Job orchestration result did not include task '${taskKey}'`);
+        if (task.resultState !== expected) {
+          throw new Error(`Task '${taskKey}' ended in ${task.resultState}, expected ${expected}`);
+        }
+      }
+      let cancellation;
+      if (spec.cancellation) {
+        const cancellationRunId = await adapter.submit(spec.cancellation.request);
+        await adapter.waitUntilActive(cancellationRunId, {
+          timeoutMs: Number(env.DBX_TEST_TIMEOUT_MS ?? 9e5),
+          pollIntervalMs: Number(env.DBX_TEST_POLL_INTERVAL_MS ?? 1e4)
+        });
+        await adapter.cancel(cancellationRunId);
+        const canceled = await adapter.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,
+        ...cancellation ? { cancellation } : {}
+      };
+    }
+  };
+}
+function parseJobOrchestrationLiveSpec(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`DBX_TEST_JOBS_ORCHESTRATION_JSON is invalid JSON: ${String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Jobs orchestration spec must be an object");
+  }
+  const spec = parsed;
+  if (!spec.request || typeof spec.request !== "object" || !Array.isArray(spec.request.tasks)) {
+    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 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);
+    return {
+      taskKey: String(task.task_key ?? "unknown"),
+      ...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 } : {},
+      ...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"}/${randomUUID()}`;
+      const paths = Object.fromEntries(
+        Object.keys(NOTEBOOKS).map((name) => [name, `${root}/${name}`])
+      );
+      try {
+        await importNotebooks(client, paths);
+        const adapter = new DatabricksJobsAdapter(client);
+        const runId = await adapter.submit(certificationRequest(paths));
+        const initial = await adapter.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 adapter.repair(runId, {
+          rerunTasks: ["repair"],
+          rerunDependentTasks: true
+        });
+        const repaired = await adapter.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 adapter.submit(cancellationRequest(paths));
+        await adapter.waitUntilActive(cancellationRunId, waitOptions(env));
+        await adapter.cancel(cancellationRunId);
+        const canceled = await adapter.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() {
+  return defineTargetPack({
+    id: "lakeflow-jobs",
+    name: "Lakeflow Jobs orchestration",
+    description: "Typed multi-task DAG, branch/loop, retry, cancellation, repair and task-outcome validation.",
+    version: "0.2.0",
+    maturity: "live-gated",
+    capabilities: [
+      "jobs.multi-task-dag",
+      "jobs.dependencies",
+      "jobs.condition-task",
+      "jobs.for-each-task",
+      "jobs.retry",
+      "jobs.cancel",
+      "jobs.repair",
+      "jobs.task-outcomes"
+    ],
+    checks: () => [
+      restrictedPrincipalCheck(),
+      jobRunCheck(),
+      jobsOrchestrationCheck(),
+      jobsCertificationCheck()
+    ],
+    requiredChecks: ["jobs-orchestration"],
+    requirements: [
+      {
+        id: "workspace",
+        description: "Databricks workspace host",
+        anyOf: ["DATABRICKS_HOST"]
+      },
+      {
+        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
+      },
+      {
+        id: "orchestration-spec",
+        description: "JSON multi-task orchestration scenario",
+        anyOf: ["DBX_TEST_JOBS_ORCHESTRATION_JSON"],
+        required: false
+      }
+    ],
+    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/builtin-packs.ts
+function createBuiltinTargetPacks() {
+  return [...createFoundationTargetPacks(), createLakeflowJobsTargetPack()];
+}
+var builtinTargetPacks = createBuiltinTargetPacks();
+
+export { DatabricksJobsAdapter, appHealthCheck, assertDeltaContract, autoLoaderIngestionCheck, backupRestoreCheck, builtinTargetPacks, classicComputeCheck, createAppsOperationalFoundationPack, createBuiltinTargetPacks, createEphemeralLakebaseBranch, createExecutionContext, createFoundationTargetPacks, createJobsCodeFoundationPack, createLakebaseTestProvider, createLakeflowFoundationPack, createLakeflowJobsTargetPack, createMockDatabricksClient, createSqlDeltaFoundationPack, createTargetPackRegistry, createUnityStorageFoundationPack, customLiveCheck, dbtBuildCheck, defineLiveSuite, defineTargetPack, defineTargetPackRun, deleteEphemeralLakebaseBranch, deleteVolumeFile, deltaContractCheck, doctorTargetPack, ensureVolumeDirectory, expectQueryToMatchGolden, expectTable, failureRecoveryCheck, foundationTargetPacks, jobRunCheck, jobsCertificationCheck, jobsOrchestrationCheck, lakebaseCredentialCheck, lakebaseRoundTripCheck, normalizeJobRun, normalizeVolumeRoot, notebookSubmitCheck, parseJobOrchestrationLiveSpec, performanceBudgetCheck, pipelineRefreshCheck, renderJUnit, resolveLakebaseProject, resolveProfile, restrictedPrincipalCheck, rollbackCheck, runLiveSuite, runTargetPack, secretRotationCheck, secretScopeCheck, serverlessComputeCheck, sqlRoundTripCheck, toLakebaseBranchId, unityCatalogAccessCheck, uploadVolumeFile, validateJobGraph, volumeIOCheck, waitForPipelineUpdate };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map