@shipwithai/loopnote 0.0.0-stage → 2.0.0-bootstrap.0

package/dist/git/worktree-inventory.js

@@ -0,0 +1,391 @@
+import { randomBytes } from 'node:crypto';
+import { lstat, open } from 'node:fs/promises';
+import { ChangedFileSchema } from '../contracts/comparison.js';
+import { createExactPath, decodeBase64url } from '../domain/path-bytes.js';
+import { MAX_INLINE_TEXT_BYTES, classifyAvailability } from './availability.js';
+import { inventoryPaths, isLoopnoteInternalPath, opaqueFileId, validateObjectFormat, } from './inventory.js';
+import { createObjectReader } from './objects.js';
+import { joinDiffStats, parseNumstat } from './numstat.js';
+import { parseRawDiff } from './raw-diff.js';
+import { createGitRunner } from './runner.js';
+const emptyPathspecs = Object.freeze([]);
+const processFileIdNamespace = randomBytes(32);
+const knownModes = Object.freeze({
+    '000000': true,
+    '040000': true,
+    '100644': true,
+    '100755': true,
+    '120000': true,
+    '160000': true,
+});
+const statusKindByCode = Object.freeze({
+    A: 'added',
+    C: 'copied',
+    D: 'deleted',
+    M: 'modified',
+    R: 'renamed',
+    T: 'type-changed',
+});
+const regularFileModes = Object.freeze({
+    '100644': true,
+    '100755': true,
+});
+const sharedDiffOptions = [
+    '-z',
+    '--find-renames=50%',
+    '--find-copies=50%',
+    '--find-copies-harder',
+    '--no-ext-diff',
+    '--no-textconv',
+];
+function filterLoopnoteInternal(joined) {
+    return joined.filter(({ diff }) => {
+        const { oldPath, newPath } = inventoryPaths(diff);
+        return !isLoopnoteInternalPath(oldPath) && !isLoopnoteInternalPath(newPath);
+    });
+}
+async function buildChangedFile(diff, stats, objectFormat, namespace, classify) {
+    validateObjectFormat(diff, objectFormat);
+    const knownStatus = statusKindByCode[diff.status];
+    const hasUnsupportedMetadata = knownStatus === undefined ||
+        knownModes[diff.oldMode] !== true ||
+        knownModes[diff.newMode] !== true;
+    const statusKind = hasUnsupportedMetadata
+        ? 'unsupported'
+        : knownStatus;
+    const file = {
+        id: opaqueFileId(namespace, diff),
+        status: {
+            code: diff.status,
+            kind: statusKind,
+            similarity: diff.similarity,
+        },
+        oldMode: diff.oldMode,
+        newMode: diff.newMode,
+        oldBlobOid: diff.oldBlobOid,
+        newBlobOid: diff.newBlobOid,
+        ...inventoryPaths(diff),
+        additions: stats.additions,
+        deletions: stats.deletions,
+    };
+    const availability = await classify(file);
+    return ChangedFileSchema.parse({ ...file, availability });
+}
+/**
+ * Walks each path segment with `lstat`, rejecting any intermediate component
+ * that is a symlink (or not a directory) before resolving the leaf — the same
+ * per-segment traversal discipline as `PatchSnapshot.worktreeEntry()`
+ * (`src/server/patch-snapshot.ts:186-216`), duplicated here (not imported)
+ * because `src/git/` never depends on `src/server/`.
+ */
+async function lstatWorktreeLeaf(repositoryRoot, path) {
+    const parts = Buffer.from(decodeBase64url(path.bytesBase64url))
+        .toString('latin1')
+        .split('/');
+    let current = Buffer.from(repositoryRoot, 'utf8');
+    try {
+        for (const [index, part] of parts.entries()) {
+            current = Buffer.concat([
+                current,
+                Buffer.from('/', 'ascii'),
+                Buffer.from(part, 'latin1'),
+            ]);
+            const info = await lstat(current);
+            if (index < parts.length - 1) {
+                if (info.isSymbolicLink() || !info.isDirectory()) {
+                    return { kind: 'missing' };
+                }
+                continue;
+            }
+            if (info.isSymbolicLink()) {
+                return { kind: 'symlink' };
+            }
+            if (!info.isFile()) {
+                return { kind: 'missing' };
+            }
+            return {
+                kind: 'file',
+                size: info.size,
+                executable: (info.mode & 0o111) !== 0,
+            };
+        }
+        return { kind: 'missing' };
+    }
+    catch (error) {
+        if (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT') {
+            return { kind: 'missing' };
+        }
+        throw error;
+    }
+}
+/**
+ * Bounded read-then-verify: open the resolved leaf path, confirm it is still
+ * a regular file of exactly `expectedSize` bytes, and read no more than that
+ * (via the `expectedSize + 1` over-read trick to detect concurrent growth) —
+ * identical discipline to `boundedFileBytes()` (`src/server/snapshot-fs.ts`),
+ * duplicated here for the same layering reason as `lstatWorktreeLeaf`.
+ */
+async function readWorktreeLeafBytes(repositoryRoot, path, expectedSize) {
+    const absolutePath = Buffer.concat([
+        Buffer.from(repositoryRoot, 'utf8'),
+        Buffer.from('/', 'ascii'),
+        Buffer.from(decodeBase64url(path.bytesBase64url)),
+    ]);
+    let handle;
+    try {
+        handle = await open(absolutePath, 'r');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const info = await handle.stat();
+        if (!info.isFile() || info.size !== expectedSize) {
+            return undefined;
+        }
+        const bytes = Buffer.allocUnsafe(expectedSize + 1);
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const { bytesRead } = await handle.read(bytes, offset, bytes.byteLength - offset, offset);
+            if (bytesRead === 0) {
+                break;
+            }
+            offset += bytesRead;
+        }
+        if (offset !== expectedSize) {
+            return undefined;
+        }
+        return bytes.subarray(0, expectedSize);
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Mirrors `classifyAvailability()`'s cascade (mode/status checks, size
+ * ceiling, numstat binary flag, embedded-NUL check, strict UTF-8 decode) but
+ * substitutes a bounded `fs` read for the one side that is worktree-resident
+ * (not a Git object) instead of going through `ObjectReader`. The other side
+ * (when present) still goes through `objectReader` unchanged. `hasNumstat`
+ * is `false` for untracked files, which have no numstat line at all (their
+ * `additions`/`deletions` are always `null` by construction, not a binary
+ * signal) — those fall through to the real embedded-NUL content check instead.
+ */
+async function classifyWorktreeSideAvailability(file, objectReader, worktreeSide, repositoryRoot, signal, hasNumstat = true) {
+    if (file.oldMode === '160000' || file.newMode === '160000') {
+        return { kind: 'unsupported', reason: 'submodule' };
+    }
+    if (file.oldMode === '120000' || file.newMode === '120000') {
+        return { kind: 'unsupported', reason: 'symlink' };
+    }
+    if (file.status.kind === 'unsupported') {
+        return { kind: 'unsupported', reason: 'mode-or-type' };
+    }
+    const sides = [];
+    if (file.oldMode !== '000000') {
+        if (regularFileModes[file.oldMode] !== true) {
+            return { kind: 'unsupported', reason: 'mode-or-type' };
+        }
+        sides.push({ side: 'old', mode: file.oldMode, oid: file.oldBlobOid });
+    }
+    if (file.newMode !== '000000') {
+        if (regularFileModes[file.newMode] !== true) {
+            return { kind: 'unsupported', reason: 'mode-or-type' };
+        }
+        sides.push({ side: 'new', mode: file.newMode, oid: file.newBlobOid });
+    }
+    if (sides.length === 0) {
+        return { kind: 'unsupported', reason: 'mode-or-type' };
+    }
+    const sizes = [];
+    for (const side of sides) {
+        if (side.side === worktreeSide) {
+            const path = worktreeSide === 'new' ? file.newPath : file.oldPath;
+            if (path === undefined) {
+                return { kind: 'unavailable', reason: 'missing-object' };
+            }
+            const leaf = await lstatWorktreeLeaf(repositoryRoot, path);
+            if (leaf.kind !== 'file') {
+                return { kind: 'unavailable', reason: 'missing-object' };
+            }
+            sizes.push(leaf.size);
+        }
+        else {
+            const metadata = await objectReader.inspect(side.oid, signal);
+            if (metadata.kind === 'missing' || metadata.objectType !== 'blob') {
+                return { kind: 'unavailable', reason: 'missing-object' };
+            }
+            sizes.push(metadata.size);
+        }
+    }
+    if (sizes.some((size) => size > MAX_INLINE_TEXT_BYTES)) {
+        return { kind: 'unsupported', reason: 'oversized' };
+    }
+    if (hasNumstat && (file.additions === null || file.deletions === null)) {
+        return { kind: 'unsupported', reason: 'binary' };
+    }
+    const contents = [];
+    for (let index = 0; index < sides.length; index += 1) {
+        const side = sides[index];
+        if (side.side === worktreeSide) {
+            const path = worktreeSide === 'new' ? file.newPath : file.oldPath;
+            const bytes = path === undefined
+                ? undefined
+                : await readWorktreeLeafBytes(repositoryRoot, path, sizes[index]);
+            if (bytes === undefined) {
+                return { kind: 'unavailable', reason: 'missing-object' };
+            }
+            contents.push(bytes);
+        }
+        else {
+            const content = await objectReader.read(side.oid, {
+                maxBytes: MAX_INLINE_TEXT_BYTES,
+                signal,
+            });
+            if (content.kind === 'missing' ||
+                content.bytes.byteLength !== sizes[index]) {
+                return { kind: 'unavailable', reason: 'missing-object' };
+            }
+            contents.push(content.bytes);
+        }
+    }
+    if (contents.some((content) => content.includes(0))) {
+        return { kind: 'unsupported', reason: 'binary' };
+    }
+    const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+    try {
+        for (const content of contents) {
+            utf8Decoder.decode(content);
+        }
+    }
+    catch {
+        return { kind: 'unsupported', reason: 'non-utf8' };
+    }
+    return { kind: 'text' };
+}
+function parseNulDelimitedUntrackedPaths(output) {
+    const paths = [];
+    let offset = 0;
+    while (offset < output.length) {
+        const end = output.indexOf(0, offset);
+        if (end === -1) {
+            break;
+        }
+        if (end > offset) {
+            paths.push(createExactPath(output.subarray(offset, end)));
+        }
+        offset = end + 1;
+    }
+    return Object.freeze(paths);
+}
+export async function buildUntrackedChangedFile(path, objectFormat, namespace, objectReader, repositoryRoot, signal) {
+    const leaf = await lstatWorktreeLeaf(repositoryRoot, path);
+    const newMode = leaf.kind === 'symlink'
+        ? '120000'
+        : leaf.kind === 'file' && leaf.executable
+            ? '100755'
+            : '100644';
+    const zeroOid = '0'.repeat(objectFormat === 'sha1' ? 40 : 64);
+    const diff = Object.freeze({
+        oldMode: '000000',
+        newMode,
+        oldBlobOid: zeroOid,
+        newBlobOid: zeroOid,
+        status: 'A',
+        similarity: null,
+        paths: Object.freeze([path]),
+    });
+    return buildChangedFile(diff, { additions: null, deletions: null }, objectFormat, namespace, (file) => classifyWorktreeSideAvailability(file, objectReader, 'new', repositoryRoot, signal, false));
+}
+export async function createWorktreeChangedFileInventory(options, dependencies = {}) {
+    const pathspecTail = Object.freeze([
+        '--',
+        ...(options.pathspecs ?? emptyPathspecs),
+    ]);
+    const runner = dependencies.runner ?? createGitRunner();
+    const objectReader = dependencies.objectReader ??
+        createObjectReader(options.repositoryRoot, { runner });
+    const namespace = options.fileIdNamespace ?? processFileIdNamespace;
+    if (namespace.byteLength === 0) {
+        throw new RangeError('File ID namespace must not be empty');
+    }
+    if (options.sourceKind === 'staged') {
+        const mergeBaseOid = options.mergeBaseOid;
+        if (mergeBaseOid === undefined) {
+            throw new RangeError('mergeBaseOid is required when sourceKind is "staged"');
+        }
+        const [rawResult, numstatResult] = await Promise.all([
+            runner.run([
+                'diff',
+                '--cached',
+                '--raw',
+                sharedDiffOptions[0],
+                '--no-abbrev',
+                ...sharedDiffOptions.slice(1),
+                mergeBaseOid,
+                ...pathspecTail,
+            ], { cwd: options.repositoryRoot, signal: options.signal }),
+            runner.run([
+                'diff',
+                '--cached',
+                '--numstat',
+                ...sharedDiffOptions,
+                mergeBaseOid,
+                ...pathspecTail,
+            ], { cwd: options.repositoryRoot, signal: options.signal }),
+        ]);
+        const joined = joinDiffStats(parseRawDiff(rawResult.stdout), parseNumstat(numstatResult.stdout));
+        const reviewable = filterLoopnoteInternal(joined);
+        const files = await Promise.all(reviewable.map(({ diff, stats }) => buildChangedFile(diff, stats, options.objectFormat, namespace, (file) => classifyAvailability(file, objectReader, options.signal))));
+        return Object.freeze(files);
+    }
+    if (options.sourceKind === 'unstaged') {
+        const [rawResult, numstatResult] = await Promise.all([
+            runner.run([
+                'diff',
+                '--raw',
+                sharedDiffOptions[0],
+                '--no-abbrev',
+                ...sharedDiffOptions.slice(1),
+                ...pathspecTail,
+            ], { cwd: options.repositoryRoot, signal: options.signal }),
+            runner.run(['diff', '--numstat', ...sharedDiffOptions, ...pathspecTail], { cwd: options.repositoryRoot, signal: options.signal }),
+        ]);
+        const joined = joinDiffStats(parseRawDiff(rawResult.stdout), parseNumstat(numstatResult.stdout));
+        const reviewable = filterLoopnoteInternal(joined);
+        const files = await Promise.all(reviewable.map(({ diff, stats }) => buildChangedFile(diff, stats, options.objectFormat, namespace, (file) => classifyWorktreeSideAvailability(file, objectReader, 'new', options.repositoryRoot, options.signal))));
+        return Object.freeze(files);
+    }
+    if (options.sourceKind === 'worktree') {
+        const mergeBaseOid = options.mergeBaseOid;
+        if (mergeBaseOid === undefined) {
+            throw new RangeError('mergeBaseOid is required when sourceKind is "worktree"');
+        }
+        const [rawResult, numstatResult, untrackedResult] = await Promise.all([
+            runner.run([
+                'diff',
+                '--raw',
+                sharedDiffOptions[0],
+                '--no-abbrev',
+                ...sharedDiffOptions.slice(1),
+                mergeBaseOid,
+                ...pathspecTail,
+            ], { cwd: options.repositoryRoot, signal: options.signal }),
+            runner.run([
+                'diff',
+                '--numstat',
+                ...sharedDiffOptions,
+                mergeBaseOid,
+                ...pathspecTail,
+            ], { cwd: options.repositoryRoot, signal: options.signal }),
+            runner.run(['ls-files', '--others', '--exclude-standard', '-z', ...pathspecTail], { cwd: options.repositoryRoot, signal: options.signal }),
+        ]);
+        const joined = joinDiffStats(parseRawDiff(rawResult.stdout), parseNumstat(numstatResult.stdout));
+        const reviewable = filterLoopnoteInternal(joined);
+        const trackedFiles = await Promise.all(reviewable.map(({ diff, stats }) => buildChangedFile(diff, stats, options.objectFormat, namespace, (file) => classifyWorktreeSideAvailability(file, objectReader, 'new', options.repositoryRoot, options.signal))));
+        const untrackedPaths = parseNulDelimitedUntrackedPaths(untrackedResult.stdout).filter((path) => !isLoopnoteInternalPath(path));
+        const untrackedFiles = await Promise.all(untrackedPaths.map((path) => buildUntrackedChangedFile(path, options.objectFormat, namespace, objectReader, options.repositoryRoot, options.signal)));
+        return Object.freeze([...trackedFiles, ...untrackedFiles]);
+    }
+    throw new RangeError('Unreachable: sourceKind must be staged, unstaged, or worktree');
+}

