devchain-cli 0.20.3 → 0.22.0

package/dist/server/modules/external-integrations/adapters/jira-external-task.provider.js

@@ -0,0 +1,1790 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JiraExternalTaskProvider = void 0;
+const common_1 = require("@nestjs/common");
+const external_provider_errors_1 = require("../errors/external-provider.errors");
+const external_provider_models_1 = require("../models/external-provider.models");
+const jira_adf_converter_1 = require("./rich/jira-adf-converter");
+const jira_adf_converter_2 = require("./rich/jira-adf-converter");
+const safe_vendor_http_client_1 = require("../transport/safe-vendor-http-client");
+const vendor_shared_1 = require("./vendor-shared");
+const JIRA_TENANT_HOSTNAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.atlassian\.net$/;
+const JIRA_SITE_URL = /^https:\/\/[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.atlassian\.net\/?$/i;
+const JIRA_SEARCH_PAGE_SIZE = 100;
+const JIRA_MAX_SEARCH_PAGES = 1_000;
+const JIRA_COMMENT_PAGE_SIZE = 10;
+const JIRA_COMMENT_MAX_START_AT = 1_000_000;
+const JIRA_COMMENT_CURSOR_PATTERN = /^\d+$/;
+const JIRA_COMMENT_AUTHOR = {
+    nameKey: 'displayName',
+    idKey: 'accountId',
+    idFormat: 'string',
+};
+const JIRA_WORKLOG_PAGE_SIZE = 100;
+const JIRA_WORKLOG_MAX_PAGES = 5;
+const JIRA_WORKLOG_MAX_RAW = 500;
+const JIRA_MANAGED_SUBTASK_PROPERTY = 'devchain.managed-subtask';
+const OTHER_ASSIGNED_WORK_AREA_ID = 'other-assigned';
+const JIRA_NEUTRAL_COLOR = '#6b778c';
+const JIRA_COMPLETED_COLOR = '#36b37e';
+const JIRA_DETAIL_FIELDS = [
+    'summary',
+    'description',
+    'status',
+    'duedate',
+    'priority',
+    'project',
+    'subtasks',
+    'timetracking',
+];
+const JIRA_SEARCH_FIELDS = [
+    'summary',
+    'status',
+    'assignee',
+    'updated',
+    'duedate',
+    'resolutiondate',
+    'project',
+    'parent',
+    'issuetype',
+];
+let JiraExternalTaskProvider = class JiraExternalTaskProvider {
+    http;
+    provider = 'jira';
+    descriptor = {
+        provider: this.provider,
+        displayName: 'Jira',
+        capabilities: { myWork: true },
+    };
+    myWork = {
+        discover: (credentials, options) => this.discoverMyWork(credentials, options),
+        getTaskDetail: (credentials, context, remoteTaskId) => this.getTaskDetail(credentials, context, remoteTaskId),
+        listComments: (credentials, context, remoteTaskId, cursor) => this.listTaskComments(credentials, context, remoteTaskId, cursor),
+        changeStatus: (credentials, context, remoteTaskId, input) => this.changeTaskStatus(credentials, context, remoteTaskId, input),
+        addComment: (credentials, context, remoteTaskId, input) => this.addTaskComment(credentials, context, remoteTaskId, input),
+        getTimeEntryHistory: (credentials, context, remoteTaskId) => this.getTaskTimeEntryHistory(credentials, context, remoteTaskId),
+    };
+    timeEntryMutations = {
+        createTimeEntry: (credentials, context, remoteTaskId, input) => this.createTimeEntry(credentials, context, remoteTaskId, input),
+        deleteTimeEntry: (credentials, context, remoteTaskId, remoteEntryId) => this.deleteTimeEntry(credentials, context, remoteTaskId, remoteEntryId),
+        readTimeEntryExact: (credentials, context, remoteTaskId, remoteEntryId) => this.readTimeEntryExact(credentials, context, remoteTaskId, remoteEntryId),
+        listOwnTimeEntryIdsInRange: (credentials, context, remoteTaskId, startedAfterMs, startedBeforeMs) => this.listOwnTimeEntryIdsInRange(credentials, context, remoteTaskId, startedAfterMs, startedBeforeMs),
+        assertTimeEntryDeletable: (credentials, context, remoteTaskId, remoteEntryId) => this.assertTimeEntryDeletable(credentials, context, remoteTaskId, remoteEntryId),
+    };
+    boardMetadataCache = new vendor_shared_1.VendorMetadataCache(vendor_shared_1.WORK_AREA_METADATA_CACHE_MAX_ENTRIES);
+    subtaskIssueTypeCache = new vendor_shared_1.VendorMetadataCache(vendor_shared_1.WORK_AREA_METADATA_CACHE_MAX_ENTRIES);
+    validate = (0, vendor_shared_1.createVendorValidators)((reason) => new external_provider_errors_1.JiraProviderError(reason));
+    constructor(http) {
+        this.http = http;
+    }
+    ownedMutations = {
+        getCurrentOwnerRemoteId: (credentials) => this.loadIdentity(this.resolveSite(credentials)).then((identity) => identity.accountId),
+        findComment: (credentials, context, remoteTaskId, commentId) => this.findComment(credentials, context, remoteTaskId, commentId),
+        deleteComment: (credentials, context, remoteTaskId, commentId) => this.deleteComment(credentials, context, remoteTaskId, commentId),
+        updateOwnedComment: (credentials, context, remoteTaskId, commentId, document) => this.updateOwnedComment(credentials, context, remoteTaskId, commentId, document),
+    };
+    descriptionEdit = {
+        readDescription: (credentials, context, remoteTaskId) => this.readDescription(credentials, context, remoteTaskId),
+        writeDescription: (credentials, context, remoteTaskId, raw) => this.writeDescription(credentials, context, remoteTaskId, raw),
+    };
+    subtaskSync = {
+        create: (credentials, context, input) => this.createSubtask(credentials, context, input),
+        readExact: (credentials, context, remoteTaskId) => this.readSubtaskExact(credentials, context, remoteTaskId),
+        update: (credentials, context, input) => this.updateSubtask(credentials, context, input),
+        delete: (credentials, context, proof) => this.deleteSubtask(credentials, context, proof),
+        listOwnedDirectChildren: (credentials, context, parentRemoteTaskId, ownershipToken) => this.listOwnedDirectChildren(credentials, context, parentRemoteTaskId, ownershipToken),
+        assertOwned: (credentials, context, proof) => this.assertOwnedSubtask(credentials, context, proof),
+    };
+    async createSubtask(credentials, context, input) {
+        const site = this.resolveSite(credentials);
+        const parentTaskId = this.validate.requiredTaskId(input.parentRemoteTaskId);
+        const ownershipToken = this.requireSubtaskOwnershipToken(input.ownershipToken);
+        const title = this.requireSubtaskTitle(input.title);
+        const description = this.requireSubtaskDescription(input.description);
+        const parent = await this.loadSubtaskParent(site, parentTaskId);
+        const issueTypeId = await this.loadSubtaskIssueType(site, context, parent.workAreaRemoteId);
+        const identity = await this.loadIdentity(site);
+        const propertyValue = { version: 1, ownershipToken };
+        const payload = await this.requestJson(site, '/rest/api/3/issue', {
+            method: 'POST',
+            body: JSON.stringify({
+                fields: {
+                    project: { id: parent.workAreaRemoteId },
+                    issuetype: { id: issueTypeId },
+                    parent: { key: parent.remoteKey },
+                    summary: title,
+                    description: this.managedDescriptionAdf(description),
+                    assignee: { id: identity.accountId },
+                },
+                properties: [{ key: JIRA_MANAGED_SUBTASK_PROPERTY, value: propertyValue }],
+            }),
+        });
+        try {
+            if (!(0, vendor_shared_1.isRecord)(payload)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            this.validate.requiredIdentifier(payload.id);
+            const remoteKey = this.validate.requiredString(payload.key);
+            return {
+                remoteTaskId: remoteKey,
+                remoteKey,
+                parentRemoteTaskId: parent.remoteKey,
+                workAreaRemoteId: parent.workAreaRemoteId,
+                ownershipToken,
+                title,
+                description,
+            };
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.JiraProviderError) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response', undefined, { dispatched: true });
+            }
+            throw error;
+        }
+    }
+    async loadSubtaskParent(site, parentTaskId) {
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(parentTaskId)}`);
+        url.searchParams.set('fields', 'project');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) || !(0, vendor_shared_1.isRecord)(payload.fields) || !(0, vendor_shared_1.isRecord)(payload.fields.project)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const remoteTaskId = this.validate.requiredIdentifier(payload.id);
+        const remoteKey = this.validate.requiredString(payload.key);
+        if (remoteTaskId !== parentTaskId && remoteKey !== parentTaskId) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return {
+            remoteTaskId,
+            remoteKey,
+            workAreaRemoteId: this.validate.requiredIdentifier(payload.fields.project.id),
+        };
+    }
+    async loadSubtaskIssueType(site, context, projectId) {
+        const cacheKey = JSON.stringify([
+            context.connectionId,
+            context.connectionGeneration,
+            site.hostname,
+            projectId,
+        ]);
+        const cached = this.subtaskIssueTypeCache.get(cacheKey);
+        if (cached && Date.now() - cached.fetchedAt <= vendor_shared_1.WORK_AREA_METADATA_TTL_MS) {
+            return cached.value;
+        }
+        const url = new URL(`${site.origin}/rest/api/3/issuetype/project`);
+        url.searchParams.set('projectId', projectId);
+        url.searchParams.set('level', '-1');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!Array.isArray(payload)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        let issueTypeId = null;
+        for (const value of payload) {
+            if (!(0, vendor_shared_1.isRecord)(value)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            if (value.subtask === true && value.hierarchyLevel === -1 && issueTypeId === null) {
+                issueTypeId = this.validate.requiredIdentifier(value.id);
+            }
+        }
+        if (issueTypeId === null) {
+            throw new external_provider_errors_1.JiraProviderError('unsupported_subtask_type');
+        }
+        this.subtaskIssueTypeCache.set(cacheKey, { value: issueTypeId, fetchedAt: Date.now() });
+        return issueTypeId;
+    }
+    async readSubtaskExact(credentials, _context, remoteTaskId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}`);
+        url.searchParams.set('fields', 'summary,description,parent,project');
+        url.searchParams.set('properties', JIRA_MANAGED_SUBTASK_PROPERTY);
+        try {
+            const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+            const snapshot = this.normalizeManagedSubtask(payload);
+            if (snapshot.remoteKey !== taskId) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            return snapshot;
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.JiraProviderError && error.details?.reason === 'not_found') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateSubtask(credentials, context, input) {
+        const current = await this.assertOwnedSubtask(credentials, context, input);
+        const fields = {};
+        if (input.title !== undefined) {
+            fields.summary = this.requireSubtaskTitle(input.title);
+        }
+        if (input.description !== undefined) {
+            fields.description = this.managedDescriptionAdf(this.requireSubtaskDescription(input.description));
+        }
+        if (Object.keys(fields).length === 0) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        await this.requestNoContent(this.resolveSite(credentials), `/rest/api/3/issue/${encodeURIComponent(current.remoteKey)}`, { method: 'PUT', body: JSON.stringify({ fields }) });
+    }
+    async deleteSubtask(credentials, context, proof) {
+        const current = await this.readSubtaskExact(credentials, context, proof.remoteTaskId);
+        if (current === null) {
+            return { outcome: 'already_absent' };
+        }
+        this.assertSubtaskProof(current, proof);
+        try {
+            await this.requestNoContent(this.resolveSite(credentials), `/rest/api/3/issue/${encodeURIComponent(current.remoteKey)}`, { method: 'DELETE' });
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.JiraProviderError && error.details?.reason === 'not_found') {
+                return { outcome: 'already_absent' };
+            }
+            throw error;
+        }
+        return { outcome: 'deleted' };
+    }
+    async listOwnedDirectChildren(credentials, context, parentRemoteTaskId, ownershipToken) {
+        const site = this.resolveSite(credentials);
+        const parentTaskId = this.validate.requiredTaskId(parentRemoteTaskId);
+        const normalizedToken = this.requireSubtaskOwnershipToken(ownershipToken);
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(parentTaskId)}`);
+        url.searchParams.set('fields', 'subtasks');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) ||
+            !(0, vendor_shared_1.isRecord)(payload.fields) ||
+            !Array.isArray(payload.fields.subtasks)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const references = payload.fields.subtasks;
+        const capped = references.length > external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS;
+        const selected = references.slice(0, external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS).map((value) => {
+            if (!(0, vendor_shared_1.isRecord)(value)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            return this.validate.requiredTaskId(typeof value.key === 'string' && value.key.trim()
+                ? value.key
+                : this.validate.requiredIdentifier(value.id));
+        });
+        let staleReference = false;
+        const children = await (0, vendor_shared_1.mapWithConcurrency)(selected, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, async (childId) => {
+            const child = await this.readSubtaskExact(credentials, context, childId);
+            if (child === null) {
+                staleReference = true;
+            }
+            return child;
+        });
+        const items = children.filter((child) => child !== null &&
+            (child.parentRemoteTaskId === parentTaskId ||
+                child.parentRemoteTaskId === this.optionalJiraKey(payload)) &&
+            child.ownershipToken === normalizedToken);
+        return { items, complete: !capped && !staleReference };
+    }
+    optionalJiraKey(value) {
+        if (typeof value.key !== 'string') {
+            return null;
+        }
+        const key = value.key.trim();
+        return key.length > 0 && key.length <= external_provider_models_1.MAX_REMOTE_TASK_ID_LENGTH ? key : null;
+    }
+    async assertOwnedSubtask(credentials, context, proof) {
+        const current = await this.readSubtaskExact(credentials, context, proof.remoteTaskId);
+        if (current === null) {
+            throw new external_provider_errors_1.JiraProviderError('not_found');
+        }
+        this.assertSubtaskProof(current, proof);
+        return current;
+    }
+    assertSubtaskProof(current, proof) {
+        const ownershipToken = this.requireSubtaskOwnershipToken(proof.ownershipToken);
+        const expectedParent = this.validate.requiredTaskId(proof.expectedParentRemoteTaskId);
+        if (current.ownershipToken !== ownershipToken) {
+            throw new external_provider_errors_1.JiraProviderError('ownership_mismatch');
+        }
+        if (current.parentRemoteTaskId !== expectedParent) {
+            throw new external_provider_errors_1.JiraProviderError('parent_mismatch');
+        }
+    }
+    normalizeManagedSubtask(value) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.fields) || !(0, vendor_shared_1.isRecord)(value.fields.project)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const parent = value.fields.parent;
+        if (parent !== null && parent !== undefined && !(0, vendor_shared_1.isRecord)(parent)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const parentRemoteTaskId = parent === null || parent === undefined
+            ? null
+            : typeof parent.key === 'string' && parent.key.trim()
+                ? parent.key.trim()
+                : this.validate.requiredIdentifier(parent.id);
+        const properties = value.properties;
+        if (properties !== null && properties !== undefined && !(0, vendor_shared_1.isRecord)(properties)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const propertyValue = (0, vendor_shared_1.isRecord)(properties)
+            ? properties[JIRA_MANAGED_SUBTASK_PROPERTY]
+            : undefined;
+        const ownershipToken = this.parseJiraOwnershipProperty(propertyValue);
+        this.validate.requiredIdentifier(value.id);
+        const remoteKey = this.validate.requiredString(value.key);
+        return {
+            remoteTaskId: remoteKey,
+            remoteKey,
+            parentRemoteTaskId,
+            workAreaRemoteId: this.validate.requiredIdentifier(value.fields.project.id),
+            ownershipToken,
+            title: this.validate.requiredString(value.fields.summary),
+            description: this.parseManagedDescriptionAdf(value.fields.description),
+        };
+    }
+    parseJiraOwnershipProperty(value) {
+        if (!(0, vendor_shared_1.isRecord)(value) || value.version !== 1 || typeof value.ownershipToken !== 'string') {
+            return null;
+        }
+        return this.isSubtaskOwnershipToken(value.ownershipToken) ? value.ownershipToken : null;
+    }
+    managedDescriptionAdf(description) {
+        const paragraphs = description === null ? [] : description.split('\n');
+        return {
+            type: 'doc',
+            version: 1,
+            content: [
+                ...paragraphs.map((line) => ({
+                    type: 'paragraph',
+                    ...(line ? { content: [{ type: 'text', text: line }] } : {}),
+                })),
+                {
+                    type: 'paragraph',
+                    content: [{ type: 'text', text: external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE }],
+                },
+            ],
+        };
+    }
+    parseManagedDescriptionAdf(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        const text = this.flattenAdfText(value);
+        if (text === external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE) {
+            return null;
+        }
+        const suffix = `\n${external_provider_models_1.EXTERNAL_SUBTASK_MANAGEMENT_NOTE}`;
+        return text.endsWith(suffix) ? text.slice(0, -suffix.length) || null : text || null;
+    }
+    requireSubtaskTitle(value) {
+        if (typeof value !== 'string' ||
+            !value.trim() ||
+            value.length > external_provider_models_1.MAX_EXTERNAL_SUBTASK_TITLE_LENGTH) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        return value.trim();
+    }
+    requireSubtaskDescription(value) {
+        if (value === null || value === '') {
+            return null;
+        }
+        if (typeof value !== 'string' || value.length > external_provider_models_1.MAX_EXTERNAL_SUBTASK_DESCRIPTION_LENGTH) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        return value;
+    }
+    isSubtaskOwnershipToken(value) {
+        return (value.length <= external_provider_models_1.MAX_EXTERNAL_SUBTASK_OWNERSHIP_TOKEN_LENGTH &&
+            /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value));
+    }
+    requireSubtaskOwnershipToken(value) {
+        if (typeof value !== 'string' || !this.isSubtaskOwnershipToken(value)) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        return value;
+    }
+    async findComment(credentials, _context, remoteTaskId, commentId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        const payload = await this.requestJson(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/comment/${encodeURIComponent(normalizedCommentId)}`);
+        if (!(0, vendor_shared_1.isRecord)(payload)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const snapshot = this.normalizeComment(payload);
+        return {
+            remoteId: snapshot.remoteId,
+            authorRemoteId: snapshot.author.remoteId,
+            createdAt: snapshot.createdAt,
+            raw: payload.body ?? null,
+            metadata: { assignee: null, resolved: null, groupAssignee: null },
+        };
+    }
+    async deleteComment(credentials, _context, remoteTaskId, commentId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        await this.requestNoContent(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/comment/${encodeURIComponent(normalizedCommentId)}`, { method: 'DELETE' });
+    }
+    async updateOwnedComment(credentials, _context, remoteTaskId, commentId, document) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const normalizedCommentId = this.validate.requiredIdentifier(commentId);
+        await this.requestJson(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/comment/${encodeURIComponent(normalizedCommentId)}`, { method: 'PUT', body: JSON.stringify({ body: (0, jira_adf_converter_2.richDocumentToAdf)(document) }) });
+    }
+    async readDescription(credentials, _context, remoteTaskId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}`);
+        url.searchParams.set('fields', 'description');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) || !(0, vendor_shared_1.isRecord)(payload.fields)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return payload.fields.description ?? null;
+    }
+    async writeDescription(credentials, _context, remoteTaskId, raw) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        if (!(0, vendor_shared_1.isRecord)(raw) || raw.type !== 'doc' || raw.version !== 1 || !Array.isArray(raw.content)) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        await this.requestNoContent(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ fields: { description: raw } }),
+        });
+    }
+    async verifyCredentials(credentials) {
+        const site = this.resolveSite(credentials);
+        const identity = await this.loadIdentity(site);
+        return {
+            provider: this.provider,
+            remoteId: identity.accountId,
+            displayName: identity.displayName,
+        };
+    }
+    async getTaskDetail(credentials, _context, remoteTaskId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const issueUrl = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}`);
+        issueUrl.searchParams.set('fields', JIRA_DETAIL_FIELDS.join(','));
+        const issue = await this.requestJson(site, `${issueUrl.pathname}${issueUrl.search}`);
+        const [[transitionResult, configurationResult], childResult] = await Promise.all([
+            Promise.allSettled([
+                this.loadTransitions(site, taskId),
+                this.requestJson(site, '/rest/api/3/configuration'),
+            ]),
+            this.normalizeTaskSubtasks(issue, site, taskId),
+        ]);
+        const transitions = transitionResult.status === 'fulfilled' ? transitionResult.value : [];
+        const timeTrackingEnabled = configurationResult.status === 'fulfilled' &&
+            (0, vendor_shared_1.isRecord)(configurationResult.value) &&
+            configurationResult.value.timeTrackingEnabled === true;
+        const detail = this.normalizeTaskDetail(issue, site, taskId);
+        const allowedStatuses = transitions
+            .filter((transition) => transition.supported)
+            .map((transition) => transition.option);
+        return {
+            ...detail,
+            subtasks: childResult.items,
+            subtasksTruncated: childResult.truncated,
+            allowedStatuses,
+            actions: [
+                { action: 'change_status', supported: allowedStatuses.length > 0 },
+                { action: 'add_comment', supported: true },
+                { action: 'log_time', supported: timeTrackingEnabled },
+            ],
+        };
+    }
+    async listTaskComments(credentials, _context, remoteTaskId, cursor) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const startAt = cursor === null ? 0 : this.decodeCommentCursor(cursor);
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}/comment`);
+        url.searchParams.set('maxResults', String(JIRA_COMMENT_PAGE_SIZE));
+        url.searchParams.set('orderBy', '-created');
+        url.searchParams.set('startAt', String(startAt));
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) ||
+            !Array.isArray(payload.comments) ||
+            payload.comments.length > JIRA_COMMENT_PAGE_SIZE) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const returnedStart = this.requiredCount(payload.startAt);
+        const total = this.requiredCount(payload.total);
+        const comments = payload.comments.map((value) => this.enrichComment(value));
+        const nextStart = returnedStart + comments.length;
+        return {
+            comments,
+            nextCursor: nextStart > startAt && nextStart < total && nextStart <= JIRA_COMMENT_MAX_START_AT
+                ? String(nextStart)
+                : null,
+        };
+    }
+    enrichComment(value) {
+        const comment = this.normalizeComment(value);
+        const rawBody = (0, vendor_shared_1.isRecord)(value) ? (value.body ?? null) : null;
+        if (rawBody === null) {
+            return { ...comment, owned: false, rich: null, lookupToken: null };
+        }
+        const parsed = (0, jira_adf_converter_1.adfToRichDocument)(rawBody);
+        return {
+            ...comment,
+            owned: false,
+            rich: parsed.supported
+                ? { document: parsed.document, supported: true }
+                : { supported: false, readOnlyReason: parsed.reason },
+            lookupToken: null,
+        };
+    }
+    requiredCount(value) {
+        if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return value;
+    }
+    decodeCommentCursor(cursor) {
+        if (cursor.length > external_provider_models_1.MAX_TASK_COMMENT_CURSOR_LENGTH ||
+            !JIRA_COMMENT_CURSOR_PATTERN.test(cursor)) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        const startAt = Number(cursor);
+        if (!Number.isSafeInteger(startAt) || startAt > JIRA_COMMENT_MAX_START_AT) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        return startAt;
+    }
+    normalizeComment(value) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const remoteId = this.validate.requiredIdentifier(value.id);
+        if (remoteId.length > external_provider_models_1.MAX_TASK_COMMENT_ID_LENGTH) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const body = this.adfCommentBody(value.body);
+        return {
+            remoteId,
+            author: this.validate.commentAuthor(value.author, JIRA_COMMENT_AUTHOR),
+            body: body.value,
+            bodyTruncated: body.truncated,
+            createdAt: this.requiredTimestamp(value.created),
+            updatedAt: this.optionalTimestamp(value.updated),
+        };
+    }
+    async changeTaskStatus(credentials, _context, remoteTaskId, input) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const transitionId = this.validate.statusInput(input);
+        const transition = (await this.loadTransitions(site, taskId)).find((candidate) => candidate.id === transitionId);
+        if (!transition?.supported) {
+            throw new external_provider_errors_1.JiraProviderError('unsupported_transition', undefined, {
+                completeInJiraUrl: this.issueWebUrl(site, taskId),
+            });
+        }
+        await this.requestNoContent(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/transitions`, {
+            method: 'POST',
+            body: JSON.stringify({ transition: { id: transitionId } }),
+        });
+    }
+    async addTaskComment(credentials, _context, remoteTaskId, input) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        this.validate.commentInput(input);
+        await this.requestJson(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/comment`, {
+            method: 'POST',
+            body: JSON.stringify({ body: this.plainTextAdf(input.text) }),
+        });
+    }
+    async createTimeEntry(credentials, _context, remoteTaskId, input) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const startedAt = this.validate.timeEntryInput(input);
+        if (input.durationMs % 1000 !== 0) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        const configuration = await this.requestJson(site, '/rest/api/3/configuration');
+        if (!(0, vendor_shared_1.isRecord)(configuration)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        if (configuration.timeTrackingEnabled !== true) {
+            throw new external_provider_errors_1.JiraProviderError('time_tracking_disabled');
+        }
+        const body = {
+            started: new Date(startedAt).toISOString().replace('Z', '+0000'),
+            timeSpentSeconds: input.durationMs / 1000,
+        };
+        if (input.note !== null && input.note !== '') {
+            body.comment = this.plainTextAdf(input.note);
+        }
+        const payload = await this.requestJson(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/worklog?adjustEstimate=leave`, { method: 'POST', body: JSON.stringify(body) });
+        if (!(0, vendor_shared_1.isRecord)(payload)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response', undefined, { dispatched: true });
+        }
+        const id = payload.id;
+        if ((typeof id !== 'string' && typeof id !== 'number') ||
+            !this.validate.requiredIdentifier(id)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response', undefined, { dispatched: true });
+        }
+        return { remoteEntryId: this.validate.requiredIdentifier(id) };
+    }
+    async readTimeEntryExact(credentials, _context, remoteTaskId, remoteEntryId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const entryId = this.validate.requiredIdentifier(remoteEntryId);
+        const [identityPayload, payload] = await Promise.all([
+            this.requestJson(site, '/rest/api/3/myself'),
+            this.requestJson(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/worklog/${encodeURIComponent(entryId)}`).catch((error) => {
+                if (error instanceof external_provider_errors_1.JiraProviderError && error.details?.reason === 'not_found') {
+                    return null;
+                }
+                throw error;
+            }),
+        ]);
+        if (payload === null) {
+            return null;
+        }
+        if (!(0, vendor_shared_1.isRecord)(identityPayload)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const accountId = this.validate.requiredString(identityPayload.accountId);
+        const parsed = this.parseWorklog(payload);
+        if (parsed.remoteId !== entryId) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return {
+            remoteId: parsed.remoteId,
+            startedAt: new Date(parsed.startedAtMs).toISOString(),
+            durationMs: parsed.durationMs,
+            owned: parsed.authorAccountId === accountId,
+        };
+    }
+    async deleteTimeEntry(credentials, _context, remoteTaskId, remoteEntryId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const entryId = this.validate.requiredIdentifier(remoteEntryId);
+        await this.requestNoContent(site, `/rest/api/3/issue/${encodeURIComponent(taskId)}/worklog/${encodeURIComponent(entryId)}?adjustEstimate=leave&notifyUsers=false`, { method: 'DELETE' });
+    }
+    async listOwnTimeEntryIdsInRange(credentials, _context, remoteTaskId, startedAfterMs, startedBeforeMs) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const identity = await this.loadIdentity(site);
+        const ids = [];
+        const seen = new Set();
+        let nextStart = 0;
+        for (let page = 0; page < JIRA_WORKLOG_MAX_PAGES; page += 1) {
+            const page_ = await this.requestWorklogPage(site, taskId, nextStart, JIRA_WORKLOG_PAGE_SIZE, startedAfterMs, startedBeforeMs);
+            for (const worklog of page_.worklogs) {
+                const parsed = this.parseWorklog(worklog);
+                if (parsed.authorAccountId !== identity.accountId) {
+                    continue;
+                }
+                if (!seen.has(parsed.remoteId)) {
+                    seen.add(parsed.remoteId);
+                    ids.push(parsed.remoteId);
+                }
+            }
+            if (page_.worklogs.length < JIRA_WORKLOG_PAGE_SIZE) {
+                return { ids, complete: true };
+            }
+            const stepped = page_.startAt + page_.worklogs.length;
+            if (stepped <= nextStart || ids.length >= JIRA_WORKLOG_MAX_RAW) {
+                return { ids, complete: false };
+            }
+            if (stepped >= page_.total) {
+                return { ids, complete: true };
+            }
+            nextStart = stepped;
+        }
+        return { ids, complete: false };
+    }
+    async assertTimeEntryDeletable(credentials, context, remoteTaskId, remoteEntryId) {
+        const exact = await this.readTimeEntryExact(credentials, context, remoteTaskId, remoteEntryId);
+        if (exact === null) {
+            throw new external_provider_errors_1.JiraProviderError('not_found');
+        }
+        if (!exact.owned) {
+            throw new external_provider_errors_1.JiraProviderError('permission_denied');
+        }
+        const site = this.resolveSite(credentials);
+        if (!(await this.loadDeleteOwnWorklogsPermission(site))) {
+            throw new external_provider_errors_1.JiraProviderError('permission_denied');
+        }
+    }
+    async getTaskTimeEntryHistory(credentials, _context, remoteTaskId) {
+        const site = this.resolveSite(credentials);
+        const taskId = this.validate.requiredTaskId(remoteTaskId);
+        const now = Date.now();
+        const startedAfterMs = now - external_provider_models_1.TIME_ENTRY_HISTORY_WINDOW_DAYS * 86_400_000;
+        const [identity, canDeleteOwn] = await Promise.all([
+            this.loadIdentity(site),
+            this.loadDeleteOwnWorklogsPermission(site),
+        ]);
+        const { raw, complete } = await this.fetchWindowedWorklogs(site, taskId, startedAfterMs, now);
+        const own = [];
+        for (const value of raw) {
+            const parsed = this.parseWorklog(value);
+            if (parsed.authorAccountId !== identity.accountId) {
+                continue;
+            }
+            own.push(parsed);
+        }
+        own.sort((left, right) => right.startedAtMs - left.startedAtMs || (0, vendor_shared_1.compareRemoteIds)(left.remoteId, right.remoteId));
+        return {
+            windowDays: external_provider_models_1.TIME_ENTRY_HISTORY_WINDOW_DAYS,
+            truncated: !complete || own.length > external_provider_models_1.MAX_TIME_ENTRY_HISTORY_ENTRIES,
+            hasRunningTimer: false,
+            entries: own.slice(0, external_provider_models_1.MAX_TIME_ENTRY_HISTORY_ENTRIES).map((parsed) => ({
+                remoteId: parsed.remoteId,
+                durationMs: parsed.durationMs,
+                startedAt: new Date(parsed.startedAtMs).toISOString(),
+                note: parsed.note,
+                noteTruncated: parsed.noteTruncated,
+                canDelete: canDeleteOwn,
+            })),
+        };
+    }
+    async loadDeleteOwnWorklogsPermission(site) {
+        const url = new URL(`${site.origin}/rest/api/3/mypermissions`);
+        url.searchParams.set('permissions', 'DELETE_OWN_WORKLOGS');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) || !(0, vendor_shared_1.isRecord)(payload.permissions)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const permission = payload.permissions.DELETE_OWN_WORKLOGS;
+        if (!(0, vendor_shared_1.isRecord)(permission)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return permission.enabled === true;
+    }
+    async fetchWindowedWorklogs(site, taskId, startedAfterMs, startedBeforeMs) {
+        const rawById = new Map();
+        const collect = (worklogs) => {
+            for (const worklog of worklogs) {
+                if (!(0, vendor_shared_1.isRecord)(worklog)) {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                rawById.set(this.validate.requiredIdentifier(worklog.id), worklog);
+            }
+        };
+        const raw = () => [...rawById.values()];
+        const probe = await this.requestWorklogPage(site, taskId, 0, 1, startedAfterMs, startedBeforeMs);
+        if (probe.worklogs.length > 1) {
+            collect(probe.worklogs);
+            return { raw: raw(), complete: rawById.size >= probe.total };
+        }
+        if (probe.total <= probe.worklogs.length) {
+            collect(probe.worklogs);
+            return { raw: raw(), complete: true };
+        }
+        if (probe.worklogs.length === 0) {
+            return this.walkWorklogsForward(site, taskId, startedAfterMs, startedBeforeMs, rawById, collect, probe.total, raw);
+        }
+        return this.walkWorklogsBackward(site, taskId, startedAfterMs, startedBeforeMs, rawById, collect, probe.total, raw);
+    }
+    async walkWorklogsBackward(site, taskId, startedAfterMs, startedBeforeMs, rawById, collect, anchorTotal, raw) {
+        let anchor = anchorTotal;
+        let nextStart = Math.max(0, anchor - JIRA_WORKLOG_PAGE_SIZE);
+        for (let pages = 1; pages < JIRA_WORKLOG_MAX_PAGES; pages += 1) {
+            if (rawById.size >= JIRA_WORKLOG_MAX_RAW) {
+                return { raw: raw(), complete: false };
+            }
+            const page = await this.requestWorklogPage(site, taskId, nextStart, JIRA_WORKLOG_PAGE_SIZE, startedAfterMs, startedBeforeMs);
+            if (page.total !== anchor) {
+                anchor = page.total;
+            }
+            collect(page.worklogs);
+            if (page.startAt === 0 || rawById.size >= anchor) {
+                return { raw: raw(), complete: rawById.size >= anchor || page.startAt === 0 };
+            }
+            const stepped = page.startAt - JIRA_WORKLOG_PAGE_SIZE;
+            if (stepped >= nextStart) {
+                return { raw: raw(), complete: false };
+            }
+            nextStart = Math.max(0, stepped);
+        }
+        return { raw: raw(), complete: rawById.size >= anchor };
+    }
+    async walkWorklogsForward(site, taskId, startedAfterMs, startedBeforeMs, rawById, collect, anchorTotal, raw) {
+        let anchor = anchorTotal;
+        let nextStart = 0;
+        for (let pages = 1; pages < JIRA_WORKLOG_MAX_PAGES; pages += 1) {
+            if (rawById.size >= JIRA_WORKLOG_MAX_RAW) {
+                return { raw: raw(), complete: false };
+            }
+            const page = await this.requestWorklogPage(site, taskId, nextStart, JIRA_WORKLOG_PAGE_SIZE, startedAfterMs, startedBeforeMs);
+            if (page.total !== anchor) {
+                anchor = page.total;
+            }
+            collect(page.worklogs);
+            if (page.worklogs.length < JIRA_WORKLOG_PAGE_SIZE) {
+                return {
+                    raw: raw(),
+                    complete: page.worklogs.length > 0 || rawById.size >= anchor,
+                };
+            }
+            if (rawById.size >= anchor) {
+                return { raw: raw(), complete: true };
+            }
+            const stepped = page.startAt + page.worklogs.length;
+            if (stepped <= nextStart) {
+                return { raw: raw(), complete: false };
+            }
+            nextStart = stepped;
+        }
+        return { raw: raw(), complete: rawById.size >= anchor };
+    }
+    parseWorklogPage(payload) {
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.worklogs)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const startAt = this.requiredCount(payload.startAt);
+        const maxResults = this.requiredCount(payload.maxResults);
+        const total = this.requiredCount(payload.total);
+        if (payload.worklogs.length > maxResults) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        if (payload.worklogs.length > 0 && startAt + payload.worklogs.length > total) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return { startAt, maxResults, total, worklogs: payload.worklogs };
+    }
+    async requestWorklogPage(site, taskId, startAt, maxResults, startedAfterMs, startedBeforeMs) {
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}/worklog`);
+        url.searchParams.set('startedAfter', String(startedAfterMs));
+        url.searchParams.set('startedBefore', String(startedBeforeMs));
+        url.searchParams.set('startAt', String(startAt));
+        url.searchParams.set('maxResults', String(maxResults));
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        return this.parseWorklogPage(payload);
+    }
+    parseWorklog(value) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const author = value.author;
+        if (author !== null && author !== undefined && !(0, vendor_shared_1.isRecord)(author)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const authorAccountId = author === null || author === undefined
+            ? null
+            : this.validate.requiredString(author.accountId);
+        const seconds = value.timeSpentSeconds;
+        if (typeof seconds !== 'number' || !Number.isSafeInteger(seconds) || seconds < 0) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const note = this.worklogNote(value.comment);
+        return {
+            remoteId: this.validate.requiredIdentifier(value.id),
+            authorAccountId,
+            startedAtMs: this.parseWorklogStarted(value.started),
+            durationMs: seconds * 1_000,
+            note: note.value,
+            noteTruncated: note.truncated,
+        };
+    }
+    worklogNote(value) {
+        if (value === null || value === undefined) {
+            return { value: null, truncated: false };
+        }
+        const text = this.flattenAdfText(value);
+        return {
+            value: text ? text.slice(0, external_provider_models_1.MAX_TIME_ENTRY_NOTE_LENGTH) : null,
+            truncated: text.length > external_provider_models_1.MAX_TIME_ENTRY_NOTE_LENGTH,
+        };
+    }
+    parseWorklogStarted(value) {
+        if (typeof value !== 'string' || !value.trim()) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const normalized = value.trim().replace(/([+-]\d{2})(\d{2})$/, '$1:$2');
+        const parsed = Date.parse(normalized);
+        if (!Number.isFinite(parsed)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return parsed;
+    }
+    taskTotalDurationMs(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const seconds = value.timeSpentSeconds;
+        if (seconds === null || seconds === undefined) {
+            return null;
+        }
+        if (typeof seconds !== 'number' || !Number.isSafeInteger(seconds) || seconds < 0) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return seconds * 1_000;
+    }
+    normalizeTaskDetail(value, site, taskId) {
+        if (!(0, vendor_shared_1.isRecord)(value) ||
+            !(0, vendor_shared_1.isRecord)(value.fields) ||
+            this.validate.requiredString(value.key) !== taskId) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const fields = value.fields;
+        if (!(0, vendor_shared_1.isRecord)(fields.status) ||
+            !(0, vendor_shared_1.isRecord)(fields.status.statusCategory) ||
+            !(0, vendor_shared_1.isRecord)(fields.project)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const category = this.classifyStatus(this.validate.requiredString(fields.status.statusCategory.key).toLowerCase());
+        const description = this.adfPlainText(fields.description);
+        const projectId = this.validate.requiredIdentifier(fields.project.id);
+        const projectName = this.validate.requiredString(fields.project.name);
+        const statusId = this.validate.requiredIdentifier(fields.status.id);
+        return {
+            remoteId: taskId,
+            remoteKey: taskId,
+            title: this.validate.requiredString(fields.summary),
+            description: description.value,
+            descriptionTruncated: description.truncated,
+            status: {
+                remoteId: statusId,
+                remoteStatusIds: [statusId],
+                name: this.validate.requiredString(fields.status.name),
+                color: this.statusColor(category),
+                category,
+                position: 0,
+            },
+            dueAt: this.optionalDueDate(fields.duedate),
+            priority: this.normalizePriority(fields.priority),
+            taskTotalDurationMs: this.taskTotalDurationMs(fields.timetracking),
+            webUrl: this.issueWebUrl(site, taskId),
+            location: {
+                scopeKey: site.hostname,
+                workAreaId: projectId,
+                workAreaName: projectName,
+            },
+        };
+    }
+    async normalizeTaskSubtasks(value, site, parentRemoteTaskId) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.fields) || !Array.isArray(value.fields.subtasks)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const references = value.fields.subtasks;
+        const selected = references.slice(0, external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS);
+        const normalized = await (0, vendor_shared_1.mapWithConcurrency)(selected, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, (reference) => this.normalizeTaskSubtask(reference, site, parentRemoteTaskId));
+        const items = normalized
+            .flatMap(({ item }) => (item === null ? [] : [item]))
+            .sort(vendor_shared_1.compareTaskSubtaskSummaries);
+        return {
+            items,
+            truncated: references.length > external_provider_models_1.MAX_TASK_DETAIL_SUBTASKS ||
+                normalized.some((result) => result.truncated),
+        };
+    }
+    async normalizeTaskSubtask(reference, site, parentRemoteTaskId) {
+        if (!(0, vendor_shared_1.isRecord)(reference)) {
+            return { item: null, truncated: true };
+        }
+        const childKey = this.optionalJiraKey(reference);
+        if (childKey === null) {
+            return { item: null, truncated: true };
+        }
+        const rich = this.normalizeTaskSubtaskReference(reference, site, childKey);
+        if (rich !== null) {
+            return { item: rich, truncated: false };
+        }
+        return this.readTaskSubtaskFallback(site, childKey, parentRemoteTaskId);
+    }
+    normalizeTaskSubtaskReference(value, site, childKey) {
+        if (!(0, vendor_shared_1.isRecord)(value.fields) ||
+            !(0, vendor_shared_1.isRecord)(value.fields.status) ||
+            !(0, vendor_shared_1.isRecord)(value.fields.status.statusCategory)) {
+            return null;
+        }
+        try {
+            const category = this.classifyStatus(this.validate.requiredString(value.fields.status.statusCategory.key).toLowerCase());
+            return {
+                remoteId: childKey,
+                remoteKey: childKey,
+                title: this.validate.requiredString(value.fields.summary),
+                status: {
+                    remoteId: this.validate.requiredIdentifier(value.fields.status.id),
+                    name: this.validate.requiredString(value.fields.status.name),
+                    category,
+                },
+                webUrl: this.issueWebUrl(site, childKey),
+            };
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.JiraProviderError) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async readTaskSubtaskFallback(site, childKey, parentRemoteTaskId) {
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(childKey)}`);
+        url.searchParams.set('fields', 'summary,status,parent');
+        let payload;
+        try {
+            payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        }
+        catch (error) {
+            if (error instanceof external_provider_errors_1.JiraProviderError && error.details?.reason === 'not_found') {
+                return { item: null, truncated: true };
+            }
+            throw error;
+        }
+        if (!(0, vendor_shared_1.isRecord)(payload) ||
+            this.optionalJiraKey(payload) !== childKey ||
+            !(0, vendor_shared_1.isRecord)(payload.fields)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        if (!(0, vendor_shared_1.isRecord)(payload.fields.parent) ||
+            this.optionalJiraKey(payload.fields.parent) !== parentRemoteTaskId) {
+            return { item: null, truncated: true };
+        }
+        const item = this.normalizeTaskSubtaskReference(payload, site, childKey);
+        if (item === null) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return { item, truncated: false };
+    }
+    async loadTransitions(site, taskId) {
+        const url = new URL(`${site.origin}/rest/api/3/issue/${encodeURIComponent(taskId)}/transitions`);
+        url.searchParams.set('expand', 'transitions.fields');
+        const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+        if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.transitions)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return payload.transitions.map((value, position) => {
+            if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.to) || !(0, vendor_shared_1.isRecord)(value.to.statusCategory)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            if (!(0, vendor_shared_1.isRecord)(value.fields)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            const hasRequiredFields = Object.values(value.fields).some((field) => {
+                if (!(0, vendor_shared_1.isRecord)(field)) {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                return field.required === true;
+            });
+            const category = this.classifyStatus(this.validate.requiredString(value.to.statusCategory.key).toLowerCase());
+            const destinationStatusId = this.validate.requiredIdentifier(value.to.id);
+            const transitionId = this.validate.requiredIdentifier(value.id);
+            return {
+                id: transitionId,
+                supported: value.isAvailable !== false && !hasRequiredFields,
+                option: {
+                    actionValue: transitionId,
+                    actionLabel: this.validate.requiredString(value.name),
+                    remoteId: destinationStatusId,
+                    remoteStatusIds: [destinationStatusId],
+                    name: this.validate.requiredString(value.to.name),
+                    color: this.statusColor(category),
+                    category,
+                    position,
+                },
+            };
+        });
+    }
+    adfPlainText(value) {
+        const text = this.flattenAdfText(value);
+        return {
+            value: text ? text.slice(0, external_provider_models_1.MAX_TASK_DETAIL_TEXT_LENGTH) : null,
+            truncated: text.length > external_provider_models_1.MAX_TASK_DETAIL_TEXT_LENGTH,
+        };
+    }
+    adfCommentBody(value) {
+        const text = this.flattenAdfText(value);
+        return {
+            value: text.slice(0, external_provider_models_1.MAX_TASK_COMMENT_BODY_LENGTH),
+            truncated: text.length > external_provider_models_1.MAX_TASK_COMMENT_BODY_LENGTH,
+        };
+    }
+    flattenAdfText(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (!(0, vendor_shared_1.isRecord)(value) ||
+            value.type !== 'doc' ||
+            value.version !== 1 ||
+            !Array.isArray(value.content)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const fragments = [];
+        const visit = (node, depth) => {
+            if (depth > 128) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            if (!(0, vendor_shared_1.isRecord)(node) || typeof node.type !== 'string') {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            if (node.type === 'text') {
+                if (typeof node.text !== 'string') {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                fragments.push(node.text);
+            }
+            else if (node.type === 'hardBreak') {
+                fragments.push('\n');
+            }
+            else if (node.type === 'mention' || node.type === 'status') {
+                fragments.push(this.adfAttrFallback(node, 'text'));
+            }
+            else if (node.type === 'emoji') {
+                fragments.push(this.adfAttrFallback(node, 'shortName'));
+            }
+            else if (node.type === 'inlineCard') {
+                fragments.push(this.adfAttrFallback(node, 'url'));
+            }
+            else if (node.type === 'date') {
+                fragments.push(this.adfDateFallback(node));
+            }
+            if (node.content !== undefined) {
+                if (!Array.isArray(node.content)) {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                node.content.forEach((child) => visit(child, depth + 1));
+            }
+            if (node.type === 'paragraph' || node.type === 'heading') {
+                fragments.push('\n');
+            }
+        };
+        value.content.forEach((node) => visit(node, 0));
+        return fragments.join('').replace(/\n+$/, '');
+    }
+    adfAttrFallback(node, attr) {
+        const attrs = node.attrs;
+        if (attrs === null || attrs === undefined) {
+            return '';
+        }
+        if (!(0, vendor_shared_1.isRecord)(attrs)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const value = attrs[attr];
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value !== 'string') {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return value.trim() ? value : '';
+    }
+    adfDateFallback(node) {
+        const attrs = node.attrs;
+        if (!(0, vendor_shared_1.isRecord)(attrs) || typeof attrs.timestamp !== 'string' || !/^\d+$/.test(attrs.timestamp)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        try {
+            return new Date(Number(attrs.timestamp)).toISOString().slice(0, 10);
+        }
+        catch {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+    }
+    plainTextAdf(text) {
+        return {
+            type: 'doc',
+            version: 1,
+            content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
+        };
+    }
+    normalizePriority(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return { name: this.validate.requiredString(value.name), color: JIRA_NEUTRAL_COLOR };
+    }
+    statusColor(category) {
+        return category === 'completed' ? JIRA_COMPLETED_COLOR : JIRA_NEUTRAL_COLOR;
+    }
+    issueWebUrl(site, taskId) {
+        return `${site.origin}/browse/${encodeURIComponent(taskId)}`;
+    }
+    async discoverMyWork(credentials, options) {
+        const site = this.resolveSite(credentials);
+        const now = Date.now();
+        const cutoff = now - vendor_shared_1.RECENT_COMPLETED_WINDOW_MS;
+        const [identity, configuration, issues] = await Promise.all([
+            this.loadIdentity(site),
+            this.requestJson(site, '/rest/api/3/configuration'),
+            this.searchAssignedIssues(site, options.includeCompleted),
+        ]);
+        if (!(0, vendor_shared_1.isRecord)(configuration)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const uniqueTasks = new Map();
+        for (const issue of issues) {
+            const normalized = this.normalizeIssue(issue, site, identity, {
+                includeCompleted: options.includeCompleted,
+                cutoff,
+                now,
+            });
+            if (normalized && !uniqueTasks.has(normalized.task.remoteId)) {
+                uniqueTasks.set(normalized.task.remoteId, {
+                    item: normalized,
+                    projectKey: this.issueProjectKey(issue),
+                });
+            }
+        }
+        const routed = await this.discoverRelevantBoards(site, options, [...uniqueTasks.values()], now);
+        return {
+            capabilities: { timeTrackingEnabled: configuration.timeTrackingEnabled === true },
+            workAreas: routed.workAreas,
+            tasks: routed.tasks,
+            refreshedAt: new Date(now).toISOString(),
+        };
+    }
+    async loadIdentity(site) {
+        const payload = await this.requestJson(site, '/rest/api/3/myself');
+        if (!(0, vendor_shared_1.isRecord)(payload)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return {
+            accountId: this.validate.requiredString(payload.accountId),
+            displayName: this.validate.requiredString(payload.displayName),
+        };
+    }
+    async searchAssignedIssues(site, includeCompleted) {
+        const jql = this.assignedJql(includeCompleted);
+        const issues = [];
+        const seenTokens = new Set();
+        let nextPageToken;
+        for (let page = 0; page < JIRA_MAX_SEARCH_PAGES; page += 1) {
+            const body = {
+                jql,
+                fields: [...JIRA_SEARCH_FIELDS],
+                maxResults: JIRA_SEARCH_PAGE_SIZE,
+            };
+            if (nextPageToken !== undefined) {
+                body.nextPageToken = nextPageToken;
+            }
+            const payload = await this.requestJson(site, '/rest/api/3/search/jql', {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+            if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.issues)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            issues.push(...payload.issues);
+            if (payload.nextPageToken === undefined || payload.nextPageToken === null) {
+                return issues;
+            }
+            if (typeof payload.nextPageToken !== 'string' || !payload.nextPageToken.trim()) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            nextPageToken = payload.nextPageToken.trim();
+            if (seenTokens.has(nextPageToken)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            seenTokens.add(nextPageToken);
+        }
+        throw new external_provider_errors_1.JiraProviderError('invalid_response');
+    }
+    normalizeIssue(value, site, identity, filter) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.fields)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const fields = value.fields;
+        if (!(0, vendor_shared_1.isRecord)(fields.status) ||
+            !(0, vendor_shared_1.isRecord)(fields.status.statusCategory) ||
+            !(0, vendor_shared_1.isRecord)(fields.assignee) ||
+            !(0, vendor_shared_1.isRecord)(fields.project)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        if (this.validate.requiredString(fields.assignee.accountId) !== identity.accountId) {
+            return null;
+        }
+        const category = this.classifyStatus(this.validate.requiredString(fields.status.statusCategory.key).toLowerCase());
+        const completedAt = this.optionalTimestamp(fields.resolutiondate);
+        if (category === 'completed') {
+            const completedTime = completedAt === null ? Number.NaN : Date.parse(completedAt);
+            if (!filter.includeCompleted ||
+                !Number.isFinite(completedTime) ||
+                completedTime < filter.cutoff ||
+                completedTime > filter.now) {
+                return null;
+            }
+        }
+        const remoteId = this.validate.requiredString(value.key);
+        const projectId = this.validate.requiredIdentifier(fields.project.id);
+        const projectName = this.validate.requiredString(fields.project.name);
+        const workArea = {
+            remoteId: projectId,
+            scopeKey: site.hostname,
+            name: projectName,
+            kind: 'project',
+            description: null,
+            assignedTaskCount: 0,
+            hierarchy: [
+                { kind: 'workspace', remoteId: site.hostname, name: site.hostname },
+                { kind: 'project', remoteId: projectId, name: projectName },
+            ],
+            workflow: { isOverridden: false, columns: [] },
+            refresh: {
+                state: 'fresh',
+                refreshedAt: new Date(filter.now).toISOString(),
+                retryable: false,
+                retryAt: null,
+            },
+        };
+        return {
+            workArea,
+            task: {
+                remoteId,
+                parentRemoteTaskId: this.normalizeIssueParent(fields),
+                title: this.validate.requiredString(fields.summary),
+                status: {
+                    remoteId: this.validate.requiredIdentifier(fields.status.id),
+                    name: this.validate.requiredString(fields.status.name),
+                    category,
+                },
+                updatedAt: this.requiredTimestamp(fields.updated),
+                dueAt: this.optionalDueDate(fields.duedate),
+                completedAt,
+                webUrl: `${site.origin}/browse/${encodeURIComponent(remoteId)}`,
+            },
+        };
+    }
+    normalizeIssueParent(fields) {
+        if (!(0, vendor_shared_1.isRecord)(fields.issuetype) || fields.issuetype.subtask !== true) {
+            return null;
+        }
+        return (0, vendor_shared_1.isRecord)(fields.parent) ? this.optionalJiraKey(fields.parent) : null;
+    }
+    async discoverRelevantBoards(site, options, assignedTasks, now) {
+        const projectKeys = [...new Set(assignedTasks.map(({ projectKey }) => projectKey))];
+        const boards = await this.loadRelevantBoards(site, projectKeys);
+        const assignedById = new Map(assignedTasks.map((assigned) => [assigned.item.task.remoteId, assigned]));
+        const matchedIds = new Set();
+        const workAreas = [];
+        const tasks = [];
+        const boardResults = await (0, vendor_shared_1.mapWithConcurrency)(boards, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, async (board) => {
+            const boardIssueIds = await this.loadBoardIssueIds(site, board.id, options.includeCompleted);
+            const boardTasks = [];
+            const seenBoardTasks = new Set();
+            for (const remoteId of boardIssueIds) {
+                const assigned = assignedById.get(remoteId);
+                if (!assigned || seenBoardTasks.has(remoteId)) {
+                    continue;
+                }
+                seenBoardTasks.add(remoteId);
+                boardTasks.push(assigned);
+            }
+            if (boardTasks.length === 0) {
+                return null;
+            }
+            const workArea = await this.loadBoardMetadata(site, options, board, boardTasks.length, now);
+            return { workArea, boardTasks };
+        });
+        for (const result of boardResults) {
+            if (!result) {
+                continue;
+            }
+            workAreas.push(result.workArea);
+            for (const assigned of result.boardTasks) {
+                matchedIds.add(assigned.item.task.remoteId);
+                tasks.push({ workArea: result.workArea, task: assigned.item.task });
+            }
+        }
+        const unmatched = assignedTasks.filter(({ item }) => !matchedIds.has(item.task.remoteId));
+        if (unmatched.length > 0) {
+            const workArea = this.otherAssignedWorkArea(site, unmatched.length, now);
+            workAreas.push(workArea);
+            tasks.push(...unmatched.map(({ item }) => ({ workArea, task: item.task })));
+        }
+        return { workAreas, tasks };
+    }
+    async loadRelevantBoards(site, projectKeys) {
+        const boardPages = await (0, vendor_shared_1.mapWithConcurrency)(projectKeys, vendor_shared_1.VENDOR_DISCOVERY_CONCURRENCY, (projectKey) => this.loadProjectBoards(site, projectKey));
+        const boards = new Map();
+        for (const board of boardPages.flat()) {
+            if (!boards.has(board.id)) {
+                boards.set(board.id, board);
+            }
+        }
+        return [...boards.values()];
+    }
+    async loadProjectBoards(site, projectKey) {
+        const boards = [];
+        let startAt = 0;
+        for (let page = 0; page < JIRA_MAX_SEARCH_PAGES; page += 1) {
+            const url = new URL(`${site.origin}/rest/agile/1.0/board`);
+            url.searchParams.set('projectKeyOrId', projectKey);
+            url.searchParams.set('startAt', String(startAt));
+            url.searchParams.set('maxResults', String(JIRA_SEARCH_PAGE_SIZE));
+            const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+            if (!(0, vendor_shared_1.isRecord)(payload) ||
+                !Array.isArray(payload.values) ||
+                typeof payload.isLast !== 'boolean') {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            for (const value of payload.values) {
+                if (!(0, vendor_shared_1.isRecord)(value)) {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                boards.push({
+                    id: this.requiredBoardId(value.id),
+                    name: this.validate.requiredString(value.name),
+                });
+            }
+            if (payload.isLast) {
+                return boards;
+            }
+            if (payload.values.length === 0) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            startAt += payload.values.length;
+        }
+        throw new external_provider_errors_1.JiraProviderError('invalid_response');
+    }
+    async loadBoardIssueIds(site, boardId, includeCompleted) {
+        const issueIds = [];
+        const seenTokens = new Set();
+        let nextPageToken;
+        for (let page = 0; page < JIRA_MAX_SEARCH_PAGES; page += 1) {
+            const url = new URL(`${site.origin}/rest/software/1.0/board/${encodeURIComponent(boardId)}/issue`);
+            url.searchParams.set('maxResults', String(JIRA_SEARCH_PAGE_SIZE));
+            url.searchParams.set('fields', 'key');
+            url.searchParams.set('jql', this.assignedJql(includeCompleted));
+            if (nextPageToken !== undefined) {
+                url.searchParams.set('nextPageToken', nextPageToken);
+            }
+            const payload = await this.requestJson(site, `${url.pathname}${url.search}`);
+            if (!(0, vendor_shared_1.isRecord)(payload) || !Array.isArray(payload.issues)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            for (const issue of payload.issues) {
+                if (!(0, vendor_shared_1.isRecord)(issue)) {
+                    throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                }
+                issueIds.push(this.validate.requiredString(issue.key));
+            }
+            if (payload.nextPageToken === undefined || payload.nextPageToken === null) {
+                return issueIds;
+            }
+            if (typeof payload.nextPageToken !== 'string' || !payload.nextPageToken.trim()) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            nextPageToken = payload.nextPageToken.trim();
+            if (seenTokens.has(nextPageToken)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            seenTokens.add(nextPageToken);
+        }
+        throw new external_provider_errors_1.JiraProviderError('invalid_response');
+    }
+    async loadBoardMetadata(site, options, board, assignedTaskCount, now) {
+        const cacheKey = JSON.stringify([
+            options.connectionId,
+            options.connectionGeneration,
+            site.hostname,
+            board.id,
+        ]);
+        const cached = this.boardMetadataCache.get(cacheKey);
+        if (cached && now - cached.fetchedAt <= vendor_shared_1.WORK_AREA_METADATA_TTL_MS) {
+            return (0, vendor_shared_1.materializeWorkArea)(cached.value, assignedTaskCount, {
+                state: 'fresh',
+                refreshedAt: new Date(cached.fetchedAt).toISOString(),
+                retryable: false,
+                retryAt: null,
+            });
+        }
+        const base = this.baseBoardWorkArea(site, board);
+        try {
+            const configuration = await this.requestJson(site, `/rest/agile/1.0/board/${encodeURIComponent(board.id)}/configuration`);
+            const metadataWithoutDescription = this.normalizeBoardConfiguration(configuration, base, board);
+            const filterId = this.boardFilterId(configuration);
+            const filter = await this.requestJson(site, `/rest/api/3/filter/${encodeURIComponent(filterId)}`);
+            const metadata = {
+                ...metadataWithoutDescription,
+                description: this.filterDescription(filter),
+            };
+            this.boardMetadataCache.set(cacheKey, { value: metadata, fetchedAt: now });
+            return (0, vendor_shared_1.materializeWorkArea)(metadata, assignedTaskCount, {
+                state: 'fresh',
+                refreshedAt: new Date(now).toISOString(),
+                retryable: false,
+                retryAt: null,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof external_provider_errors_1.JiraProviderError)) {
+                throw error;
+            }
+            if (cached) {
+                return (0, vendor_shared_1.materializeWorkArea)(cached.value, assignedTaskCount, {
+                    state: 'stale',
+                    refreshedAt: new Date(cached.fetchedAt).toISOString(),
+                    retryable: true,
+                    retryAt: (0, vendor_shared_1.vendorRetryAt)(error),
+                });
+            }
+            return {
+                ...base,
+                assignedTaskCount,
+                refresh: {
+                    state: 'error',
+                    refreshedAt: null,
+                    retryable: true,
+                    retryAt: (0, vendor_shared_1.vendorRetryAt)(error),
+                },
+            };
+        }
+    }
+    normalizeBoardConfiguration(value, base, board) {
+        if (!(0, vendor_shared_1.isRecord)(value) ||
+            this.requiredBoardId(value.id) !== board.id ||
+            !(0, vendor_shared_1.isRecord)(value.columnConfig) ||
+            !Array.isArray(value.columnConfig.columns)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const name = this.validate.requiredString(value.name);
+        const columns = this.normalizeBoardColumns(value.columnConfig.columns);
+        const hierarchy = [
+            { kind: 'workspace', remoteId: base.scopeKey, name: base.scopeKey },
+        ];
+        if (value.location !== undefined && value.location !== null) {
+            if (!(0, vendor_shared_1.isRecord)(value.location)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            if (value.location.type === 'project') {
+                hierarchy.push({
+                    kind: 'project',
+                    remoteId: this.validate.requiredIdentifier(value.location.id),
+                    name: this.validate.requiredString(value.location.name),
+                });
+            }
+        }
+        return {
+            ...base,
+            name,
+            hierarchy,
+            workflow: { isOverridden: true, columns },
+        };
+    }
+    normalizeBoardColumns(values) {
+        const mapped = values.map((value, position) => {
+            if (!(0, vendor_shared_1.isRecord)(value) || !Array.isArray(value.statuses)) {
+                throw new external_provider_errors_1.JiraProviderError('invalid_response');
+            }
+            return {
+                name: this.validate.requiredString(value.name),
+                remoteStatusIds: value.statuses.map((status) => {
+                    if (!(0, vendor_shared_1.isRecord)(status)) {
+                        throw new external_provider_errors_1.JiraProviderError('invalid_response');
+                    }
+                    return this.validate.requiredIdentifier(status.id);
+                }),
+                position,
+            };
+        });
+        let lastMappedPosition = -1;
+        for (const column of mapped) {
+            if (column.remoteStatusIds.length > 0) {
+                lastMappedPosition = column.position;
+            }
+        }
+        return mapped.map((column) => {
+            const category = column.remoteStatusIds.length === 0
+                ? 'unknown'
+                : column.position === lastMappedPosition
+                    ? 'completed'
+                    : 'active';
+            return {
+                remoteId: null,
+                remoteStatusIds: column.remoteStatusIds,
+                name: column.name,
+                color: this.statusColor(category),
+                category,
+                position: column.position,
+            };
+        });
+    }
+    boardFilterId(value) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.filter)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return this.validate.requiredIdentifier(value.filter.id);
+    }
+    filterDescription(value) {
+        if (!(0, vendor_shared_1.isRecord)(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        if (value.description === undefined || value.description === null || value.description === '') {
+            return null;
+        }
+        if (typeof value.description !== 'string') {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return value.description;
+    }
+    baseBoardWorkArea(site, board) {
+        return {
+            remoteId: board.id,
+            scopeKey: site.hostname,
+            name: board.name,
+            kind: 'board',
+            description: null,
+            hierarchy: [{ kind: 'workspace', remoteId: site.hostname, name: site.hostname }],
+            workflow: { isOverridden: false, columns: [] },
+        };
+    }
+    otherAssignedWorkArea(site, count, now) {
+        return {
+            remoteId: OTHER_ASSIGNED_WORK_AREA_ID,
+            scopeKey: site.hostname,
+            name: 'Other assigned issues',
+            kind: 'board',
+            description: null,
+            assignedTaskCount: count,
+            hierarchy: [{ kind: 'workspace', remoteId: site.hostname, name: site.hostname }],
+            workflow: { isOverridden: false, columns: [] },
+            refresh: {
+                state: 'fresh',
+                refreshedAt: new Date(now).toISOString(),
+                retryable: false,
+                retryAt: null,
+            },
+        };
+    }
+    issueProjectKey(value) {
+        if (!(0, vendor_shared_1.isRecord)(value) || !(0, vendor_shared_1.isRecord)(value.fields) || !(0, vendor_shared_1.isRecord)(value.fields.project)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return this.validate.requiredString(value.fields.project.key);
+    }
+    assignedJql(includeCompleted) {
+        return includeCompleted
+            ? 'assignee = currentUser() AND (statusCategory != Done OR resolutiondate >= -30d) ORDER BY updated DESC'
+            : 'assignee = currentUser() AND statusCategory != Done ORDER BY updated DESC';
+    }
+    requiredBoardId(value) {
+        if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return String(value);
+    }
+    resolveSite(credentials) {
+        if (credentials.provider !== this.provider ||
+            !credentials.email.trim() ||
+            !credentials.token.trim()) {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+        try {
+            if (!JIRA_SITE_URL.test(credentials.siteUrl)) {
+                throw new Error('invalid Jira site URL');
+            }
+            const url = new URL(credentials.siteUrl);
+            const hostname = url.hostname.toLowerCase();
+            if (url.protocol !== 'https:' ||
+                url.username !== '' ||
+                url.password !== '' ||
+                url.port !== '' ||
+                url.pathname !== '/' ||
+                url.search !== '' ||
+                url.hash !== '' ||
+                !JIRA_TENANT_HOSTNAME.test(hostname)) {
+                throw new Error('invalid Jira site URL');
+            }
+            return {
+                origin: `https://${hostname}`,
+                hostname,
+                authorization: `Basic ${Buffer.from(`${credentials.email}:${credentials.token}`).toString('base64')}`,
+            };
+        }
+        catch {
+            throw new external_provider_errors_1.JiraProviderError('request_rejected');
+        }
+    }
+    async requestJson(site, path, request = {}) {
+        try {
+            return await this.http.requestJson({
+                url: `${site.origin}${path}`,
+                allowedOrigins: [site.origin],
+                ...request,
+                headers: {
+                    accept: 'application/json',
+                    authorization: site.authorization,
+                    ...(request.body === undefined ? {} : { 'content-type': 'application/json' }),
+                },
+            });
+        }
+        catch (error) {
+            throw (0, vendor_shared_1.mapVendorTransportError)(error, (reason, retryAt, dispatched) => new external_provider_errors_1.JiraProviderError(reason, retryAt, dispatched ? { dispatched: true } : {}));
+        }
+    }
+    async requestNoContent(site, path, request) {
+        try {
+            await this.http.requestNoContent({
+                url: `${site.origin}${path}`,
+                allowedOrigins: [site.origin],
+                ...request,
+                headers: {
+                    accept: 'application/json',
+                    authorization: site.authorization,
+                    ...(request.body === undefined ? {} : { 'content-type': 'application/json' }),
+                },
+            });
+        }
+        catch (error) {
+            throw (0, vendor_shared_1.mapVendorTransportError)(error, (reason, retryAt, dispatched) => new external_provider_errors_1.JiraProviderError(reason, retryAt, dispatched ? { dispatched: true } : {}));
+        }
+    }
+    classifyStatus(key) {
+        if (key === 'done') {
+            return 'completed';
+        }
+        if (key === 'new' || key === 'indeterminate') {
+            return 'active';
+        }
+        return 'unknown';
+    }
+    requiredTimestamp(value) {
+        const timestamp = this.optionalTimestamp(value);
+        if (timestamp === null) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return timestamp;
+    }
+    optionalTimestamp(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value !== 'string' || !value.trim()) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const timestamp = Date.parse(value);
+        if (!Number.isFinite(timestamp)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return new Date(timestamp).toISOString();
+    }
+    optionalDueDate(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        const timestamp = Date.parse(`${value}T00:00:00.000Z`);
+        if (!Number.isFinite(timestamp) || new Date(timestamp).toISOString().slice(0, 10) !== value) {
+            throw new external_provider_errors_1.JiraProviderError('invalid_response');
+        }
+        return new Date(timestamp).toISOString();
+    }
+};
+exports.JiraExternalTaskProvider = JiraExternalTaskProvider;
+exports.JiraExternalTaskProvider = JiraExternalTaskProvider = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [safe_vendor_http_client_1.SafeVendorHttpClient])
+], JiraExternalTaskProvider);
+//# sourceMappingURL=jira-external-task.provider.js.map