canopycms 0.11.1 → 0.12.1

package/dist/worker/github-gateway-wire.d.ts

@@ -9,10 +9,13 @@ export declare const MAX_JSON_REQUEST_BYTES: number;
 export declare const MAX_JSON_ANSWER_BYTES: number;
 export declare const fetchRequest: z.ZodObject<{
     have: z.ZodArray<z.ZodString, "many">;
+    fresh: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     have: string[];
+    fresh?: boolean | undefined;
 }, {
     have: string[];
+    fresh?: boolean | undefined;
 }>;
 export declare const pushRequest: z.ZodObject<{
     branch: z.ZodString;
@@ -56,13 +59,13 @@ export declare const requests: {
     }, "strict", z.ZodTypeAny, {
         title: string;
         base: string;
-        head: string;
         body: string;
+        head: string;
     }, {
         title: string;
         base: string;
-        head: string;
         body: string;
+        head: string;
     }>;
     readonly updatePullRequest: z.ZodObject<{
         number: z.ZodNumber;
@@ -97,15 +100,15 @@ export declare const requests: {
     }, "strict", z.ZodTypeAny, {
         title: string;
         base: string;
-        head: string;
         body: string;
+        head: string;
         markReadyIfDraft?: boolean | undefined;
         mergeSectionIntoBody?: boolean | undefined;
     }, {
         title: string;
         base: string;
-        head: string;
         body: string;
+        head: string;
         markReadyIfDraft?: boolean | undefined;
         mergeSectionIntoBody?: boolean | undefined;
     }>;
@@ -211,12 +214,14 @@ export declare const answers: {
         body: z.ZodNullable<z.ZodString>;
         mergeable_state: z.ZodOptional<z.ZodString>;
         baseRef: z.ZodOptional<z.ZodString>;
+        headSha: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         merged: boolean;
         state: "open" | "closed";
         body: string | null;
         merged_at: string | null;
         node_id: string;
+        headSha?: string | undefined;
         mergeable_state?: string | undefined;
         baseRef?: string | undefined;
     }, {
@@ -225,6 +230,7 @@ export declare const answers: {
         body: string | null;
         merged_at: string | null;
         node_id: string;
+        headSha?: string | undefined;
         mergeable_state?: string | undefined;
         baseRef?: string | undefined;
     }>;
@@ -312,21 +318,21 @@ export declare const answers: {
             kind: z.ZodEnum<["auto-scaling", "spot"]>;
             reason: z.ZodString;
         }, "strict", z.ZodTypeAny, {
-            kind: "auto-scaling" | "spot";
             reason: string;
-        }, {
             kind: "auto-scaling" | "spot";
+        }, {
             reason: string;
+            kind: "auto-scaling" | "spot";
         }>>;
     }, "strict", z.ZodTypeAny, {
         notice: {
-            kind: "auto-scaling" | "spot";
             reason: string;
+            kind: "auto-scaling" | "spot";
         } | null;
     }, {
         notice: {
-            kind: "auto-scaling" | "spot";
             reason: string;
+            kind: "auto-scaling" | "spot";
         } | null;
     }>;
     readonly completeLifecycle: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
@@ -360,15 +366,18 @@ export declare const fetchPoll: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
     /** Every GitHub branch and its tip, as pairs: a `Map` has no JSON form of its own. */
     refs: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">;
     bundleId: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
     state: "done";
     refs: [string, string][];
     progress: number;
+    startedAt: number;
     bundleId: string | null;
 }, {
     state: "done";
     refs: [string, string][];
     progress: number;
+    startedAt: number;
     bundleId: string | null;
 }>]>;
 export declare const pushAnswer: z.ZodUnion<[z.ZodObject<{
@@ -391,15 +400,15 @@ export declare const pushAnswer: z.ZodUnion<[z.ZodObject<{
     pastStaleLease: z.ZodBoolean;
 }, "strict", z.ZodTypeAny, {
     kind: "pushed";
+    moved: true;
     from: string | null;
     to: string;
-    moved: true;
     pastStaleLease: boolean;
 }, {
     kind: "pushed";
+    moved: true;
     from: string | null;
     to: string;
-    moved: true;
     pastStaleLease: boolean;
 }>, z.ZodObject<{
     kind: z.ZodLiteral<"need-objects">;
@@ -431,15 +440,15 @@ declare const errorEnvelope: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     branch: string;
     push: boolean;
     message: string;
-    kind: "refusal";
     reason: "settings" | "protected" | "invalid" | "other-settings" | "outside-namespace" | "not-a-commit" | "too-long";
+    kind: "refusal";
     operation: "push" | "delete" | "pull-request";
 }, {
     branch: string;
     push: boolean;
     message: string;
-    kind: "refusal";
     reason: "settings" | "protected" | "invalid" | "other-settings" | "outside-namespace" | "not-a-commit" | "too-long";
+    kind: "refusal";
     operation: "push" | "delete" | "pull-request";
 }>, z.ZodObject<{
     kind: z.ZodLiteral<"push">;

package/dist/worker/github-gateway-wire.js

@@ -37,7 +37,9 @@ const objectId = z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, 'not a full
 const name = z.string().max(4096);
 const prNumber = z.number().int().safe();
 const message = z.string().max(MAX_MESSAGE_LENGTH);
-export const fetchRequest = z.object({ have: z.array(objectId).max(MAX_FETCH_HAVE) }).strict();
+export const fetchRequest = z
+    .object({ have: z.array(objectId).max(MAX_FETCH_HAVE), fresh: z.boolean().optional() })
+    .strict();
 export const pushRequest = z
     .object({
     branch: name,
@@ -114,6 +116,7 @@ export const answers = {
         body: pullRequestText.body.nullable(),
         mergeable_state: z.string().max(64).optional(),
         baseRef: z.string().max(256).optional(),
+        headSha: objectId.optional(),
     })
         .strict(),
     createOrUpdatePullRequest: pullRequestRef.extend({ created: z.boolean() }).strict(),
@@ -187,6 +190,7 @@ export const fetchPoll = z.discriminatedUnion('state', [
         /** Every GitHub branch and its tip, as pairs: a `Map` has no JSON form of its own. */
         refs: z.array(z.tuple([name, objectId])).max(1_000_000),
         bundleId: jobId.nullable(),
+        startedAt: z.number().int().nonnegative(),
     })
         .strict(),
 ]);

package/dist/worker/github-gateway.d.ts

@@ -15,6 +15,11 @@ export interface GitHubFetchResult {
      * request's `have` and their history; null when that leaves nothing to send.
      */
     bundleId: string | null;
+    /**
+     * When the GitHub fetch `refs` come from began, by the gateway's clock, which is the worker's:
+     * they share the instance. A fetch can be joined or reused, so this can predate the request.
+     */
+    startedAt: number;
 }
 /** The most `have` IDs one fetch takes. */
 export declare const MAX_FETCH_HAVE = 10000;
@@ -81,6 +86,8 @@ export type GitHubPullRequest = Pick<RestEndpointMethodTypes['pulls']['get']['re
     mergeable_state?: string;
     /** The branch the pull request merges into on GitHub, which a person can change. */
     baseRef?: string;
+    /** The pull request's head commit, read with `mergeable_state`. */
+    headSha?: string;
 };
 export type GitHubCreateOrUpdatePullRequest = Omit<CreateOrUpdatePullRequestParams, 'octokit' | 'owner' | 'repo' | 'signal'>;
 /**
@@ -114,10 +121,12 @@ export interface GitHubGateway {
      * Fetch every GitHub branch, and answer with all of them and a bundle of the commits `have`
      * lacks. `have` is the caller's own tips, at most {@link MAX_FETCH_HAVE} object IDs; any the
      * gateway does not hold as a commit is ignored. A new fetch replaces a bundle not yet opened.
-     * `onProgress` is told of each sign of life from the gateway's git while the caller waits.
+     * `fresh` takes no GitHub fetch begun before the request arrived. `onProgress` is told of each
+     * sign of life from the gateway's git while the caller waits.
      */
     fetch(request: {
         have: readonly string[];
+        fresh?: boolean;
     }, signal?: AbortSignal, onProgress?: () => void): Promise<GitHubFetchResult>;
     /**
      * The bundle a fetch answered with, readable once. Throws {@link GitHubTransientError}

package/dist/worker/github-gateway.js

@@ -197,11 +197,14 @@ class LocalGitHubGateway {
      * own, which repairs a corrupt mirror first ({@link GitHubMirror.heal}), and its failure re-reads
      * the credential when it reached GitHub, whoever started it.
      */
-    async joinGitHubFetch(resolve, signal) {
+    async joinGitHubFetch(resolve, signal, 
+    /** Join or reuse only a fetch that began at or after this time. */
+    notBefore) {
         const current = this.githubFetch;
         const window = this.options.fetchCoalesceMs ?? FETCH_COALESCE_MS;
         const reusable = current !== null &&
             !current.failed &&
+            (notBefore === undefined || current.startedAt >= notBefore) &&
             (current.completedAt === null ||
                 (Date.now() - current.completedAt < window && this.isCurrent(current.snapshot)));
         const job = reusable ? current : this.startGitHubFetch(resolve);
@@ -223,7 +226,7 @@ class LocalGitHubGateway {
     async afterGitHubFetch(join, fn) {
         for (let attempt = 1;; attempt++) {
             const snapshot = await join();
-            const result = await this.mirror.exclusive(async (session) => this.isCurrent(snapshot) ? { value: await fn(session) } : null);
+            const result = await this.mirror.exclusive(async (session) => this.isCurrent(snapshot) ? { value: await fn(session, snapshot) } : null);
             if (result !== null)
                 return result.value;
             if (attempt === 2) {
@@ -234,6 +237,7 @@ class LocalGitHubGateway {
     /** Start a GitHub fetch, taking its place at once, before the credential resolves. */
     startGitHubFetch(resolve) {
         let reachedGitHub = false;
+        const startedAt = Date.now();
         const run = async () => {
             const credential = await resolve();
             const own = {
@@ -248,12 +252,18 @@ class LocalGitHubGateway {
                 const pushes = this.pushes;
                 await this.mirror.heal(mirror, own);
                 await this.mirror.fetchFromGitHub(mirror, own);
-                return { generation: this.mirror.generation, pushes };
+                return { generation: this.mirror.generation, pushes, startedAt };
             });
             await this.mirror.afterFetch();
             return snapshot;
         };
-        const job = { failed: false, completedAt: null, snapshot: null, done: run() };
+        const job = {
+            failed: false,
+            completedAt: null,
+            snapshot: null,
+            startedAt,
+            done: run(),
+        };
         job.done.then((snapshot) => {
             job.completedAt = Date.now();
             job.snapshot = snapshot;
@@ -472,19 +482,20 @@ class LocalGitHubGateway {
         }
     }
     fetchOnce(request, signal) {
+        const notBefore = request.fresh ? Date.now() : undefined;
         const have = [...new Set(request.have)];
         if (have.length > MAX_FETCH_HAVE) {
             throw new Error(`A fetch takes at most ${MAX_FETCH_HAVE} have IDs, not ${have.length}`);
         }
         for (const id of have)
             assertObjectId(id);
-        return this.credentialed(signal, (reach) => this.afterGitHubFetch(() => this.joinGitHubFetch(() => this.credential(reach), signal), async (mirror) => {
+        return this.credentialed(signal, (reach) => this.afterGitHubFetch(() => this.joinGitHubFetch(() => this.credential(reach), signal, notBefore), async (mirror, snapshot) => {
             this.mirror.assertUsable();
             const refs = await mirror.heads();
             const file = await this.mirror.outgoingBundlePath();
             const created = await mirror.createBundle(have, file, signal);
             const bundleId = await this.mirror.setPendingBundle(created ? file : null);
-            return { refs, bundleId };
+            return { refs, bundleId, startedAt: snapshot.startedAt };
         }));
     }
     openBundle(bundleId) {
@@ -688,6 +699,7 @@ class LocalGitHubGateway {
                 body: ours ? (data.body ?? '') : null,
                 mergeable_state: data.mergeable_state,
                 baseRef: data.base.ref,
+                headSha: data.head.sha,
             };
         });
     }

package/dist/worker/github-transfer.d.ts

@@ -12,11 +12,13 @@ export interface TransferContext {
 /**
  * Fetch every GitHub branch into `remote.git`'s tracking namespace (`GITHUB_TRACKING_REF_PREFIX`),
  * which then holds exactly GitHub's branches. `have` is every tip `remote.git` holds, so the
- * bundle carries only what it lacks. Returns GitHub's branches, and what an operator must fix in
- * remote.git for the namespace to keep up, if anything (see {@link moveTrackingRefs}).
+ * bundle carries only what it lacks. `fresh` takes no GitHub fetch the gateway began before this
+ * call. Returns GitHub's branches, when the GitHub fetch they come from began, and what an operator
+ * must fix in remote.git for the namespace to keep up, if anything (see {@link moveTrackingRefs}).
  */
-export declare function fetchGitHubIntoRemoteGit(ctx: TransferContext, signal?: AbortSignal): Promise<{
+export declare function fetchGitHubIntoRemoteGit(ctx: TransferContext, signal?: AbortSignal, fresh?: boolean): Promise<{
     refs: ReadonlyMap<string, string>;
+    fetchedAt: number;
     needsOperator: string | null;
 }>;
 /**

package/dist/worker/github-transfer.js

@@ -28,16 +28,19 @@ const MAX_PUSH_RESTARTS = 3;
 /**
  * Fetch every GitHub branch into `remote.git`'s tracking namespace (`GITHUB_TRACKING_REF_PREFIX`),
  * which then holds exactly GitHub's branches. `have` is every tip `remote.git` holds, so the
- * bundle carries only what it lacks. Returns GitHub's branches, and what an operator must fix in
- * remote.git for the namespace to keep up, if anything (see {@link moveTrackingRefs}).
+ * bundle carries only what it lacks. `fresh` takes no GitHub fetch the gateway began before this
+ * call. Returns GitHub's branches, when the GitHub fetch they come from began, and what an operator
+ * must fix in remote.git for the namespace to keep up, if anything (see {@link moveTrackingRefs}).
  */
-export async function fetchGitHubIntoRemoteGit(ctx, signal) {
+export async function fetchGitHubIntoRemoteGit(ctx, signal, fresh = false) {
     const gitDir = ctx.remoteGitPath;
-    const { refs, bundleId } = await ctx.github().fetch({ have: await haveOf(gitDir) }, signal);
+    const { refs, bundleId, startedAt } = await ctx
+        .github()
+        .fetch({ have: await haveOf(gitDir), fresh }, signal);
     if (bundleId !== null)
         await unbundle(ctx, gitDir, bundleId, signal);
     const needsOperator = await moveTrackingRefs(ctx, gitDir, refs, signal);
-    return { refs, needsOperator };
+    return { refs, fetchedAt: startedAt, needsOperator };
 }
 /**
  * Seed the new bare repository at `gitDir`, which must not exist yet, with every GitHub branch as

package/dist/worker/rebase.d.ts

@@ -7,8 +7,9 @@ import type { WorkerContext } from './worker-context.js';
  * The rebase loop: the deepest leaf of the git-sync cluster, and the most
  * safety-critical part of the worker. `syncGit` (git-sync.ts) calls
  * `runRebaseCycle` once per cycle; every branch workspace behind the base
- * branch is rebased onto it, keeping the BRANCH's version of any conflicting
- * file. Three things make it the part most likely to misbehave under real EFS
+ * branch takes it in: by a rebase where git and the field merge agree there is
+ * nothing to decide, and by a merge (github-commits.ts' `mergeIntoBranch`)
+ * wherever there is. Three things make it the part most likely to misbehave under real EFS
  * and spot conditions, all documented at the point they happen:
  *
  * - it holds the [SYNC-C1] cross-host content-write lock for the whole rebase,
@@ -27,7 +28,7 @@ import type { WorkerContext } from './worker-context.js';
  * but still need their PR's resolution polled, and this loop is the only thing
  * that walks every branch workspace.
  */
-export type RebaseContext = Pick<WorkerContext, 'baseBranch' | 'sanitizedBaseBranch' | 'contentBranchesPath' | 'contentRoot' | 'remoteGitPath' | 'taskDir' | 'taskTimeoutMs' | 'github' | 'ensureStatusReport' | 'afterConflictDetectedForTesting' | 'afterRebaseCompletedForTesting' | 'ensureSettingsBranch' | 'isDraining'>;
+export type RebaseContext = Pick<WorkerContext, 'baseBranch' | 'sanitizedBaseBranch' | 'contentBranchesPath' | 'contentRoot' | 'remoteGitPath' | 'taskDir' | 'taskTimeoutMs' | 'github' | 'ensureStatusReport' | 'afterConflictDetectedForTesting' | 'afterRebaseCompletedForTesting' | 'ensureSettingsBranch' | 'isDraining' | 'requestBranchSync'>;
 /**
  * Per-cycle outcome of `rebaseActiveBranches()`, folded by `syncGit()` into the
  * worker's self-reported status (`WorkerStatusReport.lastGitSync`, see
@@ -85,4 +86,4 @@ export declare function pollMergeState(ctx: RebaseContext, branchDir: string, br
  * that branch's cross-host content-write lock and runs a series of git
  * subprocesses against a shared filesystem.
  */
-export declare function runRebaseCycle(ctx: RebaseContext, gatewayPolicy?: BranchPolicyDescription, gitHub?: GitHubSnapshot): Promise<RebaseSummary>;
+export declare function runRebaseCycle(ctx: RebaseContext, gatewayPolicy?: BranchPolicyDescription, gitHub?: GitHubSnapshot, requested?: ReadonlySet<string>): Promise<RebaseSummary>;