@intentius/chant 0.124.39 → 0.124.41

package/dist/lifecycle/run-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-ledger.d.ts","sourceRoot":"","sources":["../../src/lifecycle/run-ledger.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAkB,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAA+C,MAAM,eAAe,CAAC;AASrI,0EAA0E;AAC1E,eAAO,MAAM,eAAe,UAAU,CAAC;AAMvC,8FAA8F;AAC9F,wBAAgB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,MAAM,CAEjE;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,EACzC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,OAAO,CAAC,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACjC,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IACrC,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC,GACA,gBAAgB,CAkDlB;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,gBAAgB,EACvB,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACtB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC,CAsBlD;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACtB,OAAO,CAAC;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAkCxD"}
+{"version":3,"file":"run-ledger.d.ts","sourceRoot":"","sources":["../../src/lifecycle/run-ledger.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAkB,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAA+C,MAAM,eAAe,CAAC;AASrI,0EAA0E;AAC1E,eAAO,MAAM,eAAe,UAAU,CAAC;AAMvC,8FAA8F;AAC9F,wBAAgB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,MAAM,CAEjE;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC,EACzC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,OAAO,CAAC,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACjC,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IACrC,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC,GACA,gBAAgB,CAkDlB;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,gBAAgB,EACvB,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACtB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC,CAsBlD;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACtB,OAAO,CAAC;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAIxD;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CA+B7F"}

package/dist/lifecycle/run-ledger.js

@@ -163,6 +163,22 @@ export async function readRunLedger(environment, op, opts) {
     const content = await readBlobFromPath(environment, fileFor(op), opts);
     if (!content)
         return { records: [], malformed: 0 };
+    return parseRunLedger(content);
+}
+/** The run ledger file name for `op` under `<env>/`, `runs__<op>.jsonl`. */
+export function runLedgerFile(op) {
+    return fileFor(op);
+}
+/** The op a run ledger file name holds, or null when `file` is not one. */
+export function opOfRunLedgerFile(file) {
+    return file.startsWith(PREFIX) && file.endsWith(".jsonl") && file.length > PREFIX.length + ".jsonl".length ? file.slice(PREFIX.length, -".jsonl".length) : null;
+}
+/**
+ * Parse the text of one run ledger file the way {@link readRunLedger} reads
+ * it (#4297): a reader that fetches the file itself, such as `chant query`,
+ * gets the same records and the same malformed count.
+ */
+export function parseRunLedger(content) {
     const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
     const records = [];
     let malformed = 0;

package/dist/lifecycle/status.d.ts

@@ -361,7 +361,9 @@ export interface CrossEnvComparison {
      * environments legitimately render to different bytes, so cross-environment
      * "is prod running what staging tested" joins on the input side while
      * `digest` proves the exact bytes each cluster got. Records without it
-     * compare on `digest` exactly as before.
+     * compare on `digest` exactly as before. An apply record (#4274) compares
+     * on its `gitSha`, since its plan or deploy-input digest takes in the
+     * environment and so differs between any two.
      */
     same: boolean;
     /** The identities `same` was decided on (`inputDigest ?? digest` per side), when both sides had one and they differ from the digests shown. */
@@ -377,6 +379,8 @@ export interface CrossEnvComparison {
      */
     mixedDigestForms?: true;
 }
+/** What two environments' records of a component are compared on: the input side when there is one, the commit for an apply (#4274). */
+export declare function comparableIdentity(record: ReleaseRecord): string;
 /** Compare the latest recorded digest for `component` between two environments' release records. */
 export declare function compareAcrossEnvironments(component: string, envA: {
     name: string;

package/dist/lifecycle/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/lifecycle/status.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/lifecycle/status.ts"],"names":[],"mappings":"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"}

package/dist/lifecycle/status.js

@@ -40,7 +40,7 @@
  * (`buildIsInBothEnvs`) is the query the epic actually asks for ("which
  * build is in prod, and is it the one tested in staging").
  */
-import { latestPerComponent } from "./release-ledger.js";
+import { isApplyRecord, latestPerComponent } from "./release-ledger.js";
 import { isLegacyContentDigest } from "./legacy-digest.js";
 import { unobservedReasonText } from "../observation.js";
 /**
@@ -396,7 +396,8 @@ function notBefore(since, recordedAt) {
  */
 function contradictsRecord(recorded, evidence) {
     for (const id of evidence.identities ?? []) {
-        if (id.digest !== undefined) {
+        // #4274: an apply's digest is a plan or deploy-input digest, which no live resource reports.
+        if (id.digest !== undefined && !isApplyRecord(recorded)) {
             const matches = sameDigest(id.digest, recorded.digest) ||
                 (recorded.inputDigest !== undefined && sameDigest(id.digest, recorded.inputDigest));
             if (!matches)
@@ -425,13 +426,17 @@ function contradictsRecord(recorded, evidence) {
         return "live configuration has drifted since";
     return undefined;
 }
+/** What two environments' records of a component are compared on: the input side when there is one, the commit for an apply (#4274). */
+export function comparableIdentity(record) {
+    return isApplyRecord(record) ? `git:${record.gitSha}` : record.inputDigest ?? record.digest;
+}
 /** Compare the latest recorded digest for `component` between two environments' release records. */
 export function compareAcrossEnvironments(component, envA, envB) {
     const latestA = latestPerComponent(envA.records).get(component);
     const latestB = latestPerComponent(envB.records).get(component);
-    const idA = latestA ? latestA.inputDigest ?? latestA.digest : undefined;
-    const idB = latestB ? latestB.inputDigest ?? latestB.digest : undefined;
-    const comparedOnInputs = (latestA?.inputDigest ?? latestB?.inputDigest) !== undefined;
+    const idA = latestA ? comparableIdentity(latestA) : undefined;
+    const idB = latestB ? comparableIdentity(latestB) : undefined;
+    const comparedOnInputs = (latestA !== undefined && idA !== latestA.digest) || (latestB !== undefined && idB !== latestB.digest);
     return {
         component,
         envA: envA.name,

package/dist/lifecycle/target-lock.d.ts

@@ -0,0 +1,97 @@
+/** The directory on `chant/lifecycle` that holds the lock files. */
+export declare const LOCKS_DIR = "_locks";
+/**
+ * How a lock was taken. `plan`: the pull request's plan took it (`ci.locks:
+ * plan`). `apply`: its apply took it. `lock`: someone ran `chant lock`.
+ */
+export type TargetLockStage = "plan" | "apply" | "lock";
+export declare const TARGET_LOCK_STAGES: readonly ["plan", "apply", "lock"];
+/** One target's lock: the pull request that holds it, who took it, when, how, and the head it took it at. */
+export interface TargetLock {
+    pr: number;
+    by: string;
+    at: string;
+    stage: TargetLockStage;
+    /** The pull request's head commit when the lock was taken. Absent when the caller did not say. */
+    head?: string;
+}
+/** `_locks/<gate>.json`. */
+export interface TargetLockFile {
+    version: 1;
+    locks: Record<string, TargetLock>;
+}
+/** A lock another open pull request holds on a target the caller needs. */
+export interface HeldTargetLock extends TargetLock {
+    target: string;
+}
+/** Says whether pull request `pr` is still open. */
+export type PullRequestOpen = (pr: number) => Promise<boolean>;
+export interface TargetLockOptions {
+    cwd?: string;
+    /** Whether a holder is still open. Absent: every holder counts as open. */
+    isOpen?: PullRequestOpen;
+}
+export type TakeTargetLocksResult = {
+    ok: true;
+    /** The targets now locked, sorted. */
+    taken: string[];
+    /** Plan locks of the same pull request on targets it no longer reaches, released (`releaseStalePlan`). */
+    released: string[];
+    /** Locks of merged or closed pull requests that this write dropped. */
+    expired: string[];
+    /** Whether the remote has the write. False with no remote, or when recording is off. */
+    pushed: boolean;
+} | {
+    ok: false;
+    held: HeldTargetLock[];
+};
+/** The path of `gate`'s lock file on `chant/lifecycle`, under a member's prefix when it has one. */
+export declare function targetLockPath(gate: string, memberPrefix?: string): string;
+/** A gate name that is safe as a file name. */
+export declare function targetLockGateProblem(gate: string): string | null;
+/** Parse a lock file. Anything that is not a version 1 file with a map of locks reads as no locks; a malformed entry is dropped. */
+export declare function parseTargetLocks(text: string | null): TargetLockFile;
+/** The file's text: targets sorted, so two writes of the same locks are the same blob. */
+export declare function renderTargetLocks(file: TargetLockFile): string;
+/** The locks of `gate` as the remote holds them now, fetched first. */
+export declare function readTargetLocks(gate: string, opts?: {
+    cwd?: string;
+}): Promise<TargetLockFile>;
+/**
+ * The locks on `targets` that an open pull request other than `pr` holds.
+ * Reads only: an apply calls this to refuse a target another pull request
+ * holds. `pr` null (an apply of a green commit) counts every open holder.
+ */
+export declare function heldTargetLocks(gate: string, targets: readonly string[], pr: number | null, opts?: TargetLockOptions): Promise<HeldTargetLock[]>;
+/**
+ * Lock `targets` for pull request `holder.pr`. A target locked by another
+ * pull request that is still open is held, and nothing is locked. A target
+ * locked by one that merged or closed is taken over, and its lock dropped.
+ * Targets this pull request already holds stay its own, with the new head.
+ * An apply or a `chant lock` takes over the pull request's own plan locks;
+ * a plan keeps its own apply and `chant lock` locks as they are. With
+ * `releaseStalePlan`, the pull request's plan locks on targets it no longer
+ * reaches are released.
+ */
+export declare function takeTargetLocks(gate: string, targets: readonly string[], holder: TargetLock, opts?: TargetLockOptions & {
+    releaseStalePlan?: boolean;
+}): Promise<TakeTargetLocksResult>;
+/**
+ * Release the locks pull request `pr` holds on `gate`: every one, or only
+ * those on `targets`. Returns the targets released, sorted.
+ */
+export declare function releaseTargetLocks(gate: string, pr: number, opts?: {
+    cwd?: string;
+    targets?: readonly string[];
+}): Promise<{
+    released: string[];
+    pushed: boolean;
+}>;
+/** The lock file's path for the project at `cwd`, for messages. */
+export declare function targetLockPathAt(gate: string, cwd?: string): Promise<string>;
+/**
+ * One line naming the targets others hold, for a refusal or a note.
+ * `name` says how the forge names a holder (GitLab: `merge request !7`).
+ */
+export declare function describeHeldTargetLocks(held: readonly HeldTargetLock[], name?: (pr: number) => string): string;
+//# sourceMappingURL=target-lock.d.ts.map

package/dist/lifecycle/target-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-lock.d.ts","sourceRoot":"","sources":["../../src/lifecycle/target-lock.ts"],"names":[],"mappings":"AAuCA,oEAAoE;AACpE,eAAO,MAAM,SAAS,WAAW,CAAC;AAOlC;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAExD,eAAO,MAAM,kBAAkB,oCAA0E,CAAC;AAE1G,6GAA6G;AAC7G,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,eAAe,CAAC;IACvB,kGAAkG;IAClG,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,4BAA4B;AAC5B,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACnC;AAED,2EAA2E;AAC3E,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oDAAoD;AACpD,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,sCAAsC;IACtC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,0GAA0G;IAC1G,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,uEAAuE;IACvE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wFAAwF;IACxF,MAAM,EAAE,OAAO,CAAC;CACjB,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,cAAc,EAAE,CAAA;CAAE,CAAC;AAE1C,oGAAoG;AACpG,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,SAAK,GAAG,MAAM,CAEtE;AAED,+CAA+C;AAC/C,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEjE;AAID,oIAAoI;AACpI,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,cAAc,CAgBpE;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAG9D;AAcD,uEAAuE;AACvE,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CAKxG;AAsBD;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAI1J;AA+DD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,GAAE,iBAAiB,GAAG;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5D,OAAO,CAAC,qBAAqB,CAAC,CAsChC;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACvD,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAelD;AAED,mEAAmE;AACnE,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGlF;AAID;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,cAAc,EAAE,EAAE,IAAI,GAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAqC,GAAG,MAAM,CAM5I"}

package/dist/lifecycle/target-lock.js

@@ -0,0 +1,286 @@
+/**
+ * Target locks (#4293): a pull request holds a lock on each target its
+ * change reaches, so no other pull request applies or locks those targets
+ * until it merges or closes, or someone runs `chant unlock` on it.
+ *
+ * A target is a name the caller picks: a component, a workspace member, or
+ * a lexicon's own unit such as a Terraform root. The locks of one gate live
+ * in one file, `_locks/<gate>.json` on `chant/lifecycle`, under the member's
+ * ledger prefix in a workspace member (./git.ts `ledgerDir`). The gate is
+ * the pull-request loop's, `pr-apply` unless the pipeline names another, so
+ * two pipelines with their own gates keep their own locks.
+ *
+ * Every change is a new commit on the branch, written with the read-then-CAS
+ * the other ledgers use and then pushed. A lock counts only once the remote
+ * has it: when the push is refused because another writer moved the branch,
+ * the local commit is dropped, the branch is read again and the decision is
+ * made again. So two jobs that lock the same target at once cannot both win.
+ * A repository with no remote is one machine, and the local write decides.
+ *
+ * A lock held by a pull request that is no longer open is released: the
+ * holder merged or closed. The caller says which pull requests are open
+ * (`isOpen`, from the forge). Without it every lock counts as held, and only
+ * `chant unlock` releases one.
+ *
+ * The file is coordination, not a record of work. ws-074 holds: the
+ * repository is the database, and the file is one more ledger on the
+ * branch, so any clone can read who holds what.
+ */
+import { getRuntime } from "../runtime-adapter.js";
+import { fetchLifecycleStatus, pushLifecycleStatus, readBlobBySha, readPathSha, RefCASConflictError, writeBlobToPath, } from "./git.js";
+import { resolveMemberLedger } from "./member-ledger.js";
+/** The directory on `chant/lifecycle` that holds the lock files. */
+export const LOCKS_DIR = "_locks";
+const STATE_BRANCH = "chant/lifecycle";
+/** A scratch ref this module owns, for reading the remote tip after a refused push. */
+const PROBE_REF = "refs/chant/target-lock-probe";
+const ATTEMPTS = 5;
+export const TARGET_LOCK_STAGES = ["plan", "apply", "lock"];
+/** The path of `gate`'s lock file on `chant/lifecycle`, under a member's prefix when it has one. */
+export function targetLockPath(gate, memberPrefix = "") {
+    return `${memberPrefix}${LOCKS_DIR}/${gate}.json`;
+}
+/** A gate name that is safe as a file name. */
+export function targetLockGateProblem(gate) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(gate) ? null : `the gate name ${JSON.stringify(gate)} is not a lock file name: letters, digits, '.', '_' and '-', starting with a letter or digit`;
+}
+const isStage = (v) => typeof v === "string" && TARGET_LOCK_STAGES.includes(v);
+/** Parse a lock file. Anything that is not a version 1 file with a map of locks reads as no locks; a malformed entry is dropped. */
+export function parseTargetLocks(text) {
+    if (!text)
+        return { version: 1, locks: {} };
+    try {
+        const doc = JSON.parse(text);
+        if (doc?.version === 1 && doc.locks && typeof doc.locks === "object" && !Array.isArray(doc.locks)) {
+            const locks = {};
+            for (const [target, raw] of Object.entries(doc.locks)) {
+                if (!raw || !Number.isInteger(raw.pr) || typeof raw.by !== "string" || typeof raw.at !== "string" || !isStage(raw.stage))
+                    continue;
+                locks[target] = { pr: raw.pr, by: raw.by, at: raw.at, stage: raw.stage, ...(typeof raw.head === "string" ? { head: raw.head } : {}) };
+            }
+            return { version: 1, locks };
+        }
+    }
+    catch {
+        // An unreadable file holds no locks.
+    }
+    return { version: 1, locks: {} };
+}
+/** The file's text: targets sorted, so two writes of the same locks are the same blob. */
+export function renderTargetLocks(file) {
+    const locks = Object.fromEntries(Object.keys(file.locks).sort().map((t) => [t, file.locks[t]]));
+    return `${JSON.stringify({ version: 1, locks }, null, 2)}\n`;
+}
+/** Fetch `chant/lifecycle`, refusing a ledger this checkout cannot read: a lock decided on a stale branch is no lock. */
+async function fetchForLocks(cwd) {
+    const fetched = await fetchLifecycleStatus({ cwd });
+    if (fetched.status === "diverged")
+        throw new Error(`the local ${STATE_BRANCH} has forked from ${fetched.remote}'s, so the locks cannot be read: ${fetched.stderr}`);
+    if (fetched.status === "unreachable")
+        throw new Error(`cannot fetch ${STATE_BRANCH} from ${fetched.remote}, so the locks cannot be read${fetched.stderr ? `: ${fetched.stderr}` : ""}`);
+}
+async function readCurrent(gate, cwd) {
+    const sha = await readPathSha(LOCKS_DIR, `${gate}.json`, { cwd });
+    return { sha, file: parseTargetLocks(sha ? await readBlobBySha(sha, { cwd }) : null) };
+}
+/** The locks of `gate` as the remote holds them now, fetched first. */
+export async function readTargetLocks(gate, opts = {}) {
+    const problem = targetLockGateProblem(gate);
+    if (problem)
+        throw new Error(problem);
+    await fetchForLocks(opts.cwd);
+    return (await readCurrent(gate, opts.cwd)).file;
+}
+/** A memo of `isOpen`, so one decision asks the forge about each pull request once. */
+function openMemo(isOpen) {
+    const seen = new Map();
+    return (pr) => {
+        if (!isOpen)
+            return Promise.resolve(true);
+        if (!seen.has(pr))
+            seen.set(pr, isOpen(pr));
+        return seen.get(pr);
+    };
+}
+/** The locks on `targets` that an open pull request other than `pr` holds, by target. */
+async function heldIn(file, targets, pr, open) {
+    const held = [];
+    for (const target of [...new Set(targets)].sort()) {
+        const l = file.locks[target];
+        if (l && l.pr !== pr && (await open(l.pr)))
+            held.push({ target, ...l });
+    }
+    return held;
+}
+/**
+ * The locks on `targets` that an open pull request other than `pr` holds.
+ * Reads only: an apply calls this to refuse a target another pull request
+ * holds. `pr` null (an apply of a green commit) counts every open holder.
+ */
+export async function heldTargetLocks(gate, targets, pr, opts = {}) {
+    if (targets.length === 0)
+        return [];
+    const file = await readTargetLocks(gate, opts);
+    return heldIn(file, targets, pr, openMemo(opts.isOpen));
+}
+/** The local tip of `chant/lifecycle`, or "" when there is none. */
+async function localTip(cwd) {
+    const out = await getRuntime().spawn(["git", "rev-parse", "--verify", "--quiet", `refs/heads/${STATE_BRANCH}`], { cwd });
+    return out.exitCode === 0 ? out.stdout.trim() : "";
+}
+/**
+ * After a refused push: drop the lock commit `ours` from the local branch by
+ * moving it to the remote's tip, so the next attempt reads what the other
+ * writer pushed. Done only when `parent`, the tip before the write, is in
+ * the remote's history, so no other local commit is lost. Throws otherwise.
+ */
+async function dropRefusedWrite(remote, ours, parent, cwd) {
+    const rt = getRuntime();
+    const env = { LC_ALL: "C", LANGUAGE: "" };
+    const probe = await rt.spawn(["git", "fetch", "--force", remote, `${STATE_BRANCH}:${PROBE_REF}`], { cwd, env });
+    if (probe.exitCode !== 0)
+        throw new Error(`the push of the locks was refused and ${STATE_BRANCH} could not be read again from ${remote}: ${probe.stderr.trim()}`);
+    try {
+        if (parent) {
+            const contains = await rt.spawn(["git", "merge-base", "--is-ancestor", parent, PROBE_REF], { cwd, env });
+            if (contains.exitCode !== 0)
+                throw new Error(`the push of the locks was refused, and the local ${STATE_BRANCH} holds commits ${remote} does not; push or fetch ${STATE_BRANCH} and lock again`);
+        }
+        const tip = (await rt.spawn(["git", "rev-parse", "--verify", PROBE_REF], { cwd, env })).stdout.trim();
+        const moved = await rt.spawn(["git", "update-ref", `refs/heads/${STATE_BRANCH}`, tip, ours], { cwd, env });
+        if (moved.exitCode !== 0)
+            throw new Error(`could not drop the refused lock commit from ${STATE_BRANCH}: ${moved.stderr.trim()}`);
+        await rt.spawn(["git", "update-ref", `refs/remotes/${remote}/${STATE_BRANCH}`, tip], { cwd, env });
+    }
+    finally {
+        await rt.spawn(["git", "update-ref", "-d", PROBE_REF], { cwd, env });
+    }
+}
+/**
+ * Write `next` over the file read at `sha`, then push. Returns null when the
+ * branch moved under the write (locally or on the remote), so the caller
+ * reads and decides again.
+ */
+async function writeAndPush(gate, sha, next, message, cwd) {
+    const parent = await localTip(cwd);
+    let commit;
+    try {
+        commit = await writeBlobToPath(LOCKS_DIR, `${gate}.json`, renderTargetLocks(next), message, { cwd, expectPriorPathSha: sha });
+    }
+    catch (err) {
+        if (err instanceof RefCASConflictError)
+            return null;
+        throw err;
+    }
+    const push = await pushLifecycleStatus({ cwd });
+    switch (push.status) {
+        case "pushed":
+            return { pushed: true };
+        case "no-remote":
+        case "not-recorded":
+            return { pushed: false };
+        case "stale":
+            await dropRefusedWrite(push.remote, commit, parent, cwd);
+            await fetchForLocks(cwd);
+            return null;
+        case "failed":
+            throw new Error(`the locks were written but the push of ${STATE_BRANCH} to ${push.remote} failed, so they do not count yet: ${push.stderr}`);
+    }
+}
+/**
+ * Lock `targets` for pull request `holder.pr`. A target locked by another
+ * pull request that is still open is held, and nothing is locked. A target
+ * locked by one that merged or closed is taken over, and its lock dropped.
+ * Targets this pull request already holds stay its own, with the new head.
+ * An apply or a `chant lock` takes over the pull request's own plan locks;
+ * a plan keeps its own apply and `chant lock` locks as they are. With
+ * `releaseStalePlan`, the pull request's plan locks on targets it no longer
+ * reaches are released.
+ */
+export async function takeTargetLocks(gate, targets, holder, opts = {}) {
+    const problem = targetLockGateProblem(gate);
+    if (problem)
+        throw new Error(problem);
+    for (const t of targets)
+        if (t.trim() === "")
+            throw new Error("a lock target is a non-empty name");
+    const wanted = [...new Set(targets)].sort();
+    const open = openMemo(opts.isOpen);
+    await fetchForLocks(opts.cwd);
+    for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+        const { sha, file } = await readCurrent(gate, opts.cwd);
+        const held = await heldIn(file, wanted, holder.pr, open);
+        if (held.length > 0)
+            return { ok: false, held };
+        const next = { version: 1, locks: {} };
+        const released = [];
+        const expired = [];
+        for (const [target, l] of Object.entries(file.locks)) {
+            if (l.pr === holder.pr) {
+                if (opts.releaseStalePlan && l.stage === "plan" && !wanted.includes(target)) {
+                    released.push(target);
+                    continue;
+                }
+            }
+            else if (opts.isOpen && !(await open(l.pr))) {
+                expired.push(target);
+                continue;
+            }
+            next.locks[target] = l;
+        }
+        for (const target of wanted) {
+            const own = file.locks[target];
+            next.locks[target] = holder.stage === "plan" && own?.pr === holder.pr && own.stage !== "plan" ? own : holder;
+        }
+        const done = { ok: true, taken: wanted, released: released.sort(), expired: expired.sort() };
+        if (renderTargetLocks(next) === renderTargetLocks(file) && sha !== null)
+            return { ...done, pushed: false };
+        if (wanted.length === 0 && released.length === 0 && expired.length === 0)
+            return { ...done, pushed: false };
+        const wrote = await writeAndPush(gate, sha, next, `Lock ${wanted.length} target${wanted.length === 1 ? "" : "s"} of ${gate} for pull request ${holder.pr} (${holder.stage})`, opts.cwd);
+        if (wrote)
+            return { ...done, pushed: wrote.pushed };
+    }
+    throw new Error(`could not write the locks of ${gate}: ${STATE_BRANCH} kept moving; lock again`);
+}
+/**
+ * Release the locks pull request `pr` holds on `gate`: every one, or only
+ * those on `targets`. Returns the targets released, sorted.
+ */
+export async function releaseTargetLocks(gate, pr, opts = {}) {
+    const problem = targetLockGateProblem(gate);
+    if (problem)
+        throw new Error(problem);
+    await fetchForLocks(opts.cwd);
+    for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+        const { sha, file } = await readCurrent(gate, opts.cwd);
+        const mine = Object.keys(file.locks)
+            .filter((t) => file.locks[t].pr === pr && (!opts.targets || opts.targets.includes(t)))
+            .sort();
+        if (mine.length === 0)
+            return { released: [], pushed: false };
+        const next = { version: 1, locks: Object.fromEntries(Object.entries(file.locks).filter(([t]) => !mine.includes(t))) };
+        const wrote = await writeAndPush(gate, sha, next, `Unlock ${mine.length} target${mine.length === 1 ? "" : "s"} of ${gate} held by pull request ${pr}`, opts.cwd);
+        if (wrote)
+            return { released: mine, pushed: wrote.pushed };
+    }
+    throw new Error(`could not write the locks of ${gate}: ${STATE_BRANCH} kept moving; unlock again`);
+}
+/** The lock file's path for the project at `cwd`, for messages. */
+export async function targetLockPathAt(gate, cwd) {
+    const { prefix } = await resolveMemberLedger(cwd ?? process.cwd());
+    return targetLockPath(gate, prefix);
+}
+const STAGE_WORDS = { plan: "planned", apply: "applied", lock: "locked with chant lock" };
+/**
+ * One line naming the targets others hold, for a refusal or a note.
+ * `name` says how the forge names a holder (GitLab: `merge request !7`).
+ */
+export function describeHeldTargetLocks(held, name = (pr) => `pull request ${pr}`) {
+    const byPr = new Map();
+    for (const h of held)
+        byPr.set(h.pr, [...(byPr.get(h.pr) ?? []), h]);
+    return [...byPr]
+        .map(([pr, hs]) => `${hs.map((h) => h.target).join(", ")} ${hs.length === 1 ? "is" : "are"} locked by ${name(pr)} (${STAGE_WORDS[hs[0].stage]} by ${hs[0].by})`)
+        .join("; ");
+}

package/dist/live-endpoint.d.ts

@@ -88,4 +88,22 @@ export declare function zeroResourcesWarning(lexicon: string, environment: strin
     resources: Record<string, unknown>;
     unobserved: Record<string, unknown>;
 }): string | undefined;
+/**
+ * Run `run` with `environment`'s declared endpoint applied, as
+ * {@link applyLiveEndpoint} applies it to a `--live` read, and restored after
+ * (#4281). The component plan and apply paths (`components pr-plan`,
+ * `pr-apply`, `pr-record`, `fan-out`, `promote`, `rollback`, `redeploy` and
+ * `chant run --components`) run capabilities that honor the same ambient vars:
+ * azure's `arm-deploy` reads `AZURE_ENDPOINT_URL`, gcp's `gcp-apply`
+ * `GCP_ENDPOINT_URL`, aws's `cfn-deploy` `AWS_ENDPOINT_URL`. Without this, a
+ * plan for an environment declared against an emulator went to the real cloud
+ * unless the shell exported the var by hand.
+ *
+ * `lexicons` is called only when the environment declares an endpoint, so a
+ * caller that has to load its plugins pays for that only then.
+ */
+export declare function withEnvironmentEndpoint<T>(environments: EnvironmentDeclaration[] | undefined, environment: string, lexicons: () => Promise<readonly EndpointLexicon[]> | readonly EndpointLexicon[], run: () => Promise<T>, options?: {
+    warn?: (message: string) => void;
+    env?: NodeJS.ProcessEnv;
+}): Promise<T>;
 //# sourceMappingURL=live-endpoint.d.ts.map

package/dist/live-endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-endpoint.d.ts","sourceRoot":"","sources":["../src/live-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAuB,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAC5E,OAAO,EAAgC,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEjG;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,EAAE,CAErE;AAED,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,mBAAmB,CAAC;CAChC;AACD,yHAAyH;AACzH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAClD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,eAAe,CAsCjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACpF,MAAM,GAAG,SAAS,CAKpB"}
+{"version":3,"file":"live-endpoint.d.ts","sourceRoot":"","sources":["../src/live-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAuB,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAC5E,OAAO,EAAgC,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEjG;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,EAAE,CAErE;AAED,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,mBAAmB,CAAC;CAChC;AACD,yHAAyH;AACzH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAClD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,eAAe,CAsCjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACpF,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,uBAAuB,CAAC,CAAC,EAC7C,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAClD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC,GAAG,SAAS,eAAe,EAAE,EAChF,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACrB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAAO,GAC1E,OAAO,CAAC,CAAC,CAAC,CASZ"}

package/dist/live-endpoint.js

@@ -111,3 +111,30 @@ export function zeroResourcesWarning(lexicon, environment, declaredCount, observ
         return undefined;
     return `${lexicon}: 0 live resources for env "${environment}" (${declaredCount} declared) — check the endpoint/credentials`;
 }
+/**
+ * Run `run` with `environment`'s declared endpoint applied, as
+ * {@link applyLiveEndpoint} applies it to a `--live` read, and restored after
+ * (#4281). The component plan and apply paths (`components pr-plan`,
+ * `pr-apply`, `pr-record`, `fan-out`, `promote`, `rollback`, `redeploy` and
+ * `chant run --components`) run capabilities that honor the same ambient vars:
+ * azure's `arm-deploy` reads `AZURE_ENDPOINT_URL`, gcp's `gcp-apply`
+ * `GCP_ENDPOINT_URL`, aws's `cfn-deploy` `AWS_ENDPOINT_URL`. Without this, a
+ * plan for an environment declared against an emulator went to the real cloud
+ * unless the shell exported the var by hand.
+ *
+ * `lexicons` is called only when the environment declares an endpoint, so a
+ * caller that has to load its plugins pays for that only then.
+ */
+export async function withEnvironmentEndpoint(environments, environment, lexicons, run, options = {}) {
+    if (!environmentEndpoint(environments, environment))
+        return run();
+    const applied = applyLiveEndpoint(environments, environment, await lexicons(), options.env);
+    if (applied.notice)
+        options.warn?.(applied.notice);
+    try {
+        return await run();
+    }
+    finally {
+        applied.restore();
+    }
+}

package/dist/op/activities/activity-contracts.d.ts

@@ -121,6 +121,36 @@ export declare const behaviourFindingContract: import("../index.js").ActivityCon
     pullRequest?: string | undefined;
     mergeRequest?: string | undefined;
 }>;
+/**
+ * The review agent (#4299). `changeSet` is `composeChangeSet`'s document,
+ * checked only for the fields the prompt reads. `returns` names what a later
+ * step may read; no gate reads it.
+ */
+export declare const reviewAgentContract: import("../index.js").ActivityContract<{
+    op: string;
+    changeSet?: {
+        [x: string]: unknown;
+        digest: string;
+        entries: unknown[];
+    } | undefined;
+    changeSetFile?: string | undefined;
+    mode?: "comment" | "report" | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    base?: string | undefined;
+    instructions?: string | undefined;
+    command?: string | undefined;
+    keyEnv?: string | undefined;
+    timeout?: number | undefined;
+}, {
+    mode: "comment" | "report";
+    risk: "high" | "low" | "medium" | "unknown";
+    exitCode: number | null;
+    summary: string;
+    commentUrl?: string | undefined;
+    pullRequest?: string | undefined;
+    mergeRequest?: string | undefined;
+}>;
 /**
  * The propose-only template upgrade (#2550, ws-032). `args` mirrors
  * `ProposeWorkspaceUpgradeArgs` without its test hooks. `returns` names what

package/dist/op/activities/activity-contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activity-contracts.d.ts","sourceRoot":"","sources":["../../../src/op/activities/activity-contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,eAAO,MAAM,yBAAyB;;SAGrC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;EAIjC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;EAmB5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;EAgB7B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;SAGjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;EAUpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;EAuBpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgClC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAkBhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAIjC,CAAC;AAOF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;EAIpC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;EAI1C,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;EAIrC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;EAW/B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;EAWjC,CAAC;AAUF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAoBvC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;EAWzC,CAAC;AAWF,eAAO,MAAM,mBAAmB;;;;;;;;;;;EAQ/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;YAIhC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAU9B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;EAIhC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAIhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EASjC,CAAC"}
+{"version":3,"file":"activity-contracts.d.ts","sourceRoot":"","sources":["../../../src/op/activities/activity-contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,eAAO,MAAM,yBAAyB;;SAGrC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;EAIjC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;EAmB5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;EAgB7B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;SAGjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;EAUpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;EAuBpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAwB/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgClC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAkBhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAIjC,CAAC;AAOF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;EAIpC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;EAI1C,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;EAIrC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;EAW/B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;EAWjC,CAAC;AAUF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAoBvC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;EAWzC,CAAC;AAWF,eAAO,MAAM,mBAAmB;;;;;;;;;;;EAQ/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;YAIhC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAU9B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;EAIhC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAIhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EASjC,CAAC"}