patchrelay 0.38.0 → 0.38.2

package/dist/remote-pr-state.js

@@ -0,0 +1,11 @@
+import { execCommand } from "./utils.js";
+export async function readRemotePrState(repoFullName, prNumber) {
+    const { stdout, exitCode } = await execCommand("gh", [
+        "pr", "view", String(prNumber),
+        "--repo", repoFullName,
+        "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+    ], { timeoutMs: 10_000 });
+    if (exitCode !== 0)
+        return undefined;
+    return JSON.parse(stdout);
+}

package/dist/run-budgets.js

@@ -0,0 +1,12 @@
+export const DEFAULT_CI_REPAIR_BUDGET = 3;
+export const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
+export const DEFAULT_REVIEW_FIX_BUDGET = 3;
+export function getCiRepairBudget(project) {
+    return project?.repairBudgets?.ciRepair ?? DEFAULT_CI_REPAIR_BUDGET;
+}
+export function getQueueRepairBudget(project) {
+    return project?.repairBudgets?.queueRepair ?? DEFAULT_QUEUE_REPAIR_BUDGET;
+}
+export function getReviewFixBudget(project) {
+    return project?.repairBudgets?.reviewFix ?? DEFAULT_REVIEW_FIX_BUDGET;
+}

package/dist/run-notification-handler.js

@@ -41,6 +41,10 @@ export class RunNotificationHandler {
         const run = this.db.runs.getRunByThreadId(threadId);
         if (!run)
             return;
+        if (run.status !== "running") {
+            this.logger.info({ runId: run.id, status: run.status, issueId: run.linearIssueId }, "Ignoring Codex notification for inactive run");
+            return;
+        }
         if (!this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
             this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Ignoring Codex notification after losing issue-session lease");
             return;

package/dist/run-orchestrator.js

@@ -54,6 +54,20 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    threadPorts = {
+        readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
+    };
+    leasePorts = {
+        withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
+        releaseLease: (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId),
+        heartbeatLease: (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId),
+        getHeldLease: (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId),
+    };
+    recoveryPorts = {
+        failRunAndClear: (run, message, nextState) => this.failRunAndClear(run, message, nextState),
+        restoreIdleWorktree: (issue) => this.restoreIdleWorktree(issue),
+        recoverOrEscalate: (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason),
+    };
     activeSessionLeases;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -66,16 +80,16 @@ export class RunOrchestrator {
         this.feed = feed;
         this.worktreeManager = new WorktreeManager(config);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
-        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries));
+        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry);
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
-        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn));
+        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, this.completionCheck, feed);
+        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
-        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), feed);
-        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
-        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (run, message, nextState) => this.failRunAndClear(run, message, nextState), (issue) => this.restoreIdleWorktree(issue), this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
-        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason), feed);
+        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
+        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
@@ -124,6 +138,12 @@ export class RunOrchestrator {
             return;
         }
         const { runType, context, resumeThread } = wake;
