@dbsp/core 3.1.0 → 3.3.0

package/dist/index.js

@@ -3430,8 +3430,15 @@ function capabilityAvailable(descriptor, context) {
     }
   }
 }
+var RETIRED_CONNECTION_OWNERSHIP_MEMBERS = ["checkout", "release"];
+function retiredConnectionOwnershipMember(value) {
+  return RETIRED_CONNECTION_OWNERSHIP_MEMBERS.find((member) => member in value);
+}
 function isOperationRuntime(semantics) {
-  return "checkout" in semantics && "release" in semantics && "writeIntentJournal" in semantics && "begin" in semantics && "setLockTimeout" in semantics && "acquireLocks" in semantics && "observeContext" in semantics && "observeOperation" in semantics && "checkGuard" in semantics && "executeOperation" in semantics && "writeCompletionJournal" in semantics && "commit" in semantics && "rollback" in semantics && "writeObservedJournal" in semantics && "isLockTimeout" in semantics;
+  if (retiredConnectionOwnershipMember(semantics) !== void 0) {
+    return false;
+  }
+  return "writeIntentJournal" in semantics && "begin" in semantics && "setLockTimeout" in semantics && "acquireLocks" in semantics && "observeContext" in semantics && "observeOperation" in semantics && "checkGuard" in semantics && "executeOperation" in semantics && "writeCompletionJournal" in semantics && "commit" in semantics && "rollback" in semantics && "writeObservedJournal" in semantics && "isLockTimeout" in semantics;
 }
 function validateRulePrecedenceFacts(facts, rules) {
   const rulesByKey = new Map(rules.map((rule) => [ruleKey(rule), rule]));
@@ -3574,6 +3581,12 @@ var PackRegistry = class {
       compositionFactOwnerByKind.set(kind, owner);
     };
     for (const pack of packs) {
+      const retiredMember = pack.executionCoordinator ? retiredConnectionOwnershipMember(pack.executionCoordinator) : void 0;
+      if (retiredMember !== void 0) {
+        throw new Error(
+          `transition pack executionCoordinator declares retired connection ownership member ${retiredMember}`
+        );
+      }
       const transactionDomain = pack.transactionDomain ?? pack.executionCoordinator?.transactionDomain;
       if (pack.executionCoordinator && !transactionDomain) {
         throw new Error(
@@ -3892,6 +3905,129 @@ function assumptionAccepted(assumption, policy) {
 // src/transition/resume.ts
 import { createHash as createHash2 } from "crypto";
 
+// src/transition/transition-lessor.ts
+var TRANSITION_LESSOR_BRAND = /* @__PURE__ */ Symbol.for("dbsp.transition.lessor");
+var TRANSITION_LESSOR_PROTOCOL_VERSION = 1;
+var TRANSITION_LESSOR_REJECTION = "transition target must be a core-minted lessor";
+async function captureLease(value) {
+  const { query, release } = leaseMembers(value);
+  if (typeof query !== "function" || typeof release !== "function") {
+    const rejection = new Error(
+      "A transition lessor must acquire a lease exposing query() and release(). This acquisition returned an unusable member pair."
+    );
+    releaseMalformedAcquisition(value, release, rejection);
+    throw rejection;
+  }
+  return {
+    raw: value,
+    query,
+    release
+  };
+}
+async function acquireTransitionLease(target) {
+  const { raw: raw2, query, release } = await captureLease(await target.acquire());
+  let closed = false;
+  const session = Object.freeze({
+    query: (sql2, params) => {
+      if (closed) {
+        return Promise.reject(
+          new Error("transition lease was already given back")
+        );
+      }
+      return query.call(raw2, sql2, params);
+    }
+  });
+  const releaseLease = (failure) => {
+    if (closed) {
+      return Promise.resolve();
+    }
+    closed = true;
+    try {
+      const returned = failure ? release.call(raw2, releaseArgument(failure)) : release.call(raw2);
+      void Promise.resolve(returned).catch(() => void 0);
+    } catch {
+    }
+    return Promise.resolve();
+  };
+  return Object.freeze({
+    session,
+    release: releaseLease
+  });
+}
+function leaseMembers(value) {
+  if (value == null || typeof value !== "object" && typeof value !== "function") {
+    return { query: void 0, release: void 0 };
+  }
+  const release = readMember(value, "release");
+  return { query: readMember(value, "query"), release };
+}
+function readMember(value, member) {
+  try {
+    return value[member];
+  } catch {
+    return void 0;
+  }
+}
+function releaseMalformedAcquisition(value, release, rejection) {
+  if (typeof release !== "function") {
+    return;
+  }
+  try {
+    void Promise.resolve(release.call(value, rejection)).catch(() => void 0);
+  } catch {
+  }
+}
+function createTransitionLessor(acquire) {
+  const lessor = { acquire };
+  Object.defineProperty(lessor, TRANSITION_LESSOR_BRAND, {
+    value: Object.freeze({
+      protocolVersion: TRANSITION_LESSOR_PROTOCOL_VERSION
+    }),
+    writable: false,
+    configurable: false
+  });
+  return Object.freeze(lessor);
+}
+function isTransitionLessor(value) {
+  try {
+    if (value == null || typeof value !== "object" && typeof value !== "function" || Array.isArray(value)) {
+      return false;
+    }
+    const brand = value[TRANSITION_LESSOR_BRAND];
+    return brand != null && typeof brand === "object" && brand.protocolVersion === TRANSITION_LESSOR_PROTOCOL_VERSION && typeof value.acquire === "function";
+  } catch {
+    return false;
+  }
+}
+var TransitionLeaseFailureError = class extends Error {
+  constructor(cause) {
+    super("transition lease released after a failure", { cause });
+    this.name = "TransitionLeaseFailureError";
+  }
+};
+function releaseArgument(failure) {
+  return failure.error ? failure.error : new TransitionLeaseFailureError(failure.error);
+}
+function transitionLessorRejectionAssessment(artifact, lifecycle = "planned") {
+  return {
+    decision: "blocked",
+    assurance: "unproven",
+    lifecycle,
+    continuation: "human-intervention-required",
+    reasons: [
+      {
+        code: "context-mismatch",
+        artifact,
+        fact: {
+          key: "transition-lessor",
+          value: TRANSITION_LESSOR_REJECTION
+        },
+        scope: []
+      }
+    ]
+  };
+}
+
 // src/transition/validation.ts
 function sameTrustRoot2(left, right) {
   return stableJson(left) === stableJson(right);
@@ -4787,6 +4923,11 @@ function latestIntent(step, events) {
     recordedAt: recordedAt()
   };
 }
+function orderedPlanSteps(plan2, stepById) {
+  return plan2.segments.flatMap(
+    (segment) => segment.stepIds.map((stepId2) => stepById.get(stepId2)).filter((step) => step !== void 0)
+  );
+}
 function resumeRequiredResult(params) {
   const hasCompleted = params.completed.length > 0;
   return {
@@ -4925,80 +5066,71 @@ function completedJournal(intent, completion, observations) {
     observedOutcome
   };
 }
-async function observeStep(registry, step, target, baseContext, phase) {
+async function withObservedStep(registry, step, target, baseContext, phase, use) {
   const resolution = registry.resolveOperation(step.operation);
   if (!resolution.ok || !isOperationRuntime(resolution.semantics)) {
-    return { ok: false, detail: "operation runtime missing" };
+    return use({ ok: false, detail: "operation runtime missing" });
   }
   const runtime = resolution.semantics;
   const issuer = registry.resolveIssuer(step.operation.operationKind.artifact);
   if (!issuer) {
-    return { ok: false, detail: "operation observation issuer missing" };
+    return use({ ok: false, detail: "operation observation issuer missing" });
   }
-  let client;
+  let lease;
+  let failed = false;
+  let failure;
   try {
-    client = await runtime.checkout(target);
-    let context = await runtime.observeContext(
-      client,
-      step.operation,
-      baseContext
-    );
-    context = registry.contextWithDerivedCapabilities(context);
-    const liveContextMatch = matchLiveObservationContext({
-      expected: baseContext,
-      actual: context
-    });
-    if (!liveContextMatch.ok) {
-      await runtimeSafeRelease(runtime, client);
-      return { ok: false, detail: liveContextMatch.detail };
-    }
-    const observed = await runtime.observeOperation(
-      client,
-      step.operation,
-      context,
-      phase,
-      issuer
-    );
-    return {
-      ok: true,
-      observations: observed.observations,
-      fingerprint: observed.fingerprint,
-      client,
-      runtime
-    };
-  } catch (error) {
-    if (client) {
-      await runtimeSafeRelease(
-        resolution.ok && isOperationRuntime(resolution.semantics) ? resolution.semantics : void 0,
+    let observation;
+    try {
+      lease = await acquireTransitionLease(target);
+      const client = { opaqueClient: lease.session };
+      let context = await runtime.observeContext(
         client,
-        error
+        step.operation,
+        baseContext
       );
+      context = registry.contextWithDerivedCapabilities(context);
+      const liveContextMatch = matchLiveObservationContext({
+        expected: baseContext,
+        actual: context
+      });
+      if (!liveContextMatch.ok) {
+        observation = { ok: false, detail: liveContextMatch.detail };
+      } else {
+        const observed = await runtime.observeOperation(
+          client,
+          step.operation,
+          context,
+          phase,
+          issuer
+        );
+        observation = {
+          ok: true,
+          observations: observed.observations,
+          fingerprint: observed.fingerprint,
+          writeJournal: async (journal) => runtime.writeObservedJournal(client, journal)
+        };
+      }
+    } catch (error) {
+      failed = true;
+      failure = error;
+      observation = {
+        ok: false,
+        detail: error instanceof Error ? error.message : "observation failed"
+      };
+    }
+    try {
+      return await use(observation);
+    } catch (error) {
+      failed = true;
+      failure = error;
+      throw error;
+    }
+  } finally {
+    if (lease) {
+      await lease.release(failed ? { error: failure } : void 0);
     }
-    return {
-      ok: false,
-      detail: error instanceof Error ? error.message : "observation failed"
-    };
-  }
-}
-async function runtimeSafeRelease(runtime, client, error) {
-  if (!runtime) {
-    return;
-  }
-  try {
-    await runtime.release(client, error);
-  } catch {
-  }
-}
-async function releaseObservedAttempt(attempt, error) {
-  if (attempt.ok) {
-    await runtimeSafeRelease(attempt.runtime, attempt.client, error);
-  }
-}
-async function writeObserved(attempt, journal) {
-  if (!attempt.ok) {
-    return;
   }
-  await attempt.runtime.writeObservedJournal(attempt.client, journal);
 }
 function stepAssumption(plan2, assumptionId2) {
   return plan2.assumptions.find((assumption) => assumption.id === assumptionId2);
@@ -5035,6 +5167,43 @@ async function resumeTransitionRun(registry, input) {
   if (!evidenceContext) {
     return contextMismatch("loaded plan contains no durable evidence context");
   }
+  const referencedAssumptions = /* @__PURE__ */ new Set();
+  for (const step of loaded.plan.steps) {
+    for (const assumptionId2 of step.restsOnAssumptions) {
+      referencedAssumptions.add(assumptionId2);
+    }
+    const policyFailure = validatePolicyForStep(
+      loaded.plan,
+      step,
+      input.policy
+    );
+    if (policyFailure) {
+      return policyFailure;
+    }
+  }
+  for (const assumption of loaded.plan.assumptions) {
+    if (!referencedAssumptions.has(assumption.id) && !assumptionAccepted(assumption, input.policy)) {
+      return unacceptedPlanAssumption(loaded.plan, assumption);
+    }
+  }
+  const stepById = new Map(
+    loaded.plan.steps.map((step) => [step.stepId, step])
+  );
+  const groupedResult = groupEvents(loaded.events, loaded.run.runId, stepById);
+  if (!groupedResult.ok) {
+    return contextMismatch(groupedResult.detail);
+  }
+  const grouped = groupedResult.grouped;
+  if (!isTransitionLessor(input.target)) {
+    return {
+      assessment: transitionLessorRejectionAssessment(
+        RESUMER_ARTIFACT,
+        loaded.events.length === 0 ? "planned" : "outcome-unknown"
+      ),
+      journals: [],
+      observations: []
+    };
+  }
   const baseContext = await input.readContext(input.target, loaded.run);
   const runContextMatch = matchRunObservationContext({
     run: loaded.run,
@@ -5074,36 +5243,7 @@ async function resumeTransitionRun(registry, input) {
       `loaded plan failed semantic invariant validation: ${semanticDiagnostic.detail}`
     );
   }
-  const referencedAssumptions = /* @__PURE__ */ new Set();
-  for (const step of loaded.plan.steps) {
-    for (const assumptionId2 of step.restsOnAssumptions) {
-      referencedAssumptions.add(assumptionId2);
-    }
-    const policyFailure = validatePolicyForStep(
-      loaded.plan,
-      step,
-      input.policy
-    );
-    if (policyFailure) {
-      return policyFailure;
-    }
-  }
-  for (const assumption of loaded.plan.assumptions) {
-    if (!referencedAssumptions.has(assumption.id) && !assumptionAccepted(assumption, input.policy)) {
-      return unacceptedPlanAssumption(loaded.plan, assumption);
-    }
-  }
-  const stepById = new Map(
-    loaded.plan.steps.map((step) => [step.stepId, step])
-  );
-  const groupedResult = groupEvents(loaded.events, loaded.run.runId, stepById);
-  if (!groupedResult.ok) {
-    return contextMismatch(groupedResult.detail);
-  }
-  const grouped = groupedResult.grouped;
-  const orderedSteps = loaded.plan.segments.flatMap(
-    (segment) => segment.stepIds.map((stepId2) => stepById.get(stepId2)).filter(Boolean)
-  );
+  const orderedSteps = orderedPlanSteps(loaded.plan, stepById);
   const completed = [];
   const observations = [];
   for (const step of orderedSteps) {
@@ -5138,65 +5278,90 @@ async function resumeTransitionRun(registry, input) {
     }
     const transactional = effects.effects.execution.transaction !== "forbids-transaction";
     if (observedJournal?.outcome === "completed" || completion) {
-      const after2 = await observeStep(
+      const after2 = await withObservedStep(
         registry,
         step,
         input.target,
         baseContext,
-        "after"
+        "after",
+        async (observation) => {
+          if (!observation.ok || !fingerprintMatches(step.expectedAfter, observation.fingerprint)) {
+            return {
+              kind: "unmatched",
+              detail: observation.ok ? "current fingerprint no longer matches expectedAfter" : observation.detail
+            };
+          }
+          const journal = observedJournal?.outcome === "completed" ? observedJournal : completedJournal(intent, completion, observation.observations);
+          if (!observedJournal) {
+            await observation.writeJournal(journal);
+          }
+          return {
+            kind: "completed",
+            observations: observation.observations,
+            journal
+          };
+        }
       );
-      if (after2.ok && fingerprintMatches(step.expectedAfter, after2.fingerprint)) {
+      if (after2.kind === "completed") {
         observations.push(...after2.observations);
-        const journal = observedJournal?.outcome === "completed" ? observedJournal : completedJournal(intent, completion, after2.observations);
-        if (!observedJournal) {
-          await writeObserved(after2, journal);
-        }
-        await releaseObservedAttempt(after2);
-        completed.push(journal);
+        completed.push(after2.journal);
         continue;
       }
-      await releaseObservedAttempt(after2);
       return unknownResult({
         step,
         completed,
         observations,
-        detail: after2.ok ? "current fingerprint no longer matches expectedAfter" : after2.detail
+        detail: after2.detail
       });
     }
     if (transactional) {
-      const before2 = await observeStep(
+      const before2 = await withObservedStep(
         registry,
         step,
         input.target,
         baseContext,
-        "before"
+        "before",
+        async (observation) => ({
+          kind: observation.ok && fingerprintMatches(step.expectedBefore, observation.fingerprint) ? "resume-required" : "unmatched",
+          observations: observation.ok ? observation.observations : []
+        })
       );
-      if (before2.ok && fingerprintMatches(step.expectedBefore, before2.fingerprint)) {
+      if (before2.kind === "resume-required") {
         observations.push(...before2.observations);
-        await releaseObservedAttempt(before2);
         return resumeRequiredResult({
           step,
           completed,
           observations
         });
       }
-      await releaseObservedAttempt(before2);
-      const after2 = await observeStep(
+      const after2 = await withObservedStep(
         registry,
         step,
         input.target,
         baseContext,
-        "after"
+        "after",
+        async (observation) => {
+          if (!observation.ok || !fingerprintMatches(step.expectedAfter, observation.fingerprint)) {
+            return { kind: "unmatched" };
+          }
+          const journal = completedJournal(
+            intent,
+            void 0,
+            observation.observations
+          );
+          await observation.writeJournal(journal);
+          return {
+            kind: "completed",
+            observations: observation.observations,
+            journal
+          };
+        }
       );
-      if (after2.ok && fingerprintMatches(step.expectedAfter, after2.fingerprint)) {
+      if (after2.kind === "completed") {
         observations.push(...after2.observations);
-        const journal = completedJournal(intent, void 0, after2.observations);
-        await writeObserved(after2, journal);
-        await releaseObservedAttempt(after2);
-        completed.push(journal);
+        completed.push(after2.journal);
         continue;
       }
-      await releaseObservedAttempt(after2);
       return unknownResult({
         step,
         completed,
@@ -5204,39 +5369,53 @@ async function resumeTransitionRun(registry, input) {
         detail: "transactional intent had no completion and current state matches neither expectedBefore nor expectedAfter"
       });
     }
-    const after = await observeStep(
+    const after = await withObservedStep(
       registry,
       step,
       input.target,
       baseContext,
-      "after"
+      "after",
+      async (observation) => {
+        if (!observation.ok || !fingerprintMatches(step.expectedAfter, observation.fingerprint)) {
+          return { kind: "unmatched" };
+        }
+        const journal = completedJournal(
+          intent,
+          void 0,
+          observation.observations
+        );
+        await observation.writeJournal(journal);
+        return {
+          kind: "completed",
+          observations: observation.observations,
+          journal
+        };
+      }
     );
-    if (after.ok && fingerprintMatches(step.expectedAfter, after.fingerprint)) {
+    if (after.kind === "completed") {
       observations.push(...after.observations);
-      const journal = completedJournal(intent, void 0, after.observations);
-      await writeObserved(after, journal);
-      await releaseObservedAttempt(after);
-      completed.push(journal);
+      completed.push(after.journal);
       continue;
     }
-    await releaseObservedAttempt(after);
-    const before = await observeStep(
+    const before = await withObservedStep(
       registry,
       step,
       input.target,
       baseContext,
-      "before"
+      "before",
+      async (observation) => ({
+        kind: observation.ok && fingerprintMatches(step.expectedBefore, observation.fingerprint) ? "resume-required" : "unmatched",
+        observations: observation.ok ? observation.observations : []
+      })
     );
-    if (before.ok && fingerprintMatches(step.expectedBefore, before.fingerprint)) {
+    if (before.kind === "resume-required") {
       observations.push(...before.observations);
-      await releaseObservedAttempt(before);
       return resumeRequiredResult({
         step,
         completed,
         observations
       });
     }
-    await releaseObservedAttempt(before);
     return unknownResult({
       step,
       completed,
@@ -5801,16 +5980,25 @@ function createApplier(registry) {
           );
         }
         let client;
+        let lease;
         let committed = false;
         let transactionStarted = false;
-        let releaseError;
+        let releaseFailure;
         let active = first;
         let activeContext = runtimeContext;
         let activeOperationAttempted = false;
         let activeNonRollbackableOperationExecuted = false;
         const completedInSegment = [];
+        if (!isTransitionLessor(target)) {
+          return resultWithCommittedJournals({
+            assessment: transitionLessorRejectionAssessment(APPLIER_ARTIFACT),
+            journals: [],
+            observations: []
+          });
+        }
         try {
-          client = await segmentCoordinator.checkout(target);
+          lease = await acquireTransitionLease(target);
+          client = { opaqueClient: lease.session };
           const executionClient = client;
           if (transactional) {
             await segmentCoordinator.begin(executionClient);
@@ -6361,7 +6549,7 @@ function createApplier(registry) {
             journals.push(journal);
           }
         } catch (error) {
-          releaseError = error;
+          releaseFailure = { error };
           if (error instanceof CommitOutcomeUncertainError) {
             if (client && transactionStarted) {
               await segmentCoordinator.rollback(client).catch(() => void 0);
@@ -6608,11 +6796,8 @@ function createApplier(registry) {
             outcomeDurable: true
           });
         } finally {
-          if (client) {
-            try {
-              await segmentCoordinator.release(client, releaseError);
-            } catch {
-            }
+          if (lease) {
+            await lease.release(releaseFailure);
           }
         }
       }
@@ -9674,22 +9859,8 @@ function validateIssuedObservation(observation, context) {
     detail: `observation ${observation.id ?? "unknown"} has an invalid role`
   };
 }
-function transitionPool(target) {
-  if (isJsonObject3(target) && typeof target.connect === "function" && typeof target.release !== "function") {
-    return target;
-  }
-  throw new Error(
-    "transition proof target must be a Pool-like object with connect(); checked-out clients are not accepted"
-  );
-}
 async function checkoutProofClient(target) {
-  const client = await transitionPool(target).connect();
-  if (!isJsonObject3(client) || typeof client.query !== "function" || typeof client.release !== "function") {
-    throw new Error(
-      "transition proof pool returned a client without query() and release()"
-    );
-  }
-  return client;
+  return acquireTransitionLease(target);
 }
 function conclusionForObligation(obligation, evidence, expectedContext) {
   const result = concludeEvidenceForObligation({
@@ -10326,13 +10497,15 @@ async function proveTransitions(registry, compare, target, context, initialState
   let minServerVersionRequests = /* @__PURE__ */ new Map();
   const obligationClaimByCanonicalKey = /* @__PURE__ */ new Map();
   const multiCandidateSnapshot = !initialState && compare.candidates.length > 1;
+  let sharedLease;
   let sharedClient;
-  let sharedReleaseError;
+  let sharedReleaseFailure;
   const sharedIssuedRequestKeys = /* @__PURE__ */ new Set();
   let sharedIssued = { evidence: [], advisory: [] };
   try {
     if (multiCandidateSnapshot) {
-      sharedClient = await checkoutProofClient(target);
+      sharedLease = await checkoutProofClient(target);
+      sharedClient = sharedLease.session;
       const allRequiredObservations = [];
       for (const candidate of compare.candidates) {
         const rule = registry.resolveRule(candidate.rule);
@@ -10506,10 +10679,12 @@ async function proveTransitions(registry, compare, target, context, initialState
           issued = appendIssued(sharedIssued, additional);
           sharedIssued = appendIssued(sharedIssued, additional);
         } else {
+          let lease;
           let client;
-          let releaseError;
+          let releaseFailure;
           try {
-            client = await checkoutProofClient(target);
+            lease = await checkoutProofClient(target);
+            client = lease.session;
             proofContext = issuer.readContext ? await issuer.readContext(client, context, requiredObservations) : context;
             proofContext = registry.contextWithDerivedCapabilities(proofContext);
             const supportMismatch = ruleSupportMismatch(rule, proofContext);
@@ -10529,7 +10704,7 @@ async function proveTransitions(registry, compare, target, context, initialState
               proofContext
             );
           } catch (error) {
-            releaseError = error;
+            releaseFailure = { error };
             return {
               kind: "blocked",
               assessment: artifactMismatch(
@@ -10538,8 +10713,8 @@ async function proveTransitions(registry, compare, target, context, initialState
               )
             };
           } finally {
-            if (client) {
-              client.release(releaseError);
+            if (lease) {
+              await lease.release(releaseFailure);
             }
           }
         }
@@ -10886,7 +11061,7 @@ async function proveTransitions(registry, compare, target, context, initialState
       planAssumptions.push(...assumptions2);
     }
   } catch (error) {
-    sharedReleaseError = error;
+    sharedReleaseFailure = { error };
     return {
       kind: "blocked",
       assessment: artifactMismatch(
@@ -10895,8 +11070,8 @@ async function proveTransitions(registry, compare, target, context, initialState
       )
     };
   } finally {
-    if (sharedClient) {
-      sharedClient.release(sharedReleaseError);
+    if (sharedLease) {
+      await sharedLease.release(sharedReleaseFailure);
     }
   }
   let assumptions;
@@ -11041,11 +11216,13 @@ async function retryUnknownRecognition(registry, compare, target, context) {
   ]);
   const issuer = registry.resolveIssuer(recognition.rule.pack);
   if (issuer) {
+    let lease;
     let client;
-    let releaseError;
+    let releaseFailure;
     const issuedRequestKeys = /* @__PURE__ */ new Set();
     try {
-      client = await checkoutProofClient(target);
+      lease = await checkoutProofClient(target);
+      client = lease.session;
       let proofContext2 = issuer.readContext ? await issuer.readContext(client, context, recognitionRequests) : context;
       proofContext2 = registry.contextWithDerivedCapabilities(proofContext2);
       const supportMismatch2 = ruleSupportMismatch(rule, proofContext2);
@@ -11152,7 +11329,7 @@ async function retryUnknownRecognition(registry, compare, target, context) {
         }
       );
     } catch (error) {
-      releaseError = error;
+      releaseFailure = { error };
       return {
         kind: "blocked",
         assessment: artifactMismatch(
@@ -11161,8 +11338,8 @@ async function retryUnknownRecognition(registry, compare, target, context) {
         )
       };
     } finally {
-      if (client) {
-        client.release(releaseError);
+      if (lease) {
+        await lease.release(releaseFailure);
       }
     }
   }
@@ -11259,7 +11436,7 @@ function createProver(registry) {
         case "unsupported":
           return { kind: "blocked", assessment: unsupported(compare) };
         case "unknown":
-          return retryUnknownRecognition(registry, compare, target, context);
+          break;
         case "ambiguous":
           return { kind: "blocked", assessment: ambiguous(compare) };
         case "uncomposable":
@@ -11267,7 +11444,13 @@ function createProver(registry) {
         case "transitions":
           break;
       }
-      return proveTransitions(registry, compare, target, context);
+      if (!isTransitionLessor(target)) {
+        return {
+          kind: "blocked",
+          assessment: transitionLessorRejectionAssessment(PROVER_ARTIFACT)
+        };
+      }
+      return compare.kind === "unknown" ? retryUnknownRecognition(registry, compare, target, context) : proveTransitions(registry, compare, target, context);
     }
   };
 }
@@ -11521,6 +11704,10 @@ function projectCompareToSingleCandidate(compare, entry) {
 }
 
 // src/transition/staged-orchestrator.ts
+var STAGED_ORCHESTRATOR_ARTIFACT = {
+  id: semanticArtifactId("dbsp.core.transition.staged-orchestrator"),
+  version: "0.1.0"
+};
 function uniqueResources2(resources) {
   const byKey = /* @__PURE__ */ new Map();
   for (const resource of resources) {
@@ -11679,6 +11866,20 @@ function createStagedTransitionOrchestrator(registry) {
       const observations = [];
       const completedProgress = /* @__PURE__ */ new Set();
       const maxIterations = input.maxIterations ?? 32;
+      const targetRejectionResult = () => resultWithAggregate(
+        transitionLessorRejectionAssessment(STAGED_ORCHESTRATOR_ARTIFACT),
+        journals,
+        observations
+      );
+      const proveAtTargetBoundary = async (compare, context) => {
+        if (!isTransitionLessor(input.target)) {
+          return { kind: "target-rejected" };
+        }
+        return {
+          kind: "proof",
+          proof: await prover.prove(compare, input.target, context)
+        };
+      };
       for (let iteration = 0; iteration < maxIterations; iteration += 1) {
         const context = await input.readContext();
         const current = await input.loadCurrent();
@@ -11696,7 +11897,14 @@ function createStagedTransitionOrchestrator(registry) {
         }
         if (compare.kind !== "transitions") {
           if (compare.kind === "unknown" && hasAppliedWork(journals)) {
-            const proof2 = await prover.prove(compare, input.target, context);
+            const proofAtBoundary2 = await proveAtTargetBoundary(
+              compare,
+              context
+            );
+            if (proofAtBoundary2.kind === "target-rejected") {
+              return targetRejectionResult();
+            }
+            const { proof: proof2 } = proofAtBoundary2;
             switch (proof2.kind) {
               case "no-drift":
                 return {
@@ -11750,7 +11958,14 @@ function createStagedTransitionOrchestrator(registry) {
           );
         }
         const segmentCompare = projectCompareToSingleCandidate(compare, ready);
-        const proof = await prover.prove(segmentCompare, input.target, context);
+        const proofAtBoundary = await proveAtTargetBoundary(
+          segmentCompare,
+          context
+        );
+        if (proofAtBoundary.kind === "target-rejected") {
+          return targetRejectionResult();
+        }
+        const { proof } = proofAtBoundary;
         if (proof.kind !== "proven") {
           return resultWithAggregate(proof.assessment, journals, observations);
         }
@@ -11788,7 +12003,7 @@ function createStagedTransitionOrchestrator(registry) {
 
 // src/adapter.ts
 function supportsExecution(adapter) {
-  return "execute" in adapter && "executeOne" in adapter && typeof adapter.execute === "function";
+  return typeof adapter.execute === "function" && typeof adapter.executeOne === "function" && typeof adapter.executeOneOrThrow === "function";
 }
 function supportsStreaming(adapter) {
   return adapter.capabilities?.supportsStreaming === true && "stream" in adapter && typeof adapter.stream === "function";
@@ -14325,6 +14540,10 @@ function compileMutationIntent(adapter, intent, options) {
   );
 }
 async function runMutationWithHooks(opts) {
+  const execution = await runMutationWithHooksMeta(opts);
+  return execution.result;
+}
+async function runMutationWithHooksMeta(opts) {
   if (!opts.hookStore || !hasHooks(opts.hookStore)) {
     const prepared = opts.prepare(opts.intent);
     return prepared.execute();
@@ -14358,25 +14577,30 @@ async function runMutationWithHooksInner(opts, store) {
     }
     const prepared = opts.prepare(intent);
     const duration = Date.now() - startTime;
-    const result = await prepared.execute();
+    const execution = await prepared.execute();
+    let result = execution.result;
     if (store.afterMutation.length > 0) {
       const afterCtx = Object.freeze({
         ...ctx,
         sql: prepared.sql,
         parameters: prepared.parameters,
-        duration
+        duration,
+        ...execution.affectedRows !== void 0 ? { affectedRows: execution.affectedRows } : {}
       });
       const transformed = await runAfterMutationHooks(
         store.afterMutation,
         afterCtx,
-        [...prepared.getAfterMutationResult?.(result) ?? []],
+        [...prepared.getAfterMutationResult?.(execution.result) ?? []],
         opts.onHookError
       );
       if (prepared.returnAfterMutationResult) {
-        return prepared.mapAfterMutationResult?.(result, transformed) ?? transformed;
+        result = prepared.mapAfterMutationResult?.(result, transformed) ?? transformed;
       }
     }
-    return result;
+    return {
+      result,
+      ...execution.affectedRows !== void 0 ? { affectedRows: execution.affectedRows } : {}
+    };
   } catch (error) {
     if (store.onError.length > 0) {
       const errorCtx = {
@@ -14502,6 +14726,34 @@ var MutationBuilderBase = class {
       prepare: (preparedIntent) => this.prepareMutationExecution(adapter, preparedIntent)
     });
   }
+  async affectedRows() {
+    const adapter = this.requireAdapter(this.operationName);
+    const intent = this.buildIntent();
+    if (typeof adapter.executeWithMeta !== "function") {
+      throw new ExecutionError({
+        operation: `${this.operationName}.affectedRows`,
+        reason: "this adapter does not support affectedRows(); it does not implement executeWithMeta",
+        fix: "Use an adapter that implements executeWithMeta, or call execute() when row count metadata is not required."
+      });
+    }
+    const execution = await runMutationWithHooksMeta({
+      table: this.table,
+      intent,
+      hookStore: this.hookStore,
+      onHookError: this.onHookError,
+      schemaName: this.schemaName,
+      inTransaction: this.inTransaction,
+      prepare: (preparedIntent) => this.prepareMutationExecution(adapter, preparedIntent)
+    });
+    if (execution.affectedRows === void 0) {
+      throw new ExecutionError({
+        operation: `${this.operationName}.affectedRows`,
+        reason: "this adapter does not support affectedRows(); it did not return executeWithMeta metadata",
+        fix: "Use an adapter that implements executeWithMeta and returns rowCount metadata."
+      });
+    }
+    return execution.affectedRows;
+  }
   prepareMutationExecution(adapter, intent) {
     const compileOptions = {
       model: this.model,
@@ -14512,7 +14764,19 @@ var MutationBuilderBase = class {
       return {
         sql: compiled.sql,
         parameters: compiled.parameters,
-        execute: () => adapter.execute(compiled),
+        execute: async () => {
+          if (typeof adapter.executeWithMeta === "function") {
+            const result2 = await adapter.executeWithMeta(compiled);
+            return {
+              result: result2.rows,
+              affectedRows: result2.rowCount
+            };
+          }
+          const result = await adapter.execute(compiled);
+          return {
+            result
+          };
+        },
         getAfterMutationResult: (result) => result,
         returnAfterMutationResult: true
       };
@@ -14521,8 +14785,17 @@ var MutationBuilderBase = class {
       sql: compiled.sql,
       parameters: compiled.parameters,
       execute: async () => {
+        if (typeof adapter.executeWithMeta === "function") {
+          const result = await adapter.executeWithMeta(compiled);
+          return {
+            result: void 0,
+            affectedRows: result.rowCount
+          };
+        }
         await adapter.execute(compiled);
-        return void 0;
+        return {
+          result: void 0
+        };
       },
       getAfterMutationResult: () => []
     };
@@ -16355,12 +16628,27 @@ var NqlBuilderImpl = class {
           sql: compiled.sql,
           parameters: compiled.parameters,
           execute: async () => {
+            if (typeof adapter.executeWithMeta === "function") {
+              const metadata = await adapter.executeWithMeta(compiled);
+              const hookRows2 = metadata.rows;
+              const rawRows2 = snapshotMutationRows(hookRows2);
+              return {
+                result: {
+                  rawRows: rawRows2,
+                  hookRows: hookRows2,
+                  transformedRows: hookRows2
+                },
+                affectedRows: metadata.rowCount
+              };
+            }
             const hookRows = await adapter.execute(compiled);
             const rawRows = snapshotMutationRows(hookRows);
             return {
-              rawRows,
-              hookRows,
-              transformedRows: hookRows
+              result: {
+                rawRows,
+                hookRows,
+                transformedRows: hookRows
+              }
             };
           },
           getAfterMutationResult: (result) => hasReturning ? result.hookRows : [],
@@ -16704,6 +16992,11 @@ function extractPseudoColumnKeywords(model) {
   };
 }
 
+// src/dx/orm-instance.ts
+import {
+  convertBigintJsReadValue as convertBigintJsReadValue2
+} from "@dbsp/types";
+
 // src/dx/hierarchy-helpers.ts
 function extractRecursiveField(result, field) {
   if (result == null) return [];
@@ -17600,9 +17893,35 @@ function createUnsupportedStreamingError() {
     fix: "Use an adapter configuration that supports streaming."
   });
 }
+function hasStreamTransactionBeginOptions(options) {
+  return options != null && (options.isolationLevel !== void 0 || options.readOnly !== void 0 || options.lockTimeoutMs !== void 0 || options.statementTimeoutMs !== void 0);
+}
+function hasRuntimeStreamSignalOption(options) {
+  return typeof options === "object" && options !== null && "signal" in options;
+}
+function createAdapterStreamOptions(options) {
+  if (options === void 0 || options.chunkSize === void 0 && !hasStreamTransactionBeginOptions(options)) {
+    return void 0;
+  }
+  return {
+    ...options.chunkSize !== void 0 && { chunkSize: options.chunkSize },
+    ...options.isolationLevel !== void 0 && {
+      isolationLevel: options.isolationLevel
+    },
+    ...options.readOnly !== void 0 && { readOnly: options.readOnly },
+    ...options.lockTimeoutMs !== void 0 && {
+      lockTimeoutMs: options.lockTimeoutMs
+    },
+    ...options.statementTimeoutMs !== void 0 && {
+      statementTimeoutMs: options.statementTimeoutMs
+    }
+  };
+}
 function stream(builder, options) {
   const adapter = builder.getConfiguredAdapter();
-  const adapterOptions = options?.chunkSize !== void 0 ? { chunkSize: options.chunkSize } : void 0;
+  const hasBeginOptions = hasStreamTransactionBeginOptions(options);
+  const hasSignalOption = hasRuntimeStreamSignalOption(options);
+  const adapterOptions = createAdapterStreamOptions(options);
   const hookStore = builder.ctx.hookStore;
   const onHookError = builder.ctx.onHookError;
   const table = builder.from;
@@ -17622,6 +17941,16 @@ function stream(builder, options) {
       if (!supportsStreaming(adapter)) {
         throw createUnsupportedStreamingError();
       }
+      if (hasSignalOption) {
+        throw new Error(
+          "stream() does not support signal; AbortSignal is only supported by transaction()."
+        );
+      }
+      if (hasBeginOptions && adapter.capabilities.supportsTransactionOptions !== true) {
+        throw new Error(
+          "This adapter does not support stream transaction options (isolationLevel/readOnly/lockTimeoutMs/statementTimeoutMs); it does not declare supportsTransactionOptions."
+        );
+      }
       if (!hooksFired) {
         hooksFired = true;
         if (hookStore && hasHooks(hookStore)) {
@@ -19175,8 +19504,21 @@ function createRawCteBuilder(cteName, options, adapter, schemaName, model) {
 function quoteIdent(name) {
   return `"${name.replace(/"/g, '""')}"`;
 }
+var DEFAULT_DDL_SCHEMA_NAME = "public";
+function resolveDDLSchemaName(schemaName) {
+  const resolved = schemaName ?? DEFAULT_DDL_SCHEMA_NAME;
+  validateIdentifier(resolved, "schema");
+  return resolved;
+}
+function sanitizeDropIndexOptions(options) {
+  if (options === void 0 || !("schema" in options)) {
+    return options;
+  }
+  const { schema: _schema, ...rest } = options;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
 function buildQualifiedTable(tableName, schemaName) {
-  return schemaName ? `${quoteIdent(schemaName)}.${quoteIdent(tableName)}` : quoteIdent(tableName);
+  return `${quoteIdent(schemaName)}.${quoteIdent(tableName)}`;
 }
 function generateTruncateSQL(tableName, schemaName, options) {
   const parts = [`TRUNCATE ${buildQualifiedTable(tableName, schemaName)}`];
@@ -19198,6 +19540,33 @@ function createUnsupportedTransactionError() {
     fix: "Use an adapter that implements transaction() and withSchema(), and declare adapter.capabilities.supportsTransactions: true."
   });
 }
+function createUnsupportedPinnedConnectionError() {
+  return new ExecutionError({
+    operation: "withPinnedConnection()",
+    reason: "The adapter does not declare capabilities.supportsPinnedConnections: true and implement withPinnedConnection() for this ORM instance.",
+    fix: "Use an adapter that implements withPinnedConnection(), and declare adapter.capabilities.supportsPinnedConnections: true."
+  });
+}
+function hasTransactionOptions(options) {
+  return options != null && (options.isolationLevel !== void 0 || options.readOnly !== void 0 || options.lockTimeoutMs !== void 0 || options.statementTimeoutMs !== void 0 || options.signal !== void 0);
+}
+function supportsPinnedConnections(adapter) {
+  return adapter.capabilities.supportsPinnedConnections === true && typeof adapter.withPinnedConnection === "function";
+}
+function applyBigintReads(row, bigintReads) {
+  if (row === null || typeof row !== "object") return row;
+  const rowRecord = row;
+  const converted = { ...rowRecord };
+  for (const [outputKey, js] of Object.entries(bigintReads)) {
+    if (!(outputKey in rowRecord)) continue;
+    converted[outputKey] = convertBigintJsReadValue2(rowRecord[outputKey], js, {
+      table: "(raw)",
+      column: outputKey,
+      outputKey
+    });
+  }
+  return converted;
+}
 function adapterTransactionState(adapter, operation, statement) {
   const inTransaction = adapter.inTransaction;
   if (typeof inTransaction !== "boolean") {
@@ -19216,8 +19585,8 @@ function assertOutsideTransaction(adapter, operation, statement) {
     );
   }
 }
-function generateAlterColumnSQL(tableName, column, schemaName, options) {
-  const tbl = buildQualifiedTable(tableName, schemaName);
+function generateAlterColumnSQL(tableName, schemaName, column, options) {
+  const tbl = buildQualifiedTable(tableName, resolveDDLSchemaName(schemaName));
   const col2 = quoteIdent(column);
   const clauses = [];
   if (options.type !== void 0) {
@@ -19249,8 +19618,7 @@ function generateDropIndexSQL(name, schemaName, options) {
   const parts = ["DROP INDEX"];
   if (options?.concurrently) parts.push("CONCURRENTLY");
   if (options?.ifExists) parts.push("IF EXISTS");
-  const sc = options?.schema ?? schemaName;
-  parts.push(sc ? `${quoteIdent(sc)}.${quoteIdent(name)}` : quoteIdent(name));
+  parts.push(`${quoteIdent(schemaName)}.${quoteIdent(name)}`);
   if (options?.cascade) parts.push("CASCADE");
   return parts.join(" ");
 }
@@ -19261,7 +19629,8 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
       if (opts.concurrently) {
         assertOutsideTransaction(a, "createIndex", "CREATE INDEX CONCURRENTLY");
       }
-      const sql2 = a.generateCreateIndex(tableName, opts, schemaName);
+      const ddlSchemaName = resolveDDLSchemaName(schemaName);
+      const sql2 = a.generateCreateIndex(tableName, ddlSchemaName, opts);
       await a.executeDDL?.(sql2);
     },
     async drop(name, options) {
@@ -19269,8 +19638,9 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
       if (options?.concurrently) {
         assertOutsideTransaction(a, "dropIndex", "DROP INDEX CONCURRENTLY");
       }
-      const scopedOptions = schemaName ? { ...options, schema: options?.schema ?? schemaName } : options;
-      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, scopedOptions) : generateDropIndexSQL(name, schemaName, options);
+      const ddlSchemaName = resolveDDLSchemaName(schemaName);
+      const sanitizedOptions = sanitizeDropIndexOptions(options);
+      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, ddlSchemaName, sanitizedOptions) : generateDropIndexSQL(name, ddlSchemaName, sanitizedOptions);
       await a.executeDDL?.(sql2);
     },
     async list(options) {
@@ -19318,20 +19688,23 @@ function buildTableDDL(tableName, schemaName, adapter) {
   return {
     async truncate(options) {
       const a = requireAdapter2();
-      const sql2 = a.generateTruncate ? a.generateTruncate(tableName, schemaName, options) : generateTruncateSQL(tableName, schemaName, options);
+      const ddlSchemaName = resolveDDLSchemaName(schemaName);
+      const sql2 = a.generateTruncate ? a.generateTruncate(tableName, ddlSchemaName, options) : generateTruncateSQL(tableName, ddlSchemaName, options);
       await a.executeDDL?.(sql2);
     },
     async vacuum(options) {
       const a = requireAdapter2();
       assertOutsideTransaction(a, "vacuum", "VACUUM");
-      const sql2 = a.generateVacuum ? a.generateVacuum(tableName, schemaName, options) : generateVacuumSQL(tableName, schemaName, options);
+      const ddlSchemaName = resolveDDLSchemaName(schemaName);
+      const sql2 = a.generateVacuum ? a.generateVacuum(tableName, ddlSchemaName, options) : generateVacuumSQL(tableName, ddlSchemaName, options);
       await a.executeDDL?.(sql2);
     },
     async alterColumn(column, options) {
       validateIdentifier(tableName, "table");
       validateIdentifier(column, "column");
       const a = requireAdapter2();
-      const sql2 = a.generateAlterColumn ? a.generateAlterColumn(tableName, column, options, schemaName) : generateAlterColumnSQL(tableName, column, schemaName, options);
+      const ddlSchemaName = resolveDDLSchemaName(schemaName);
+      const sql2 = a.generateAlterColumn ? a.generateAlterColumn(tableName, ddlSchemaName, column, options) : generateAlterColumnSQL(tableName, ddlSchemaName, column, options);
       await a.executeDDL?.(sql2);
     },
     indexes: buildIndexAPI(tableName, schemaName, adapter, requireAdapter2),
@@ -19410,6 +19783,18 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
   );
   return {
     strictMode,
+    // Reflect the REAL transaction state of the backing adapter so callers can
+    // enforce a top-level precondition. This is authoritative even when the ORM
+    // was handed an adapter ALREADY inside a caller-owned transaction (e.g. a
+    // borrowed pg client mid-BEGIN): the adapter tracks the connection's actual
+    // state, which dbsp's construction-time nesting flag alone cannot see. Falls
+    // back to that flag only when no adapter exposes the state (e.g. a compile-only
+    // ORM). withSchema/transaction() re-derive it from their own (scoped/tx)
+    // adapter, so every instance reports the state of the connection it uses.
+    get inTransaction() {
+      const adapterState = adapter?.inTransaction;
+      return typeof adapterState === "boolean" ? adapterState : inTransaction ?? false;
+    },
     nql,
     tables: tablesDDLProxy,
     // biome-ignore lint/suspicious/noExplicitAny: polymorphic constraint — TTable is inferred by callers; TableRef generics are statically erased in this implementation signature
@@ -19662,7 +20047,7 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
     // as awaited, by core, before the caller ever touched it. So the adapter's
     // promise is passed through untouched. The guards still reject rather than
     // throwing synchronously, because that is what callers already rely on.
-    transaction(fn2) {
+    transaction(fn2, options) {
       if (!adapter) {
         return Promise.reject(
           new Error(
@@ -19673,6 +20058,13 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
       if (!supportsTransactions(adapter)) {
         return Promise.reject(createUnsupportedTransactionError());
       }
+      if (hasTransactionOptions(options) && adapter.capabilities.supportsTransactionOptions !== true) {
+        return Promise.reject(
+          new Error(
+            "This adapter does not support transaction options (isolationLevel/readOnly/lockTimeoutMs/statementTimeoutMs/signal); it does not declare supportsTransactionOptions."
+          )
+        );
+      }
       try {
         return adapter.transaction(async (txAdapter) => {
           const txOrm = createOrmInstance(
@@ -19692,7 +20084,41 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
             tablesProxy
           );
           return fn2(txOrm);
-        });
+        }, options);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    withPinnedConnection(fn2, options) {
+      if (!adapter) {
+        return Promise.reject(
+          new Error(
+            "withPinnedConnection() requires an adapter. Pass an adapter when creating the ORM."
+          )
+        );
+      }
+      if (!supportsPinnedConnections(adapter)) {
+        return Promise.reject(createUnsupportedPinnedConnectionError());
+      }
+      try {
+        return adapter.withPinnedConnection(async (pinnedAdapter) => {
+          const pinnedOrm = createOrmInstance(
+            model,
+            strictMode,
+            relationHints,
+            pinnedAdapter,
+            schemaName,
+            dialectCapabilities,
+            schemaDefinition,
+            globalPlanOptions,
+            defaultFilters,
+            hookStore,
+            onHookError,
+            pinnedAdapter.inTransaction,
+            tablesProxy
+          );
+          return fn2(pinnedOrm);
+        }, options);
       } catch (error) {
         return Promise.reject(error);
       }
@@ -19725,13 +20151,18 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
      *
      * @see {@link https://owasp.org/www-community/attacks/SQL_Injection | OWASP SQL Injection}
      */
-    async raw(sqlString, parameters = []) {
+    async raw(sqlString, parameters = [], options) {
       if (!adapter) {
         throw new Error(
           "raw() requires an adapter. Pass an adapter when creating the ORM."
         );
       }
-      return adapter.executeRaw(sqlString, parameters);
+      const rows = await adapter.executeRaw(sqlString, parameters);
+      const bigintReads = options?.bigintReads;
+      if (!bigintReads || Object.keys(bigintReads).length === 0) {
+        return rows;
+      }
+      return rows.map((row) => applyBigintReads(row, bigintReads));
     },
     batchValues(data, columns, types, opts) {
       return batchValues(data, columns, types, opts);
@@ -19788,19 +20219,16 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
           );
         }
         validateIdentifier(name, "index");
-        const sc = options?.schema ?? schemaName;
-        if (sc) {
-          validateIdentifier(sc, "schema");
-        }
-        const scopedOptions = sc ? { ...options, schema: sc } : options;
-        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, scopedOptions) : (() => {
+        const ddlSchemaName = resolveDDLSchemaName(schemaName);
+        const sanitizedOptions = sanitizeDropIndexOptions(options);
+        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, ddlSchemaName, sanitizedOptions) : (() => {
           const parts = ["DROP INDEX"];
-          if (options?.concurrently) parts.push("CONCURRENTLY");
-          if (options?.ifExists) parts.push("IF EXISTS");
+          if (sanitizedOptions?.concurrently) parts.push("CONCURRENTLY");
+          if (sanitizedOptions?.ifExists) parts.push("IF EXISTS");
           parts.push(
-            sc ? `"${sc.replace(/"/g, '""')}"."${name.replace(/"/g, '""')}"` : `"${name.replace(/"/g, '""')}"`
+            `"${ddlSchemaName.replace(/"/g, '""')}"."${name.replace(/"/g, '""')}"`
           );
-          if (options?.cascade) parts.push("CASCADE");
+          if (sanitizedOptions?.cascade) parts.push("CASCADE");
           return parts.join(" ");
         })();
         await adapter.executeDDL(sql2);
@@ -21346,6 +21774,7 @@ export {
   SubqueryBuilder,
   SubqueryExpression,
   TABLE_META,
+  TRANSITION_LESSOR_REJECTION,
   TableNotFoundError,
   UnhandledTypeInDialect,
   UnknownDialectError,
@@ -21356,6 +21785,7 @@ export {
   UpdateBuilder,
   UpsertBuilder,
   WindowBuilder,
+  acquireTransitionLease,
   advisoryObservationId,
   aggOrderBy,
   and,
@@ -21417,6 +21847,7 @@ export {
   createRawCteBuilder,
   createRecursiveMetadata,
   createStagedTransitionOrchestrator,
+  createTransitionLessor,
   decapitalize,
   defaultIndexName,
   defaultLogger,
@@ -21489,6 +21920,7 @@ export {
   isSubqueryExpression,
   export_isSubqueryRef as isSubqueryRef,
   isTableRef,
+  isTransitionLessor,
   export_isUpdateIntent as isUpdateIntent,
   export_isUpsertIntent as isUpsertIntent,
   export_isWhereAnd as isWhereAnd,