@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/activities/pr/decision-claim.js

@@ -0,0 +1,76 @@
+import { createEventDraft, EventSourceKind, } from '../../kernel/index.js';
+import { ActivityEventType, decodeActivityEvent, decodeActivityEventDraft, } from '../contracts/events.js';
+import { activityDecisionStream } from '../contracts/streams.js';
+import { ActivityFailureCode, ActivityOutcomeKind, IntentAppendStatus, } from '../contracts/vocabulary.js';
+import { appendResolved } from './activity-support.js';
+export async function readDecisionClaim(journal, activationId, action) {
+    const claimId = decisionClaimId(activationId, action);
+    const event = (await journal.readStream(activityDecisionStream(activationId, action))).find((candidate) => candidate.eventId === claimId);
+    return event === undefined ? null : parseClaim(event, activationId, action);
+}
+export async function claimDecision(journal, activationId, action, proposal) {
+    const existing = await readDecisionClaim(journal, activationId, action);
+    if (existing !== null)
+        return existing;
+    const stream = activityDecisionStream(activationId, action);
+    const claim = createEventDraft({
+        eventId: decisionClaimId(activationId, action),
+        eventType: decisionEventType(action),
+        occurredAt: proposal.fact.occurredAt,
+        correlationId: proposal.fact.correlationId,
+        causationId: proposal.fact.causationId,
+        actor: proposal.fact.actor,
+        source: { kind: EventSourceKind.Internal, id: 'activities-pr' },
+        stream,
+        payload: {
+            action,
+            activationId,
+            decisionKind: proposal.decisionKind,
+            outcome: proposal.outcome,
+            fact: proposal.fact,
+        },
+    });
+    decodeActivityEventDraft(claim);
+    try {
+        await journal.append(stream, 0, [claim]);
+        return proposal;
+    }
+    catch (error) {
+        const winner = await readDecisionClaim(journal, activationId, action);
+        if (winner !== null)
+            return winner;
+        throw error;
+    }
+}
+export async function completeDecisionClaim(journal, appender, decision) {
+    const result = await appendResolved(journal, appender, decision.fact.stream, decision.fact);
+    return result === IntentAppendStatus.Failed
+        ? { kind: ActivityOutcomeKind.Failed, data: { reason: ActivityFailureCode.IntentWriteFailed } }
+        : decision.outcome;
+}
+export async function claimAndCompleteDecision(journal, appender, activationId, action, proposal) {
+    const claimed = await claimDecision(journal, activationId, action, proposal);
+    return completeDecisionClaim(journal, appender, claimed);
+}
+function decisionClaimId(activationId, action) {
+    return `${activationId}:${decisionEventType(action)}`;
+}
+function parseClaim(event, activationId, action) {
+    const decoded = decodeActivityEvent(event);
+    const expectedType = decisionEventType(action);
+    if (decoded.eventType !== expectedType ||
+        decoded.payload.activationId !== activationId ||
+        decoded.payload.action !== action) {
+        throw new Error(`Invalid pull-request decision claim ${event.eventId}`);
+    }
+    return {
+        decisionKind: decoded.payload.decisionKind,
+        outcome: decoded.payload.outcome,
+        fact: decoded.payload.fact,
+    };
+}
+function decisionEventType(action) {
+    return action === 'approve'
+        ? ActivityEventType.PrApproveDecisionClaimed
+        : ActivityEventType.PrMergeDecisionClaimed;
+}

package/dist/src/activities/pr/event-drafts.js

