@nurix/nustack 0.10.0-dev.10

package/dist/lib/git-sync/inbound/undo.js

@@ -0,0 +1,198 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { withReconciliationLock } from "../core/reconciliation_lock.js";
+import { resolveRepository, readHeadCommit } from "../core/repository.js";
+import { runGit } from "../core/git_runner.js";
+import { getBindingById } from "../../local_store/bindings.js";
+import { isCloudOriginCommit } from "../../local_store/commit_origins.js";
+import { getApplication, upsertApplication, transitionApplicationState, } from "../../local_store/handoff_applications.js";
+import { reportApplicationUndoResult } from "../../nustack_client.js";
+import { buildCommit, materializeTarget, casBranchRef } from "./apply_commit.js";
+function readUserIdentity(repo) {
+    const name = runGit(repo.repositoryRoot, ["config", "--get", "user.name"], { allowFailure: true }).stdout.trim();
+    const email = runGit(repo.repositoryRoot, ["config", "--get", "user.email"], { allowFailure: true }).stdout.trim();
+    return name.length > 0 && email.length > 0 ? { name, email } : null;
+}
+function treeOf(repo, ref) {
+    if (ref)
+        return runGit(repo.repositoryRoot, ["rev-parse", `${ref}^{tree}`]).stdout.trim();
+    const tmpIndex = path.join(tmpdir(), `nustack-empty-${randomUUID()}`);
+    try {
+        return runGit(repo.repositoryRoot, ["write-tree"], { indexFile: tmpIndex }).stdout.trim();
+    }
+    finally {
+        rmSync(tmpIndex, { force: true });
+    }
+}
+function firstParent(repo, commit) {
+    const result = runGit(repo.repositoryRoot, ["rev-parse", "--verify", "--quiet", `${commit}^`], { allowFailure: true });
+    const parent = result.stdout.trim();
+    return result.exitCode === 0 && parent.length > 0 ? parent : null;
+}
+function changedPaths(repo, parent, commit) {
+    const args = parent
+        ? ["diff-tree", "--no-commit-id", "--name-only", "-r", parent, commit]
+        : ["diff-tree", "--no-commit-id", "--name-only", "-r", "--root", commit];
+    return runGit(repo.repositoryRoot, args)
+        .stdout.split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function blobAt(repo, ref, targetPath) {
+    if (!ref)
+        return null;
+    const listed = runGit(repo.repositoryRoot, ["ls-tree", ref, "--", targetPath], { allowFailure: true });
+    const line = listed.stdout.split("\n").find((entry) => entry.trim().length > 0);
+    if (listed.exitCode !== 0 || !line)
+        return null;
+    const blobSha = (line.split("\t")[0] ?? "").split(/\s+/)[2] ?? "";
+    if (blobSha.length === 0)
+        return null;
+    return Buffer.from(runGit(repo.repositoryRoot, ["cat-file", "blob", blobSha]).stdout, "utf8");
+}
+function pathContentConflicts(repo, tmpIndex, targetPath) {
+    const unmerged = runGit(repo.repositoryRoot, ["ls-files", "--unmerged", "--", targetPath], { indexFile: tmpIndex }).stdout;
+    const stageSha = {};
+    for (const line of unmerged.split("\n")) {
+        if (line.trim().length === 0)
+            continue;
+        const meta = (line.split("\t")[0] ?? "").split(/\s+/);
+        const sha = meta[1] ?? "";
+        const stage = Number.parseInt(meta[2] ?? "0", 10);
+        if (sha.length > 0)
+            stageSha[stage] = sha;
+    }
+    if (!stageSha[2] || !stageSha[3])
+        return true;
+    const dir = mkdtempSync(path.join(tmpdir(), "nustack-merge-"));
+    try {
+        const write = (stage) => {
+            const file = path.join(dir, `stage${stage}`);
+            const content = stageSha[stage] ? runGit(repo.repositoryRoot, ["cat-file", "blob", stageSha[stage]]).stdout : "";
+            writeFileSync(file, content);
+            return file;
+        };
+        const ours = write(2);
+        const base = write(1);
+        const theirs = write(3);
+        const result = runGit(repo.repositoryRoot, ["merge-file", "-p", ours, base, theirs], { allowFailure: true });
+        return result.exitCode !== 0;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+function preflightRevert(repo, inboundTree, headTree, parentTree) {
+    const tmpIndex = path.join(tmpdir(), `nustack-revert-${randomUUID()}`);
+    try {
+        const merged = runGit(repo.repositoryRoot, ["read-tree", "-i", "-m", inboundTree, headTree, parentTree], {
+            indexFile: tmpIndex,
+            allowFailure: true,
+        });
+        const unmerged = runGit(repo.repositoryRoot, ["ls-files", "--unmerged"], { indexFile: tmpIndex, allowFailure: true }).stdout;
+        const paths = new Set();
+        for (const line of unmerged.split("\n")) {
+            const file = line.split("\t")[1];
+            if (file && file.trim().length > 0)
+                paths.add(file.trim());
+        }
+        if (paths.size === 0) {
+            return merged.exitCode === 0 ? { clean: true } : { clean: false, conflictPaths: [] };
+        }
+        const conflictPaths = [...paths].filter((targetPath) => pathContentConflicts(repo, tmpIndex, targetPath));
+        return conflictPaths.length > 0 ? { clean: false, conflictPaths } : { clean: true };
+    }
+    finally {
+        rmSync(tmpIndex, { force: true });
+    }
+}
+export async function undoHandoff(store, deps, bindingId, handoffId) {
+    return withReconciliationLock(bindingId, async () => {
+        const binding = getBindingById(store, bindingId);
+        if (!binding)
+            return { ok: false, code: "not_found" };
+        const application = getApplication(store, handoffId, bindingId);
+        if (!application)
+            return { ok: false, code: "not_found" };
+        if (application.state !== "committed")
+            return { ok: false, code: "not_undoable" };
+        const inboundCommit = application.generatedCommitId;
+        if (!inboundCommit)
+            return { ok: false, code: "not_undoable" };
+        const repo = resolveRepository(binding.repositoryRoot);
+        const head = readHeadCommit(repo);
+        if (!head)
+            return { ok: false, code: "not_in_history" };
+        const ancestor = runGit(repo.repositoryRoot, ["merge-base", "--is-ancestor", inboundCommit, head], { allowFailure: true });
+        if (ancestor.exitCode !== 0)
+            return { ok: false, code: "not_in_history" };
+        if (!isCloudOriginCommit(store, bindingId, inboundCommit))
+            return { ok: false, code: "not_linked" };
+        const identity = readUserIdentity(repo);
+        if (!identity)
+            return { ok: false, code: "missing_identity" };
+        const parent = firstParent(repo, inboundCommit);
+        const inboundTree = treeOf(repo, inboundCommit);
+        const parentTree = treeOf(repo, parent);
+        const headTree = treeOf(repo, head);
+        transitionApplicationState(store, handoffId, bindingId, "undo_requested");
+        const preflight = preflightRevert(repo, inboundTree, headTree, parentTree);
+        if (!preflight.clean) {
+            transitionApplicationState(store, handoffId, bindingId, "revert_conflict");
+            upsertApplication(store, { handoffId, bindingId, notificationState: "unacknowledged" });
+            await reportUndo(deps, binding.id, handoffId, "revert_conflict", preflight.conflictPaths);
+            return { ok: false, code: "revert_conflict", conflictPaths: preflight.conflictPaths };
+        }
+        const paths = changedPaths(repo, parent, inboundCommit);
+        const inverseTargets = [];
+        const bytesByPath = new Map();
+        for (const targetPath of paths) {
+            const parentBytes = blobAt(repo, parent, targetPath);
+            if (parentBytes === null) {
+                inverseTargets.push({ path: targetPath, operation: "delete", targetSha256: null, byteSize: 0, base: { absent: true } });
+            }
+            else {
+                inverseTargets.push({ path: targetPath, operation: "upsert", targetSha256: null, byteSize: parentBytes.byteLength, base: { absent: true } });
+                bytesByPath.set(targetPath, parentBytes);
+            }
+        }
+        const message = `Revert NuStack sync commit ${inboundCommit.slice(0, 12)}\n\nThis reverts NuStack sync handoff ${handoffId}.\n`;
+        const built = buildCommit(repo, head, inverseTargets, bytesByPath, message, {
+            authorName: identity.name,
+            authorEmail: identity.email,
+            committerName: identity.name,
+            committerEmail: identity.email,
+            ...(deps.authorDate ? { authorDate: deps.authorDate } : {}),
+            ...(deps.committerDate ? { committerDate: deps.committerDate } : {}),
+        });
+        for (const target of inverseTargets) {
+            materializeTarget(repo, target, built.blobByPath.get(target.path) ?? null, bytesByPath.get(target.path) ?? null);
+        }
+        if (!casBranchRef(repo, binding.boundBranch, built.commitId, head)) {
+            return { ok: false, code: "cas_conflict" };
+        }
+        upsertApplication(store, { handoffId, bindingId, revertCommitId: built.commitId, notificationState: "unacknowledged" });
+        transitionApplicationState(store, handoffId, bindingId, "reverted");
+        const revertedPaths = inverseTargets.map((target) => target.path);
+        deps.emitter?.emit({ event: "undo_result", bindingId, handoffId, outcome: "reverted", paths: revertedPaths, revertCommitId: built.commitId });
+        await reportUndo(deps, binding.id, handoffId, "reverted", revertedPaths, built.commitId);
+        return { ok: true, revertCommitId: built.commitId, revertedPaths };
+    });
+}
+async function reportUndo(deps, bindingId, handoffId, outcome, affectedPaths, commitId) {
+    const reportUndoResult = deps.reportUndo ?? reportApplicationUndoResult;
+    try {
+        await reportUndoResult(deps.baseUrl, deps.accessToken, {
+            bindingId,
+            handoffId,
+            idempotencyKey: `undo:${bindingId}:${handoffId}`,
+            outcome,
+            affectedPaths,
+            commitId: commitId ?? null,
+        });
+    }
+    catch {
+    }
+}

package/dist/lib/git-sync/outbound/extraction.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { runGit } from "../core/git_runner.js";
+import { readRefCommit } from "../core/repository.js";
+import { normalizeRepositoryPath, findCaseFoldCollisions, findUnicodeCollisions, } from "../core/path_normalizer.js";
+import { matchPath } from "../whitelist/matcher.js";
+import { validateOperationContent } from "../whitelist/validation.js";
+const ALL_ZERO_SHA = /^0+$/;
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function parseDiffTree(stdout) {
+    const parts = stdout.split("\0");
+    const records = [];
+    for (let i = 0; i + 1 < parts.length; i += 2) {
+        const meta = parts[i];
+        const rawPath = parts[i + 1];
+        if (!meta || meta.length === 0 || rawPath === undefined || rawPath.length === 0)
+            continue;
+        const fields = meta.replace(/^:/, "").split(" ");
+        if (fields.length < 5)
+            continue;
+        records.push({
+            srcMode: fields[0],
+            dstMode: fields[1],
+            srcSha: fields[2],
+            dstSha: fields[3],
+            status: fields[4],
+            rawPath,
+        });
+    }
+    return records;
+}
+function readBlob(repo, blobId) {
+    const size = Number.parseInt(runGit(repo.repositoryRoot, ["cat-file", "-s", blobId]).stdout.trim(), 10);
+    if (!Number.isFinite(size))
+        return null;
+    const { stdout } = runGit(repo.repositoryRoot, ["cat-file", "blob", blobId]);
+    const bytes = Buffer.from(stdout, "utf8");
+    if (bytes.byteLength !== size)
+        return null;
+    return { bytes, byteSize: size };
+}
+export function isCommitTreeReadable(repo, commitId) {
+    return runGit(repo.repositoryRoot, ["cat-file", "-e", `${commitId}^{tree}`], { allowFailure: true }).exitCode === 0;
+}
+export function extractCommitDelta(repo, commitId, whitelist, workspaceId, direction = "local_to_cloud") {
+    const parentCommitId = readRefCommit(repo, `${commitId}^1`);
+    return computeTreeDelta(repo, parentCommitId, commitId, whitelist, workspaceId, direction);
+}
+export function computeTreeDelta(repo, baseCommitId, targetCommitId, whitelist, workspaceId, direction = "local_to_cloud") {
+    const diffArgs = ["diff-tree", "-r", "-z", "--no-renames", "--no-commit-id"];
+    const args = baseCommitId === null ? [...diffArgs, "--root", targetCommitId] : [...diffArgs, baseCommitId, targetCommitId];
+    const { stdout } = runGit(repo.repositoryRoot, args);
+    const records = parseDiffTree(stdout);
+    const operations = [];
+    for (const record of records) {
+        const normalized = normalizeRepositoryPath(record.rawPath);
+        if (!normalized.ok) {
+            if (normalized.code === "protected_path")
+                continue;
+            return { ok: false, code: "invalid_path", path: record.rawPath };
+        }
+        const path = normalized.path;
+        const match = matchPath(whitelist, path, direction);
+        if (!match.allowed)
+            continue;
+        if (record.status === "D") {
+            operations.push({
+                path,
+                operation: "delete",
+                previousGitBlobId: ALL_ZERO_SHA.test(record.srcSha) ? undefined : record.srcSha,
+            });
+            continue;
+        }
+        const blob = readBlob(repo, record.dstSha);
+        if (!blob)
+            return { ok: false, code: "invalid_encoding", path };
+        const validation = validateOperationContent({
+            path,
+            mode: record.dstMode,
+            bytes: blob.bytes,
+            byteSize: blob.byteSize,
+            entry: match.entry,
+            workspaceId,
+        });
+        if (!validation.ok)
+            return { ok: false, code: validation.code, path };
+        operations.push({
+            path,
+            operation: "upsert",
+            gitBlobId: record.dstSha,
+            previousGitBlobId: ALL_ZERO_SHA.test(record.srcSha) ? undefined : record.srcSha,
+            contentSha256: sha256Hex(blob.bytes),
+            byteSize: blob.byteSize,
+            bytes: blob.bytes,
+            mode: record.dstMode,
+        });
+    }
+    const collision = firstCollision(operations.map((op) => op.path));
+    if (collision)
+        return { ok: false, code: "path_collision", path: collision };
+    return { ok: true, delta: { commitId: targetCommitId, parentCommitId: baseCommitId, operations } };
+}
+function firstCollision(paths) {
+    const groups = [...findCaseFoldCollisions(paths), ...findUnicodeCollisions(paths)];
+    return groups[0]?.[0] ?? null;
+}

package/dist/lib/git-sync/outbound/history_decision.js

@@ -0,0 +1,112 @@
+import { randomBytes } from "node:crypto";
+import { updateBindingCursor } from "../../local_store/bindings.js";
+import { insertHistoryDecision } from "../../local_store/history_decisions.js";
+import { readHeadCommit } from "../core/repository.js";
+import { resolveCommitRange } from "../core/commit_range.js";
+import { withReconciliationLock } from "../core/reconciliation_lock.js";
+import { loadPinnedWhitelist } from "../whitelist/store.js";
+import { computeTreeDelta, isCommitTreeReadable } from "./extraction.js";
+import { pushOperations } from "./queue.js";
+function mintHistoryDecisionId() {
+    const timePrefix = Date.now().toString(16).padStart(12, "0");
+    return `hdx_${timePrefix}${randomBytes(6).toString("hex")}`;
+}
+export function describeHistoryDecision(store, binding, repo) {
+    void store;
+    const headCommitId = readHeadCommit(repo);
+    const range = resolveCommitRange(repo, {
+        boundBranch: binding.boundBranch,
+        lastProcessedCommitId: binding.lastProcessedCommitId,
+    });
+    const oldBaselineCommitId = binding.lastProcessedCommitId;
+    return {
+        bindingId: binding.id,
+        pending: range.kind === "history_decision_required",
+        oldBaselineCommitId,
+        headCommitId,
+        baselineReadable: oldBaselineCommitId !== null && isCommitTreeReadable(repo, oldBaselineCommitId),
+    };
+}
+export async function publishCurrentState(store, binding, repo, deps) {
+    return withReconciliationLock(binding.id, async () => {
+        const head = readHeadCommit(repo);
+        if (head === null)
+            return { ok: false, code: "NO_HEAD" };
+        let whitelist;
+        try {
+            whitelist = await loadPinnedWhitelist(store, binding, deps.client);
+        }
+        catch {
+            return { ok: false, code: "WHITELIST_UNAVAILABLE" };
+        }
+        const oldBaseline = binding.lastProcessedCommitId;
+        const baselineReadable = oldBaseline !== null && isCommitTreeReadable(repo, oldBaseline);
+        const base = baselineReadable ? oldBaseline : null;
+        const mode = baselineReadable ? "exact_delta" : "full_tree";
+        const ctx = {
+            store,
+            binding,
+            repo,
+            client: deps.client,
+            whitelistRef: { current: whitelist },
+            workspaceId: binding.workspaceId,
+            now: deps.now ?? Date.now,
+        };
+        for (let staleDepth = 0;; staleDepth++) {
+            const delta = computeTreeDelta(repo, base, head, ctx.whitelistRef.current, binding.workspaceId);
+            if (!delta.ok)
+                return { ok: false, code: delta.code, detail: delta.path };
+            const result = await pushOperations(ctx, head, base, delta.delta.operations);
+            if (result.kind === "stale") {
+                if (staleDepth >= 2)
+                    return { ok: false, code: "SYNC_WHITELIST_STALE" };
+                try {
+                    ctx.whitelistRef.current = await loadPinnedWhitelist(store, binding, deps.client);
+                }
+                catch {
+                    return { ok: false, code: "WHITELIST_UNAVAILABLE" };
+                }
+                continue;
+            }
+            if (result.kind === "retry_scheduled")
+                return { ok: false, code: result.code };
+            if (result.kind === "blocked")
+                return { ok: false, code: result.code, detail: result.path };
+            if (result.kind === "not_due")
+                return { ok: false, code: "BACKOFF" };
+            const handoffId = result.kind === "accepted" ? result.handoffId : undefined;
+            updateBindingCursor(store, binding.id, { lastProcessedCommitId: head });
+            const decisionId = recordDecision(store, binding.id, "publish_current_state", oldBaseline, head, handoffId ?? null);
+            await reportDecisionHealth(deps, binding.id, head, "publish_current_state", oldBaseline, handoffId);
+            emitResolved(deps, binding.id, "publish_current_state", head, handoffId);
+            return { ok: true, newBaselineCommitId: head, mode, handoffId, noOp: result.kind === "no_op", decisionId };
+        }
+    });
+}
+export async function adoptWithoutPublishing(store, binding, repo, deps) {
+    return withReconciliationLock(binding.id, async () => {
+        const head = readHeadCommit(repo);
+        if (head === null)
+            return { ok: false, code: "NO_HEAD" };
+        const oldBaseline = binding.lastProcessedCommitId;
+        updateBindingCursor(store, binding.id, { lastProcessedCommitId: head });
+        const decisionId = recordDecision(store, binding.id, "adopt_without_publishing", oldBaseline, head, null);
+        await reportDecisionHealth(deps, binding.id, head, "adopt_without_publishing", oldBaseline, undefined);
+        emitResolved(deps, binding.id, "adopt_without_publishing", head, undefined);
+        return { ok: true, newBaselineCommitId: head, decisionId };
+    });
+}
+function recordDecision(store, bindingId, decision, oldBaselineCommitId, newBaselineCommitId, handoffId) {
+    const id = mintHistoryDecisionId();
+    insertHistoryDecision(store, { id, bindingId, decision, oldBaselineCommitId, newBaselineCommitId, handoffId });
+    return id;
+}
+async function reportDecisionHealth(deps, bindingId, newBaselineCommitId, decision, oldBaselineCommitId, handoffId) {
+    await deps.client.reportHealth(bindingId, {
+        lastProcessedCommitId: newBaselineCommitId,
+        lastHistoryDecision: { decision, oldBaselineCommitId, newBaselineCommitId, ...(handoffId ? { handoffId } : {}) },
+    });
+}
+function emitResolved(deps, bindingId, decision, newBaselineCommitId, handoffId) {
+    deps.emit?.({ event: "history_decision_resolved", bindingId, decision, newBaselineCommitId, ...(handoffId ? { handoffId } : {}) });
+}

package/dist/lib/git-sync/outbound/index.js

@@ -0,0 +1,26 @@
+import { ensureAccessToken } from "../../auth_grant.js";
+import { createUploadClient } from "./upload_client.js";
+import { runOutboundPublisher } from "./publisher.js";
+export function deviceTokenProvider(baseUrl) {
+    let cached = null;
+    return async (forceRefresh) => {
+        if (cached && !forceRefresh)
+            return cached;
+        const result = await ensureAccessToken(baseUrl);
+        cached = result?.accessToken ?? null;
+        return cached;
+    };
+}
+export function registerOutbound(engine, options) {
+    const getAccessToken = options.getAccessToken ?? deviceTokenProvider(options.baseUrl);
+    const client = createUploadClient({ baseUrl: options.baseUrl, getAccessToken, fetchImpl: options.fetchImpl });
+    engine.registerOutboundPublisher((ctx) => runOutboundPublisher(ctx, { client, now: options.now }));
+    return client;
+}
+export { runOutboundPublisher } from "./publisher.js";
+export { submitHead, pushOperations, backoffMs, enqueueCommit } from "./queue.js";
+export { describeHistoryDecision, publishCurrentState, adoptWithoutPublishing, } from "./history_decision.js";
+export { createUploadClient, classifyFailure, UploadRequestError } from "./upload_client.js";
+export { extractCommitDelta } from "./extraction.js";
+export { buildGitHandoffManifest, deriveIdempotencyKey } from "./manifest_builder.js";
+export { OUTBOUND_STATES } from "./state.js";

package/dist/lib/git-sync/outbound/manifest_builder.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+function sha256Hex(input) {
+    return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === "object") {
+        const source = value;
+        const out = {};
+        for (const key of Object.keys(source).sort())
+            out[key] = sortKeys(source[key]);
+        return out;
+    }
+    return value;
+}
+function toManifestOperation(op) {
+    if (op.operation === "delete") {
+        return { path: op.path, operation: "delete", ...(op.previousGitBlobId ? { previousGitBlobId: op.previousGitBlobId } : {}) };
+    }
+    return {
+        path: op.path,
+        operation: "upsert",
+        gitBlobId: op.gitBlobId,
+        contentSha256: op.contentSha256,
+        byteSize: op.byteSize,
+        ...(op.previousGitBlobId ? { previousGitBlobId: op.previousGitBlobId } : {}),
+    };
+}
+function sortOperations(operations) {
+    return [...operations].sort((a, b) => {
+        if (a.path !== b.path)
+            return a.path < b.path ? -1 : 1;
+        if (a.operation !== b.operation)
+            return a.operation < b.operation ? -1 : 1;
+        return 0;
+    });
+}
+export function deriveIdempotencyKey(bindingId, commitId, whitelistManifestSha256, manifestSha256) {
+    return sha256Hex(`git-handoff:v1:${bindingId}:${commitId}:${whitelistManifestSha256}:${manifestSha256}`);
+}
+export function buildGitHandoffManifest(input) {
+    const operations = sortOperations(input.operations.map(toManifestOperation));
+    const canonicalCore = {
+        schemaVersion: 1,
+        commitId: input.commitId,
+        parentCommitId: input.parentCommitId,
+        branch: input.binding.boundBranch,
+        whitelistManifestId: input.whitelist.manifestId,
+        whitelistManifestSha256: input.whitelist.manifestSha256,
+        operations,
+    };
+    const canonicalManifestBytes = JSON.stringify(sortKeys(canonicalCore));
+    const manifestSha256 = sha256Hex(canonicalManifestBytes);
+    const manifest = { ...canonicalCore, manifestSha256 };
+    const idempotencyKey = deriveIdempotencyKey(input.binding.id, input.commitId, input.whitelist.manifestSha256, manifestSha256);
+    return { manifest, canonicalManifestBytes, manifestSha256, idempotencyKey };
+}

package/dist/lib/git-sync/outbound/publisher.js

@@ -0,0 +1,51 @@
+import { updateBindingCursor } from "../../local_store/bindings.js";
+import { isCloudOriginCommit } from "../../local_store/commit_origins.js";
+import { loadPinnedWhitelist } from "../whitelist/store.js";
+import { submitHead } from "./queue.js";
+export async function runOutboundPublisher(ctx, runtime) {
+    const { store, repo, binding, commitIds, emit } = ctx;
+    const now = runtime.now ?? Date.now;
+    let whitelist;
+    try {
+        whitelist = await loadPinnedWhitelist(store, binding, runtime.client);
+    }
+    catch {
+        emit({ event: "error", bindingId: binding.id, code: "whitelist_unavailable", message: "the sync whitelist could not be loaded" });
+        return;
+    }
+    const submitCtx = {
+        store,
+        binding,
+        repo,
+        client: runtime.client,
+        whitelistRef: { current: whitelist },
+        workspaceId: binding.workspaceId,
+        now,
+    };
+    for (const commitId of commitIds) {
+        if (isCloudOriginCommit(store, binding.id, commitId)) {
+            updateBindingCursor(store, binding.id, { lastProcessedCommitId: commitId });
+            continue;
+        }
+        emit({ event: "upload_started", bindingId: binding.id, commitId });
+        const outcome = await submitHead(submitCtx, commitId);
+        switch (outcome.kind) {
+            case "accepted":
+                updateBindingCursor(store, binding.id, { lastProcessedCommitId: commitId });
+                emit({ event: "upload_result", bindingId: binding.id, commitId, outcome: "accepted", handoffId: outcome.handoffId, workspaceSequence: outcome.workspaceSequence });
+                break;
+            case "no_op":
+                updateBindingCursor(store, binding.id, { lastProcessedCommitId: commitId });
+                emit({ event: "upload_result", bindingId: binding.id, commitId, outcome: "no_op" });
+                break;
+            case "retry_scheduled":
+                emit({ event: "upload_result", bindingId: binding.id, commitId, outcome: "retry_scheduled", errorCode: outcome.code });
+                return;
+            case "not_due":
+                return;
+            case "blocked":
+                emit({ event: "upload_result", bindingId: binding.id, commitId, outcome: "blocked", errorCode: outcome.code });
+                return;
+        }
+    }
+}