package/dist/server/app.js

@@ -0,0 +1,171 @@
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import fastifyStatic from '@fastify/static';
+import Fastify from 'fastify';
+import { createCapabilityRegistry, createExactPatchCapabilityRegistry, createUncommittedCapabilityRegistry, createStandaloneCapabilityRegistry, createSupportCapability, } from './capabilities.js';
+import { createHostedSupportClient } from './support-client.js';
+import { createSupportStore } from './support-store.js';
+import { createDraftStore, } from './draft-store.js';
+import { registerSessionRoutes } from './routes.js';
+import { materializePatchSnapshot } from './patch-snapshot.js';
+import { materializeWorktreeSnapshot } from './worktree-snapshot.js';
+import { registerSessionSecurity, } from './security.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+export function createConfiguredSupportCapability(environment = process.env) {
+    const serviceUrl = environment[`${RENAME_MAP.envPrefix}SUPPORT_SERVICE_URL`];
+    try {
+        if (serviceUrl === undefined || new URL(serviceUrl).protocol !== 'https:')
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return createSupportCapability(createSupportStore(), createHostedSupportClient({ serviceUrl }));
+}
+function testRecoveryFailure() {
+    if (process.env.NODE_ENV !== 'test') {
+        return undefined;
+    }
+    const configured = process.env[`${RENAME_MAP.envPrefix}TEST_RECOVERY_FAILURE`];
+    return configured === 'backup' || configured === 'replacement' ? configured : undefined;
+}
+function createRecoveryFaultFileSystem(failure) {
+    return {
+        readFile: async (path) => fs.readFile(path),
+        mkdir: async (path) => {
+            await fs.mkdir(path, { recursive: true });
+        },
+        open: async (path, flags, mode) => {
+            if ((failure === 'backup' && path.endsWith('.bak')) ||
+                (failure === 'replacement' && path.endsWith('.tmp'))) {
+                throw new Error('Test-only recovery persistence failure.');
+            }
+            const handle = await fs.open(path, flags, mode);
+            return {
+                writeFile: async (bytes) => handle.writeFile(bytes),
+                sync: async () => handle.sync(),
+                close: async () => handle.close(),
+            };
+        },
+        rename: async (from, to) => fs.rename(from, to),
+        unlink: async (path) => fs.unlink(path),
+        syncDirectory: async (path) => {
+            const handle = await fs.open(path, 'r');
+            try {
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        },
+    };
+}
+function createAppDraftStore(comparison, options) {
+    if (options.draftStore !== undefined) {
+        return options.draftStore;
+    }
+    const failure = testRecoveryFailure();
+    return createDraftStore({
+        repositoryRoot: comparison.repositoryRoot,
+        comparison: comparison.range === undefined
+            ? {
+                baseCommitOid: comparison.base.oid,
+                headCommitOid: comparison.head.oid,
+                mergeBaseOid: comparison.mergeBaseOid,
+            }
+            : {
+                baseCommitOid: comparison.base.oid,
+                headCommitOid: comparison.head.oid,
+                mergeBaseOid: comparison.mergeBaseOid,
+                range: comparison.range,
+            },
+        ...(options.attachedCompletion === undefined ? {} : { storageScope: options.attachedCompletion.storageScope }),
+        ...(failure === undefined ? {} : { fileSystem: createRecoveryFaultFileSystem(failure) }),
+    });
+}
+export function createSessionApp(comparison, options) {
+    const app = Fastify({
+        logger: false,
+        ajv: { customOptions: { removeAdditional: false } },
+    });
+    const support = options.support ?? createConfiguredSupportCapability();
+    const webRoot = options.webRoot ?? resolve(import.meta.dirname, '../web');
+    const draftStore = createAppDraftStore(comparison, options);
+    const capabilities = createCapabilityRegistry(comparison, { ...options, draftStore, support });
+    const security = registerSessionSecurity(app, options);
+    app.decorate('bindSessionSecurity', security.bind);
+    app.addHook('onClose', async () => support?.close());
+    registerSessionRoutes(app, capabilities);
+    void app.register(fastifyStatic, {
+        root: webRoot,
+        index: ['index.html'],
+    });
+    return app;
+}
+export async function createExactPatchSessionApp(grounded, options) {
+    const snapshot = await materializePatchSnapshot(grounded, {
+        parent: options.snapshotParent,
+        observeTarget: options.observePatchTarget,
+    });
+    const app = Fastify({
+        logger: false,
+        ajv: { customOptions: { removeAdditional: false } },
+    });
+    const webRoot = options.webRoot ?? resolve(import.meta.dirname, '../web');
+    const support = options.support ?? createConfiguredSupportCapability();
+    const capabilities = await createExactPatchCapabilityRegistry(grounded, snapshot, { ...options, support });
+    const security = registerSessionSecurity(app, options);
+    app.addHook('onClose', async () => support?.close());
+    app.decorate('bindSessionSecurity', security.bind);
+    app.addHook('onClose', async () => snapshot.dispose());
+    registerSessionRoutes(app, capabilities);
+    void app.register(fastifyStatic, {
+        root: webRoot,
+        index: ['index.html'],
+    });
+    return app;
+}
+export async function createUncommittedSessionApp(scope, options) {
+    const snapshot = await materializeWorktreeSnapshot(scope, {
+        root: options.snapshotRoot ?? join(tmpdir(), `${RENAME_MAP.slug}-worktree-${randomUUID()}`),
+    });
+    const app = Fastify({
+        logger: false,
+        ajv: { customOptions: { removeAdditional: false } },
+    });
+    const webRoot = options.webRoot ?? resolve(import.meta.dirname, '../web');
+    const support = options.support ?? createConfiguredSupportCapability();
+    const capabilities = await createUncommittedCapabilityRegistry(scope, snapshot, { ...options, support });
+    const security = registerSessionSecurity(app, options);
+    app.addHook('onClose', async () => support?.close());
+    app.decorate('bindSessionSecurity', security.bind);
+    registerSessionRoutes(app, capabilities);
+    void app.register(fastifyStatic, {
+        root: webRoot,
+        index: ['index.html'],
+    });
+    return app;
+}
+export async function createStandaloneSessionApp(scope, options) {
+    const snapshot = await materializeWorktreeSnapshot(scope, {
+        root: options.snapshotRoot ?? join(tmpdir(), `${RENAME_MAP.slug}-worktree-${randomUUID()}`),
+    });
+    const app = Fastify({
+        logger: false,
+        ajv: { customOptions: { removeAdditional: false } },
+    });
+    const webRoot = options.webRoot ?? resolve(import.meta.dirname, '../web');
+    const support = options.support ?? createConfiguredSupportCapability();
+    const capabilities = await createStandaloneCapabilityRegistry(scope, snapshot, { ...options, support });
+    const security = registerSessionSecurity(app, options);
+    app.addHook('onClose', async () => support?.close());
+    app.decorate('bindSessionSecurity', security.bind);
+    registerSessionRoutes(app, capabilities);
+    void app.register(fastifyStatic, {
+        root: webRoot,
+        index: ['index.html'],
+    });
+    return app;
+}

package/dist/server/attached-completion.js

@@ -0,0 +1,85 @@
+import { AttachedCompletionStatusSchema, FinishReviewResultSchema, } from '../contracts/api.js';
+export class AttachedCompletionCoordinator {
+    #status = AttachedCompletionStatusSchema.parse({ kind: 'waiting' });
+    #inFlight;
+    #terminal;
+    #resolveDelivery;
+    #resolveResponseSettled;
+    delivery;
+    responseSettled;
+    constructor() {
+        const delivery = Promise.withResolvers();
+        this.delivery = delivery.promise;
+        this.#resolveDelivery = delivery.resolve;
+        const responseSettled = Promise.withResolvers();
+        this.responseSettled = responseSettled.promise;
+        this.#resolveResponseSettled = responseSettled.resolve;
+    }
+    markResponseSettled() {
+        if (this.#status.kind === 'completed')
+            this.#resolveResponseSettled();
+    }
+    cancel() {
+        if (this.#status.kind === 'completed' || this.#terminal !== undefined)
+            return;
+        const result = FinishReviewResultSchema.parse({ kind: 'deliveryFailed' });
+        this.#terminal = result;
+        this.#resolveDelivery(result);
+    }
+    async runDelivery(operation) {
+        if (this.#status.kind === 'completed' || this.#terminal !== undefined)
+            return false;
+        await operation();
+        return true;
+    }
+    status() {
+        return this.#status;
+    }
+    async finish(expectedRevision, operation) {
+        if (this.#status.kind === 'completed') {
+            return FinishReviewResultSchema.parse({ kind: 'alreadyCompleted', revision: this.#status.revision });
+        }
+        if (this.#terminal !== undefined) {
+            return this.#terminal;
+        }
+        if (this.#inFlight !== undefined) {
+            return this.#inFlight;
+        }
+        this.#status = AttachedCompletionStatusSchema.parse({ kind: 'finishing', expectedRevision });
+        const attempt = (async () => {
+            let result;
+            try {
+                result = FinishReviewResultSchema.parse(await operation());
+            }
+            catch {
+                result = FinishReviewResultSchema.parse({ kind: 'deliveryFailed' });
+            }
+            if (this.#terminal !== undefined)
+                return this.#terminal;
+            if (result.kind === 'completed') {
+                this.#status = AttachedCompletionStatusSchema.parse({ kind: 'completed', revision: result.revision });
+                this.#resolveDelivery(result);
+            }
+            else if (result.kind === 'deliveryFailed') {
+                this.#terminal = result;
+                this.#resolveDelivery(result);
+            }
+            else {
+                this.#status = AttachedCompletionStatusSchema.parse({ kind: 'waiting' });
+            }
+            return result;
+        })();
+        this.#inFlight = attempt;
+        try {
+            return await attempt;
+        }
+        finally {
+            if (this.#inFlight === attempt && this.#terminal === undefined && this.#status.kind !== 'finishing') {
+                this.#inFlight = undefined;
+            }
+        }
+    }
+}
+export function createAttachedCompletionCoordinator() {
+    return new AttachedCompletionCoordinator();
+}