@@ -0,0 +1,66 @@
+import { createEventDraft, EventSourceKind } from '../../kernel/index.js';
+import { resourceStream } from '../../resources/index.js';
+import { ActivityEventType, } from '../contracts/events.js';
+import { activationId } from '../contracts/identifiers.js';
+import { isReviewAuthorized } from '../review/authorization.js';
+export const discovered = ({ resourceId, ...command }, context) => fact(resourceId, ActivityEventType.PrDiscovered, command, context);
+export const revisionChanged = (command, context) => fact(command.resourceId, ActivityEventType.PrRevisionChanged, {
+    headRevision: command.headRevision,
+    baseRevision: command.baseRevision,
+    ...(command.changedFiles === undefined ? {} : { changedFiles: command.changedFiles }),
+}, context);
+export const stateChanged = (command, context) => fact(command.resourceId, ActivityEventType.PrStateChanged, { state: command.state }, context);
+export const checksChanged = (command, context) => fact(command.resourceId, ActivityEventType.PrChecksChanged, { checks: command.checks }, context);
+export const reviewAccepted = (command, context) => fact(command.resourceId, ActivityEventType.PrReviewAccepted, { revision: command.revision, actorId: command.actorId }, context);
+export const reviewAcceptanceSignalRecorded = (command, context) => fact(command.resourceId, ActivityEventType.ReviewAcceptanceSignalRecorded, {
+    revision: command.revision,
+    actorId: command.actorId,
+    actorKind: command.actorKind,
+    acceptedEventId: `${context.commandId}:${ActivityEventType.PrReviewAccepted}`,
+    providerEventId: command.acceptedEventId,
+    trusted: isReviewAuthorized(command),
+}, context);
+export const reviewChangesRequested = (command, context) => fact(command.resourceId, ActivityEventType.PrReviewChangesRequested, { revision: command.revision, actorId: command.actorId }, context);
+export const reviewRejected = (resourceId, reason, context) => fact(resourceId, ActivityEventType.PrReviewRejected, { reason }, context);
+export const mergeDenied = (stream, reason, context, audit = {}) => denialDraft(ActivityEventType.PrMergeDenied, stream, reason, context, audit);
+export const approveDenied = (stream, reason, context, audit = {}) => denialDraft(ActivityEventType.PrApproveDenied, stream, reason, context, audit);
+export const mergeAuthorized = (stream, revision, context) => createEventDraft({
+    ...metadata(ActivityEventType.PrMergeAuthorized, context),
+    stream,
+    payload: { revision },
+});
+export const deliveryIntentRequested = (resourceId, type, payload, context) => createEventDraft({
+    ...metadata(type, context),
+    stream: resourceStream(resourceId),
+    payload: { idempotencyKey: `${context.commandId}:${type}`, ...payload },
+});
+function fact(resourceId, eventType, payload, context) {
+    return createEventDraft({
+        ...metadata(eventType, context),
+        stream: resourceStream(resourceId),
+        payload,
+    });
+}
+function denialDraft(eventType, stream, reason, context, audit) {
+    return createEventDraft({
+        ...metadata(eventType, context),
+        stream,
+        payload: {
+            activationId: activationId(context.commandId),
+            idempotencyKey: `${context.commandId}:${eventType}`,
+            reason,
+            ...audit,
+        },
+    });
+}
+function metadata(eventType, context) {
+    return {
+        eventId: `${context.commandId}:${eventType}`,
+        eventType,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.commandId,
+        actor: context.actor,
+        source: { kind: EventSourceKind.Internal, id: 'activities-pr' },
+    };
+}

package/dist/src/activities/pr/intent.js

@@ -0,0 +1,37 @@
+import { EventActorKind, WrongExpectedSequenceError, } from '../../kernel/index.js';
+import { IntentAppendStatus } from '../contracts/vocabulary.js';
+export function createJournalIntentAppender(journal) {
+    return {
+        append: (stream, intent) => appendIntentOnce(journal, stream, intent),
+    };
+}
+export async function appendIntentOnce(journal, stream, intent) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const events = await journal.readStream(stream);
+        if (events.some((event) => event.eventId === intent.eventId))
+            return IntentAppendStatus.Known;
+        try {
+            await journal.append(stream, events.length, [intent]);
+            return IntentAppendStatus.Appended;
+        }
+        catch (error) {
+            const observed = await journal.readStream(stream);
+            if (observed.some((event) => event.eventId === intent.eventId))
+                return IntentAppendStatus.Known;
+            if (!(error instanceof WrongExpectedSequenceError))
+                return IntentAppendStatus.Failed;
+        }
+    }
+    const reconciled = await journal.readStream(stream);
+    return reconciled.some((event) => event.eventId === intent.eventId)
+        ? IntentAppendStatus.Known
+        : IntentAppendStatus.Failed;
+}
+export function activityCommandContext(activationId, orchestrationGroupId, occurredAt) {
+    return {
+        commandId: activationId,
+        correlationId: orchestrationGroupId,
+        occurredAt,
+        actor: { kind: EventActorKind.System, id: 'activities-pr' },
+    };
+}