+        if (runType === "implementation" && this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId) > 0) {
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(item.projectId, item.issueId);
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            this.logger.info({ issueKey: issue.issueKey }, "Skipped implementation launch because the issue is blocked");
+            return;
+        }
         const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);
         if (remainingZombieDelayMs > 0) {
             this.logger.debug({ issueKey: issue.issueKey, runType, remainingZombieDelayMs }, "Deferring recovered run launch until zombie backoff elapses");
@@ -138,7 +158,7 @@ export class RunOrchestrator {
             : typeof effectiveContext?.headSha === "string"
                 ? effectiveContext.headSha
                 : issue.prHeadSha;
-        const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, runType, isRequestedChangesRunType);
+        const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, project, runType, isRequestedChangesRunType);
         if (budgetExceeded) {
             this.escalate(issue, runType, budgetExceeded);
             return;

package/dist/run-wake-planner.js

@@ -1,6 +1,4 @@
-const DEFAULT_CI_REPAIR_BUDGET = 3;
-const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
-const DEFAULT_REVIEW_FIX_BUDGET = 12;
+import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./run-budgets.js";
 export class RunWakePlanner {
     db;
     constructor(db) {
@@ -62,15 +60,18 @@ export class RunWakePlanner {
             return issue;
         return this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
     }
-    budgetExceeded(issue, runType, isRequestedChangesRunType) {
-        if (runType === "ci_repair" && issue.ciRepairAttempts >= DEFAULT_CI_REPAIR_BUDGET) {
-            return `CI repair budget exhausted (${DEFAULT_CI_REPAIR_BUDGET} attempts)`;
+    budgetExceeded(issue, project, runType, isRequestedChangesRunType) {
+        const ciRepairBudget = getCiRepairBudget(project);
+        if (runType === "ci_repair" && issue.ciRepairAttempts >= ciRepairBudget) {
+            return `CI repair budget exhausted (${ciRepairBudget} attempts)`;
         }
-        if (runType === "queue_repair" && issue.queueRepairAttempts >= DEFAULT_QUEUE_REPAIR_BUDGET) {
-            return `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`;
+        const queueRepairBudget = getQueueRepairBudget(project);
+        if (runType === "queue_repair" && issue.queueRepairAttempts >= queueRepairBudget) {
+            return `Queue repair budget exhausted (${queueRepairBudget} attempts)`;
         }
-        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
-            return `Requested-changes budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`;
+        const reviewFixBudget = getReviewFixBudget(project);
+        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= reviewFixBudget) {
+            return `Requested-changes budget exhausted (${reviewFixBudget} attempts)`;
         }
         return undefined;
     }

package/dist/service-issue-actions.js

@@ -1,5 +1,5 @@
 import { buildOperatorRetryEvent } from "./operator-retry-event.js";
-import { hasOpenPr } from "./pr-state.js";
+import { buildManualRetryAttemptReset, resolveRetryTarget } from "./manual-issue-actions.js";
 export class ServiceIssueActions {
     db;
     codex;
@@ -103,7 +103,16 @@ export class ServiceIssueActions {
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
         const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
-        if (issue.prState === "merged") {
+        const retryTarget = resolveRetryTarget({
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            pendingRunType: issue.pendingRunType,
+            lastRunType: issueSession?.lastRunType,
+            lastGitHubFailureSource: issue.lastGitHubFailureSource,
+        });
+        if (retryTarget.runType === "none") {
             this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -111,45 +120,89 @@ export class ServiceIssueActions {
             });
             return { issueKey, runType: "none" };
         }
-        let runType = "implementation";
-        let factoryState = "delegated";
-        if (hasOpenPr(issue.prNumber, issue.prState) && issue.lastGitHubFailureSource === "queue_eviction") {
-            runType = "queue_repair";
-            factoryState = "repairing_queue";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState) && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
-            runType = "ci_repair";
-            factoryState = "repairing_ci";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState) && issue.prReviewState === "changes_requested") {
-            runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
-                ? "branch_upkeep"
-                : "review_fix";
-            factoryState = "changes_requested";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState)) {
-            runType = "implementation";
-            factoryState = "implementing";
-        }
-        this.appendOperatorRetryEvent(issue, runType);
+        this.appendOperatorRetryEvent(issue, retryTarget.runType);
         this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            factoryState: factoryState,
+            factoryState: retryTarget.factoryState,
+            ...buildManualRetryAttemptReset(retryTarget.runType),
         });
         this.feed.publish({
             level: "info",
             kind: "stage",
             issueKey: issue.issueKey,
             projectId: issue.projectId,
-            stage: factoryState,
+            stage: retryTarget.factoryState,
             status: "retry",
-            summary: `Retry queued: ${runType}`,
+            summary: `Retry queued: ${retryTarget.runType}`,
         });
         if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
-        return { issueKey, runType };
+        return { issueKey, runType: retryTarget.runType };
+    }
+    async closeIssue(issueKey, options) {
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const terminalState = options?.failed ? "failed" : "done";
+        const run = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
+        if (run?.threadId && run.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    input: `STOP: The operator manually closed this issue in PatchRelay as ${terminalState}. Stop working immediately and exit without making further changes.`,
+                });
+            }
+            catch {
+                // The turn may already be settled.
+            }
+        }
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "operator_closed",
+            eventJson: JSON.stringify({
+                terminalState,
+                ...(options?.reason ? { reason: options.reason } : {}),
+            }),
+            dedupeKey: `operator_closed:${issue.linearIssueId}:${terminalState}:${issue.activeRunId ?? "no-run"}`,
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        if (run) {
+            this.db.issueSessions.finishRunRespectingActiveLease(issue.projectId, issue.linearIssueId, run.id, {
+                status: "released",
+                failureReason: options?.reason
+                    ? `Operator closed issue as ${terminalState}: ${options.reason}`
+                    : `Operator closed issue as ${terminalState}`,
+            });
+        }
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: terminalState,
+            activeRunId: null,
+            pendingRunType: null,
+            pendingRunContextJson: null,
+        });
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.feed.publish({
+            level: terminalState === "failed" ? "warn" : "info",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: terminalState,
+            status: "operator_closed",
+            summary: options?.reason
+                ? `Operator closed issue as ${terminalState}: ${options.reason}`
+                : `Operator closed issue as ${terminalState}`,
+        });
+        return {
+            issueKey,
+            factoryState: terminalState,
+            ...(run ? { releasedRunId: run.id } : {}),
+        };
     }
     queueOperatorPrompt(issue, text, source) {
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {

package/dist/service.js

@@ -215,6 +215,9 @@ export class PatchRelayService {
     retryIssue(issueKey) {
         return this.issueActions.retryIssue(issueKey);
     }
+    async closeIssue(issueKey, options) {
+        return await this.issueActions.closeIssue(issueKey, options);
+    }
     async acceptWebhook(params) {
         const result = await acceptIncomingWebhook({
             config: this.config,

package/dist/webhooks/desired-stage-recorder.js

@@ -19,16 +19,22 @@ export class DesiredStageRecorder {
         const existingIssue = this.db.issues.getIssue(params.project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
         const latestRun = existingIssue ? this.db.runs.getLatestRunForIssue(params.project.id, normalizedIssue.id) : undefined;
-        const delegated = this.isDelegatedToPatchRelay(params.project, params.normalized);
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
         const incomingAgentSessionId = params.normalized.agentSession?.id;
         const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(params.project.id, normalizedIssue.id) !== undefined;
-        if (!existingIssue && !delegated && !incomingAgentSessionId) {
-            return { issue: undefined, wakeRunType: undefined, delegated };
+        if (!existingIssue && !this.isDelegatedToPatchRelay(params.project, normalizedIssue) && !incomingAgentSessionId) {
+            return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
         const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const delegated = this.isDelegatedToPatchRelay(params.project, hydratedIssue);
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
+        const openPrExists = existingIssue?.prNumber !== undefined
+            && existingIssue.prState !== "closed"
+            && existingIssue.prState !== "merged";
+        const blockerPausedImplementation = unresolvedBlockers > 0
+            && activeRun?.runType === "implementation"
+            && !openPrExists;
         const desiredStage = decideRunIntent({
             delegated,
             triggerAllowed,
@@ -45,6 +51,9 @@ export class DesiredStageRecorder {
             triggerEvent: params.normalized.triggerEvent,
             delegated,
         });
+        const effectiveRunRelease = blockerPausedImplementation
+            ? { release: true, reason: "Issue became blocked during implementation" }
+            : runRelease;
         const undelegation = decideUnDelegation({
             triggerEvent: params.normalized.triggerEvent,
             delegated,
@@ -96,11 +105,12 @@ export class DesiredStageRecorder {
                 ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
-                ...(runRelease.release ? { activeRunId: null } : {}),
+                ...(effectiveRunRelease.release ? { activeRunId: null } : {}),
+                ...(blockerPausedImplementation ? { factoryState: "delegated" } : {}),
                 ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
             });
-            if (runRelease.release && activeRun && runRelease.reason) {
-                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: runRelease.reason });
+            if (effectiveRunRelease.release && activeRun && effectiveRunRelease.reason) {
+                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: effectiveRunRelease.reason });
             }
             return record;
         };
@@ -136,6 +146,22 @@ export class DesiredStageRecorder {
                     : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
             });
         }
+        else if (blockerPausedImplementation) {
+            if (activeRun?.threadId && activeRun.turnId) {
+                await params.stopActiveRun(activeRun, "STOP: The issue is now blocked by another task. Stop working immediately and exit without publishing.");
+            }
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.feed?.publish({
+                level: "warn",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: params.project.id,
+                stage: issue.factoryState,
+                status: "blocked",
+                summary: `Implementation paused because ${issue.issueKey ?? normalizedIssue.id} is now blocked`,
+            });
+        }
         else if (reDelegationResume.pendingRunType) {
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
                 projectId: params.project.id,
@@ -168,13 +194,11 @@ export class DesiredStageRecorder {
             delegated,
         };
     }
-    isDelegatedToPatchRelay(project, normalized) {
-        if (!normalized.issue)
-            return false;
+    isDelegatedToPatchRelay(project, issue) {
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
         if (!installation?.actorId)
             return false;
-        return normalized.issue.delegateId === installation.actorId;
+        return issue.delegateId === installation.actorId;
     }
     async syncIssueDependencies(projectId, issue) {
         let source = issue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.38.0",
+  "version": "0.38.2",
   "license": "MIT",
   "type": "module",
   "repository": {