package/dist/src/activities/pr/merge-authority-gate.js

@@ -0,0 +1,14 @@
+import { EventActorKind } from '../../kernel/index.js';
+export function createPullRequestMergeAuthorityGate(service) {
+    return {
+        async evaluate(input, occurredAt) {
+            const allowed = await service.authorizeMerge(input.workItemId, {
+                commandId: `${input.activationId}:pr.merge`,
+                correlationId: input.orchestrationGroupId,
+                occurredAt,
+                actor: { kind: EventActorKind.System, id: 'activities-pr' },
+            });
+            return { kind: allowed ? 'merge-authorized' : 'merge-denied' };
+        },
+    };
+}

package/dist/src/activities/pr/merge.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { ActivityOutcomeKind } from '../contracts/vocabulary.js';
+import { MergeMethod } from './vocabulary.js';
+import { BuiltInResourceCapability, resourceStream } from '../../resources/index.js';
+import { workItemStream } from '../../work/index.js';
+import { ActivityEventType } from '../contracts/events.js';
+import { ActivityExecutionKind, BuiltInActivityName } from '../contracts/vocabulary.js';
+import { pullRequestOutcomeSchema, pullRequestTargetSchema, resolvePrimaryCapability, selectedDenialAudit, selectionDenialAudit, } from './activity-support.js';
+import { claimAndCompleteDecision, completeDecisionClaim, readDecisionClaim, } from './decision-claim.js';
+import { deliveryIntentRequested, mergeDenied } from './event-drafts.js';
+import { activityCommandContext, createJournalIntentAppender, } from './intent.js';
+import { decidePullRequestAuthority } from './policy.js';
+const inputSchema = z
+    .object({
+    target: pullRequestTargetSchema,
+    method: z.enum([MergeMethod.Merge, MergeMethod.Squash, MergeMethod.Rebase]),
+    requireChecks: z.boolean(),
+    requireApproval: z.boolean().default(true),
+    autoMerge: z.boolean().default(false),
+    maxFilesChanged: z.number().int().positive().optional(),
+    blockedPaths: z.array(z.string().min(1)).default([]),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if (!input.requireApproval && !input.autoMerge)
+        context.addIssue({
+            code: 'custom',
+            path: ['requireApproval'],
+            message: 'requireApproval may be false only when autoMerge is true',
+        });
+});
+export function createPullRequestMergeActivity(journal, pullRequests, appender = createJournalIntentAppender(journal)) {
+    return {
+        name: BuiltInActivityName.PullRequestMerge,
+        inputSchema,
+        outcomeSchema: pullRequestOutcomeSchema,
+        outcomeKinds: [
+            ActivityOutcomeKind.Waiting,
+            ActivityOutcomeKind.Done,
+            ActivityOutcomeKind.Blocked,
+            ActivityOutcomeKind.Failed,
+        ],
+        resources: [],
+        executionKind: ActivityExecutionKind.Deterministic,
+        handler: {
+            execute: (invocation, context) => executeMerge(journal, pullRequests, appender, invocation, context),
+        },
+    };
+}
+async function executeMerge(journal, pullRequests, appender, invocation, context) {
+    const requireApproval = invocation.input.requireApproval ?? true;
+    const autoMerge = invocation.input.autoMerge ?? false;
+    const command = activityCommandContext(invocation.activationId, invocation.orchestrationGroupId, context.occurredAt);
+    const prior = await readDecisionClaim(journal, invocation.activationId, MergeMethod.Merge);
+    if (prior !== null)
+        return completeDecisionClaim(journal, appender, prior);
+    const authority = await pullRequests.authorityInput(invocation.workItemId);
+    const resource = resolvePrimaryCapability(invocation.resources, authority, invocation.workItemId, invocation.input.target, BuiltInResourceCapability.Mergeable);
+    if (!resource.allowed) {
+        const denial = mergeDenied(workItemStream(invocation.workItemId), resource.reason, command, {
+            ...selectionDenialAudit(invocation.input.target, resource.candidates),
+            method: invocation.input.method,
+        });
+        return claimAndCompleteDecision(journal, appender, invocation.activationId, MergeMethod.Merge, {
+            decisionKind: 'denied',
+            outcome: { kind: ActivityOutcomeKind.Blocked, data: { reason: resource.reason } },
+            fact: denial,
+        });
+    }
+    const decision = decidePullRequestAuthority(authority, {
+        target: { resourceId: resource.resourceId },
+        requireAcceptedReview: requireApproval,
+        requireChecks: invocation.input.requireChecks,
+        allowPendingChecks: autoMerge,
+        mergePolicy: {
+            ...(invocation.input.maxFilesChanged === undefined
+                ? {}
+                : { maxFilesChanged: invocation.input.maxFilesChanged }),
+            blockedPaths: invocation.input.blockedPaths,
+        },
+    });
+    if (!decision.allowed) {
+        const denial = mergeDenied(resourceStream(resource.resourceId), decision.reason, command, {
+            ...selectedDenialAudit(authority, resource.resourceId),
+            method: invocation.input.method,
+        });
+        return claimAndCompleteDecision(journal, appender, invocation.activationId, MergeMethod.Merge, {
+            decisionKind: 'denied',
+            outcome: { kind: ActivityOutcomeKind.Blocked, data: { reason: decision.reason } },
+            fact: denial,
+        });
+    }
+    const intent = deliveryIntentRequested(decision.resourceId, ActivityEventType.PrMergeRequested, {
+        activationId: invocation.activationId,
+        workflowInstanceId: invocation.workflowInstanceId,
+        resourceId: decision.resourceId,
+        revision: decision.revision,
+        method: invocation.input.method,
+        requireChecks: invocation.input.requireChecks,
+        autoMerge,
+    }, command);
+    return claimAndCompleteDecision(journal, appender, invocation.activationId, MergeMethod.Merge, {
+        decisionKind: 'requested',
+        outcome: {
+            kind: ActivityOutcomeKind.Waiting,
+            data: { intentEventId: intent.eventId, signalKind: 'delivery-result' },
+        },
+        fact: intent,
+    });
+}

package/dist/src/activities/pr/policy.js

@@ -0,0 +1,135 @@
+import { BuiltInResourceCapability } from '../../resources/index.js';
+import { ActivityEventType } from '../contracts/events.js';
+import { ActivityResourceRole } from '../contracts/vocabulary.js';
+import { isPullRequestLikeResource } from './capability.js';
+import { PullRequestCheckState, PullRequestDenialCode, PullRequestState } from './vocabulary.js';
+export function decidePullRequestAuthority(input, options = {
+    target: ActivityResourceRole.Primary,
+    requireAcceptedReview: true,
+    requireChecks: true,
+}) {
+    if (input.work === null)
+        return denied(PullRequestDenialCode.MissingResource);
+    const resource = selectResource(input, input.work.workItemId, options.target);
+    if (isDenial(resource))
+        return resource;
+    const pullRequest = selectPullRequest(input, resource, input.work.workItemId);
+    if (isDenial(pullRequest))
+        return pullRequest;
+    if (pullRequest.state !== PullRequestState.Open)
+        return denied(PullRequestDenialCode.Closed);
+    const authority = finalizeAuthority(input, resource, pullRequest, options);
+    if (authority !== null)
+        return authority;
+    return { allowed: true, resourceId: pullRequest.resourceId, revision: pullRequest.headRevision };
+}
+function finalizeAuthority(input, resource, pullRequest, options) {
+    if (options.requireAcceptedReview) {
+        const review = reviewAuthority(pullRequest, input.acceptedSignals);
+        if (review !== null)
+            return review;
+    }
+    if (options.requireChecks) {
+        const checks = checkAuthority(pullRequest, options.allowPendingChecks ?? false);
+        if (checks !== null)
+            return checks;
+    }
+    if (options.mergePolicy !== undefined) {
+        const files = changedFilesAuthority(pullRequest, resource, options.mergePolicy);
+        if (files !== null)
+            return files;
+    }
+    return null;
+}
+export function createPullRequestMergeDenial(decision) {
+    if (decision.allowed)
+        return null;
+    return {
+        eventType: ActivityEventType.PrMergeDenied,
+        payload: { reason: decision.reason },
+    };
+}
+function hasPrimaryCorrelationConflict(resource, workItemId) {
+    const primary = resource.correlations.filter((correlation) => correlation.role === ActivityResourceRole.Primary);
+    return (resource.resource.primaryCorrelationConflict !== undefined ||
+        primary.length !== 1 ||
+        primary[0].workItemId !== workItemId);
+}
+function selectResource(input, workItemId, target) {
+    const resources = input.resources.filter((entry) => isPrimaryPullRequest(entry, workItemId) &&
+        (target === ActivityResourceRole.Primary || entry.resource.resourceId === target.resourceId));
+    if (resources.length === 0)
+        return denied(PullRequestDenialCode.MissingResource);
+    if (resources.length !== 1)
+        return denied(PullRequestDenialCode.AmbiguousResource);
+    const resource = resources[0];
+    return hasPrimaryCorrelationConflict(resource, workItemId)
+        ? denied(PullRequestDenialCode.CorrelationConflict)
+        : resource;
+}
+function isPrimaryPullRequest(resource, workItemId) {
+    if (!isPullRequestLikeResource(resource.resource.capabilities))
+        return false;
+    return resource.correlations.some((correlation) => correlation.role === ActivityResourceRole.Primary && correlation.workItemId === workItemId);
+}
+function selectPullRequest(input, resource, workItemId) {
+    const pullRequests = input.pullRequests.filter((view) => view.resourceId === resource.resource.resourceId && view.workItemId === workItemId);
+    if (pullRequests.length === 0)
+        return denied(PullRequestDenialCode.MissingResource);
+    return pullRequests.length === 1
+        ? pullRequests[0]
+        : denied(PullRequestDenialCode.AmbiguousResource);
+}
+function reviewAuthority(pullRequest, signals) {
+    const accepted = pullRequest.acceptedReview;
+    if (accepted === undefined || accepted.revision !== pullRequest.headRevision) {
+        if (hasCurrentUntrustedSignal(pullRequest, signals))
+            return denied(PullRequestDenialCode.UntrustedActor);
+        return denied(PullRequestDenialCode.StaleApproval);
+    }
+    const signal = signals.find((candidate) => matchesAcceptedReview(candidate, pullRequest));
+    return signal?.trusted === true ? null : denied(PullRequestDenialCode.UntrustedActor);
+}
+function hasCurrentUntrustedSignal(pullRequest, signals) {
+    return signals.some((signal) => signal.resourceId === pullRequest.resourceId &&
+        signal.revision === pullRequest.headRevision &&
+        !signal.trusted);
+}
+function matchesAcceptedReview(candidate, pullRequest) {
+    const accepted = pullRequest.acceptedReview;
+    return (accepted !== undefined &&
+        candidate.resourceId === pullRequest.resourceId &&
+        candidate.acceptedEventId === accepted.acceptedEventId &&
+        candidate.revision === accepted.revision &&
+        candidate.actorId === accepted.actorId);
+}
+function changedFilesAuthority(pullRequest, resource, policy) {
+    const configured = policy.maxFilesChanged !== undefined || policy.blockedPaths.length > 0;
+    if (!configured)
+        return null;
+    const changedFiles = resource.resource.capabilities.includes(BuiltInResourceCapability.ChangedFiles)
+        ? pullRequest.changedFiles
+        : undefined;
+    if (changedFiles === undefined)
+        return denied(PullRequestDenialCode.ChangedFilesUnavailable);
+    if (policy.maxFilesChanged !== undefined && changedFiles.length > policy.maxFilesChanged)
+        return denied(PullRequestDenialCode.TooManyFilesChanged);
+    return policy.blockedPaths.some((blocked) => changedFiles.includes(blocked))
+        ? denied(PullRequestDenialCode.BlockedPathChanged)
+        : null;
+}
+function checkAuthority(pullRequest, allowPendingChecks) {
+    if (pullRequest.checks === PullRequestCheckState.Unknown)
+        return denied(PullRequestDenialCode.ChecksPending);
+    if (pullRequest.checks === PullRequestCheckState.Pending && !allowPendingChecks)
+        return denied(PullRequestDenialCode.ChecksPending);
+    return pullRequest.checks === PullRequestCheckState.Failing
+        ? denied(PullRequestDenialCode.ChecksFailing)
+        : null;
+}
+function isDenial(value) {
+    return 'allowed' in value;
+}
+function denied(reason) {
+    return { allowed: false, reason };
+}

package/dist/src/activities/pr/projection.js

@@ -0,0 +1,130 @@
+import { isResourceStream } from '../../resources/index.js';
+import { ActivityEventType, selectActivityEvent } from '../contracts/events.js';
+export const pullRequestProjection = {
+    name: 'activities-pr',
+    select(event) {
+        const owned = selectActivityEvent(event);
+        return owned !== null && isResourceStream(owned.stream) ? { key: owned.stream.id } : null;
+    },
+    initial: () => null,
+    project(previous, event) {
+        const owned = selectActivityEvent(event);
+        if (owned === null || !isResourceStream(owned.stream))
+            return previous;
+        return projectPullRequest(previous, owned);
+    },
+};
+export const acceptedReviewSignalProjection = {
+    name: 'activities-pr-accepted-signals',
+    select(event) {
+        const owned = selectActivityEvent(event);
+        return owned !== null && isResourceStream(owned.stream) ? { key: owned.stream.id } : null;
+    },
+    initial: () => [],
+    project(previous, event) {
+        const owned = selectActivityEvent(event);
+        if (owned === null || !isResourceStream(owned.stream))
+            return previous;
+        return projectAcceptedReviewSignal(previous, owned);
+    },
+};
+export const activityProjectionDefinitions = [
+    pullRequestProjection,
+    acceptedReviewSignalProjection,
+];
+function clearReview(view) {
+    const copy = { ...view };
+    delete copy.acceptedReview;
+    return copy;
+}
+// A new revision invalidates prior review and prior changed-file evidence;
+// the projected event payload re-supplies changedFiles only if the provider
+// reported it for this new revision.
+function clearRevisionEvidence(view) {
+    const copy = { ...view };
+    delete copy.acceptedReview;
+    delete copy.changedFiles;
+    return copy;
+}
+function projectPullRequest(previous, event) {
+    switch (event.eventType) {
+        case ActivityEventType.PrDiscovered:
+            return { resourceId: event.stream.id, ...event.payload };
+        case ActivityEventType.PrRevisionChanged:
+            return previous === null
+                ? previous
+                : { ...clearRevisionEvidence(previous), ...event.payload };
+        case ActivityEventType.PrStateChanged:
+            return previous === null ? previous : { ...previous, state: event.payload.state };
+        case ActivityEventType.PrChecksChanged:
+            return previous === null ? previous : { ...previous, checks: event.payload.checks };
+        case ActivityEventType.PrReviewAccepted:
+            return previous === null
+                ? previous
+                : {
+                    ...previous,
+                    acceptedReview: {
+                        revision: event.payload.revision,
+                        actorId: event.payload.actorId,
+                        acceptedEventId: event.eventId,
+                    },
+                };
+        case ActivityEventType.PrReviewChangesRequested:
+            return previous === null ? previous : clearReview(previous);
+        default:
+            return ignorePullRequestEvent(previous, event);
+    }
+}
+function ignorePullRequestEvent(previous, event) {
+    switch (event.eventType) {
+        case ActivityEventType.ReviewAcceptanceSignalRecorded:
+        case ActivityEventType.PrReviewRejected:
+        case ActivityEventType.PrMergeDenied:
+        case ActivityEventType.PrApproveDenied:
+        case ActivityEventType.PrMergeAuthorized:
+        case ActivityEventType.PrApproveRequested:
+        case ActivityEventType.PrMergeRequested:
+        case ActivityEventType.PrApproveDecisionClaimed:
+        case ActivityEventType.PrMergeDecisionClaimed:
+            return previous;
+        default:
+            return assertNever(event);
+    }
+}
+function projectAcceptedReviewSignal(previous, event) {
+    switch (event.eventType) {
+        case ActivityEventType.ReviewAcceptanceSignalRecorded: {
+            const signal = { resourceId: event.stream.id, ...event.payload };
+            return previous.some((candidate) => candidate.acceptedEventId === signal.acceptedEventId)
+                ? previous
+                : [...previous, signal];
+        }
+        case ActivityEventType.PrMergeDenied:
+        case ActivityEventType.PrApproveDenied:
+        case ActivityEventType.PrApproveDecisionClaimed:
+        case ActivityEventType.PrMergeDecisionClaimed:
+            return previous;
+        default:
+            return ignoreAcceptedSignalFact(previous, event);
+    }
+}
+function ignoreAcceptedSignalFact(previous, event) {
+    switch (event.eventType) {
+        case ActivityEventType.PrDiscovered:
+        case ActivityEventType.PrRevisionChanged:
+        case ActivityEventType.PrStateChanged:
+        case ActivityEventType.PrChecksChanged:
+        case ActivityEventType.PrReviewAccepted:
+        case ActivityEventType.PrReviewChangesRequested:
+        case ActivityEventType.PrReviewRejected:
+        case ActivityEventType.PrMergeAuthorized:
+        case ActivityEventType.PrApproveRequested:
+        case ActivityEventType.PrMergeRequested:
+            return previous;
+        default:
+            return assertNever(event);
+    }
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Activity event: ${JSON.stringify(value)}`);
+}

package/dist/src/activities/pr/vocabulary.js

@@ -0,0 +1,30 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const PullRequestState = defineClosedVocabulary({
+    Open: 'open',
+    Closed: 'closed',
+    Merged: 'merged',
+});
+export const PullRequestCheckState = defineClosedVocabulary({
+    Unknown: 'unknown',
+    Pending: 'pending',
+    Passing: 'passing',
+    Failing: 'failing',
+});
+export const MergeMethod = defineClosedVocabulary({
+    Merge: 'merge',
+    Squash: 'squash',
+    Rebase: 'rebase',
+});
+export const PullRequestDenialCode = defineClosedVocabulary({
+    MissingResource: 'missing-resource',
+    AmbiguousResource: 'ambiguous-resource',
+    CorrelationConflict: 'correlation-conflict',
+    Closed: 'closed',
+    StaleApproval: 'stale-approval',
+    ChecksPending: 'checks-pending',
+    ChecksFailing: 'checks-failing',
+    UntrustedActor: 'untrusted-actor',
+    TooManyFilesChanged: 'too-many-files-changed',
+    BlockedPathChanged: 'blocked-path-changed',
+    ChangedFilesUnavailable: 'changed-files-unavailable',
+});

package/dist/src/activities/review/authorization.js

@@ -0,0 +1,22 @@
+import { ProviderPermission, ReviewActorKind, ReviewerAuthorizationSource } from './contracts.js';
+export function isReviewAuthorized(input) {
+    if (input.origin === 'provider-native-review')
+        return true;
+    if (input.actorKind !== ReviewActorKind.Human)
+        return false;
+    if (sameIdentity(input.actorId, input.resourceAuthorId))
+        return false;
+    if (input.authorization.source === ReviewerAuthorizationSource.ConfiguredReviewer)
+        return sameIdentity(input.actorId, input.authorization.reviewerId);
+    if (input.authorization.source !== ReviewerAuthorizationSource.ProviderPermission)
+        return false;
+    return trustedPermissions.has(input.authorization.permission);
+}
+function sameIdentity(left, right) {
+    return left.toLowerCase() === right.toLowerCase();
+}
+const trustedPermissions = new Set([
+    ProviderPermission.Write,
+    ProviderPermission.Maintain,
+    ProviderPermission.Admin,
+]);

package/dist/src/activities/review/contracts.js

@@ -0,0 +1,22 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const ReviewerAuthorizationSource = defineClosedVocabulary({
+    ConfiguredReviewer: 'configured-reviewer',
+    ProviderPermission: 'provider-permission',
+    None: 'none',
+});
+export const ProviderPermission = defineClosedVocabulary({
+    None: 'none',
+    Read: 'read',
+    Triage: 'triage',
+    Write: 'write',
+    Maintain: 'maintain',
+    Admin: 'admin',
+});
+export const ReviewActorKind = defineClosedVocabulary({
+    Human: 'human',
+    Bot: 'bot',
+});
+export const ReviewDecisionKind = defineClosedVocabulary({
+    Accepted: 'accepted',
+    ChangesRequested: 'changes-requested',
+});

package/dist/src/activities/review/signals.js

@@ -0,0 +1,3 @@
+export function proposeReviewSignal(input) {
+    return input;
+}