@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/internal/task-qualification.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import { applyQualificationConfirmation } from '../task/qualification-confirmation.js';
+import { applyQualificationProposal } from '../task/qualification-intents.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = `Usage: agent-infra-internal task-qualification <task-ref> <proposal|confirm|supersede|revoke> --input <json-file> [--dry-run]\n`;
+function fail(message, code = 'QUALIFICATION_PROPOSAL_INVALID') {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code, message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+async function taskQualification(args = []) {
+    const [taskRef, operation] = args;
+    const registered = [
+        internalHandlerRoute('task-qualification', 'proposal', operation ?? ''),
+        internalHandlerRoute('task-qualification', 'confirm', operation ?? ''),
+        internalHandlerRoute('task-qualification', 'supersede', operation ?? ''),
+        internalHandlerRoute('task-qualification', 'revoke', operation ?? '')
+    ].some(Boolean);
+    if (!registered) {
+        fail('task ref and a valid qualification operation are required');
+        return;
+    }
+    if (!ensureInternalHandlerRoute('task-qualification', args))
+        return;
+    if (!taskRef || !['proposal', 'confirm', 'supersede', 'revoke'].includes(operation ?? '')) {
+        fail('task ref and a valid qualification operation are required');
+        return;
+    }
+    let inputPath = '';
+    let dryRun = false;
+    for (let index = 2; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--dry-run') {
+            if (dryRun) {
+                fail('duplicate option --dry-run');
+                return;
+            }
+            dryRun = true;
+            continue;
+        }
+        if (arg !== '--input' || inputPath) {
+            fail(`unknown or duplicate option '${arg}'`);
+            return;
+        }
+        inputPath = args[++index] ?? '';
+        if (!inputPath || inputPath.startsWith('--')) {
+            fail("option '--input' requires a value");
+            return;
+        }
+    }
+    if (!inputPath) {
+        fail("option '--input' is required");
+        return;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
+    }
+    catch (error) {
+        fail(`cannot read qualification input: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        fail('qualification input must be an object');
+        return;
+    }
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        fail(resolved.message, resolved.code);
+        return;
+    }
+    try {
+        const result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-qualification.${operation}`, () => operation === 'proposal'
+            ? applyQualificationProposal({ ...payload, taskRef: resolved.taskId, dryRun }, { repoRoot: resolved.repoRoot })
+            : applyQualificationConfirmation({ ...payload, taskRef: resolved.taskId, operation, dryRun }, { repoRoot: resolved.repoRoot }));
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
+    }
+    catch (error) {
+        if (error instanceof TaskExecutionLockError)
+            fail(`${error.code}: ${error.message}`, error.code);
+        else
+            throw error;
+    }
+}
+export { taskQualification };
+//# sourceMappingURL=task-qualification.js.map

package/dist/lib/internal/task-review.js

@@ -1,7 +1,9 @@
+import { parseReviewCommand } from '../task/review-command.js';
 import { finalizeReviewSummary } from '../task/review-finalization.js';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
@@ -14,65 +16,21 @@ function failUsage(message) {
     process.exitCode = 2;
 }
 async function taskReview(args = []) {
+    if (!ensureInternalHandlerRoute('task-review', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length < 2) {
-        failUsage('task ref and intent are required');
-        return;
-    }
-    if (args[1] !== 'finalize-summary') {
-        failUsage(`unknown intent '${args[1]}'`);
-        return;
-    }
-    let stage = '';
-    let artifact = '';
-    let dryRun = false;
-    let orchestrated = false;
-    let overrideTicket = '';
-    let overrideTarget = '';
-    let overrideScope = '';
-    const seen = new Set();
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (!['--stage', '--artifact', '--orchestrated', '--dry-run', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
-            failUsage(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            failUsage(`duplicate option '${flag}'`);
-            return;
-        }
-        seen.add(flag);
-        if (flag === '--dry-run') {
-            dryRun = true;
-            continue;
-        }
-        if (flag === '--orchestrated') {
-            orchestrated = true;
-            continue;
-        }
-        const value = args[++index];
-        if (!value || value.startsWith('--')) {
-            failUsage(`option '${flag}' requires a value`);
-            return;
-        }
-        if (flag === '--stage')
-            stage = value;
-        else if (flag === '--artifact')
-            artifact = value;
-        else if (flag === '--override-ticket')
-            overrideTicket = value;
-        else if (flag === '--override-target')
-            overrideTarget = value;
-        else if (flag === '--override-scope')
-            overrideScope = value;
+    let request;
+    try {
+        request = parseReviewCommand(args);
     }
-    if (!stage || !artifact) {
-        failUsage("options '--stage' and '--artifact' are required");
+    catch (error) {
+        failUsage(error instanceof Error ? error.message : String(error));
         return;
     }
+    const { stage, artifact, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
     const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
     if (dryRunConflict) {
         failUsage(dryRunConflict.message);

package/dist/lib/internal/task-short-id.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { detectRepoRoot } from '../task/resolve-ref.js';
 import { configuredShortIdLength, executeShortIdCommand } from '../task/short-id.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-short-id <alloc|release|resolve|list> [argument] [--active-dir <path>] [--short-id-length <N>] [--verify]\n`;
 function failure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, output: '', error: { code: 'SHORT_ID_PAYLOAD_INVALID', message } })}\n`);
@@ -8,12 +9,21 @@ function failure(message) {
     process.exitCode = 1;
 }
 function taskShortId(args = []) {
+    if (!ensureInternalHandlerRoute('task-short-id', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['alloc', 'release', 'resolve', 'list'].includes(operation)) {
+    const route = operation === 'list' && args.includes('--verify') ? 'list-verify' : operation ?? '';
+    if (!operation || ![
+        internalHandlerRoute('task-short-id', 'alloc', route),
+        internalHandlerRoute('task-short-id', 'release', route),
+        internalHandlerRoute('task-short-id', 'resolve', route),
+        internalHandlerRoute('task-short-id', 'list', route),
+        internalHandlerRoute('task-short-id', 'list-verify', route)
+    ].some(Boolean)) {
         failure('a valid short-id operation is required');
         return;
     }

package/dist/lib/internal/task-snapshot.js

@@ -1,4 +1,5 @@
 import { collectTaskSnapshot } from '../task/snapshot.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-snapshot <N | TASK-id> [--format json|text]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'SNAPSHOT_PAYLOAD_INVALID', message } })}\n`);
@@ -6,11 +7,13 @@ function fail(message) {
     process.exitCode = 1;
 }
 function taskSnapshot(args = []) {
+    if (!ensureInternalHandlerRoute('task-snapshot', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (!args[0] || args[0].startsWith('--')) {
+    if (!args[0] || args[0].startsWith('--') || !internalHandlerRoute('task-snapshot', 'snapshot', 'snapshot')) {
         fail('task ref is required');
         return;
     }

package/dist/lib/internal/task-validate.js

@@ -16,12 +16,15 @@ import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../sandbox/control/protocol.js';
 import { getProcessStartTime } from '../server/process-state.js';
 import { assertGitWorktreeBinding } from '../git/worktree-identity.js';
-const USAGE = `Usage: agent-infra-internal task-validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] -- <command> [args...]`;
+import { createManualValidationEvidence, manualValidationEvidenceSummary } from '../task/manual-validation-evidence.js';
+import { writeJsonAtomic } from '../task/manual-validation-shared.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = `Usage: agent-infra-internal task-validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] [--evidence-file <path>] -- <command> [args...]`;
 const MAX_TIMEOUT_MS = 60 * 60 * 1000;
 const RECOVERY_GRACE_MS = 30_000;
 export function parseValidateArgs(args) {
     if (args.includes('--help') || args.includes('-h')) {
-        return { target: '', scope: 'snapshot', timeoutMs: 300_000, format: 'text', command: [], help: true };
+        return { target: '', scope: 'snapshot', timeoutMs: 300_000, format: 'text', evidenceFile: null, command: [], help: true };
     }
     const separator = args.indexOf('--');
     if (separator < 0)
@@ -31,6 +34,7 @@ export function parseValidateArgs(args) {
     let scope = 'snapshot';
     let timeoutMs = 300_000;
     let format = 'text';
+    let evidenceFile = null;
     const positionals = [];
     for (let index = 0; index < optionArgs.length; index += 1) {
         const arg = optionArgs[index];
@@ -52,6 +56,12 @@ export function parseValidateArgs(args) {
                 throw new Error('validate --format must be text or json');
             format = value;
         }
+        else if (arg === '--evidence-file') {
+            const value = optionArgs[++index];
+            if (!value || value.startsWith('-'))
+                throw new Error('validate --evidence-file requires a path');
+            evidenceFile = value;
+        }
         else if (arg.startsWith('-')) {
             throw new Error(`Unknown option: ${arg}`);
         }
@@ -61,7 +71,7 @@ export function parseValidateArgs(args) {
     }
     if (positionals.length !== 1 || command.length === 0)
         throw new Error(USAGE);
-    return { target: positionals[0], scope, timeoutMs, format, command, help: false };
+    return { target: positionals[0], scope, timeoutMs, format, evidenceFile, command, help: false };
 }
 function runValidationCommand(command, cwd, scope, timeoutMs, json) {
     const [file, ...args] = command;
@@ -273,6 +283,8 @@ function sniffFormat(args) {
     return index >= 0 && args[index + 1] === 'json' ? 'json' : 'text';
 }
 function taskValidate(args) {
+    if (!ensureInternalHandlerRoute('task-validate', args))
+        return;
     let options;
     try {
         options = parseValidateArgs(args);
@@ -290,27 +302,40 @@ function taskValidate(args) {
         const target = resolveSandboxTarget(options.target, config.repoRoot);
         const commit = git(config.repoRoot, ['rev-parse', target.branch]);
         const startedAt = new Date().toISOString();
-        const result = options.scope === 'snapshot'
+        const result = internalHandlerRoute('task-validate', 'snapshot', options.scope)
             ? snapshotValidation(config.repoRoot, commit, options)
-            : inplaceValidation(config, target, options);
-        const evidence = {
-            version: 1,
+            : internalHandlerRoute('task-validate', 'inplace', options.scope)
+                ? inplaceValidation(config, target, options)
+                : (() => { throw new Error('TASK_VALIDATE_SCOPE_UNREGISTERED'); })();
+        const cleanup = result.cleanup();
+        const evidence = createManualValidationEvidence({
+            mode: target.workspace.mode,
             taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
             branch: target.branch,
-            scope: options.scope,
             commit,
+            recoverable: target.workspace.mode === 'task-bound',
+            scope: options.scope,
             command: path.basename(options.command[0]),
             startedAt,
             completedAt: new Date().toISOString(),
             exitCode: result.exitCode,
             signal: result.signal,
-            cleanup: result.cleanup()
-        };
+            cleanup
+        });
+        if (options.evidenceFile) {
+            try {
+                writeJsonAtomic(path.resolve(options.evidenceFile), evidence);
+            }
+            catch (error) {
+                throw new Error(`MANUAL_VALIDATION_EVIDENCE_WRITE_FAILED: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const evidenceSummary = manualValidationEvidenceSummary(evidence);
         if (options.format === 'json') {
-            process.stdout.write(`${JSON.stringify({ status: 'applied', changed: false, evidence, error: null })}\n`);
+            process.stdout.write(`${JSON.stringify({ status: 'applied', changed: false, evidence: evidenceSummary, evidenceFile: options.evidenceFile, error: null })}\n`);
         }
         else {
-            process.stdout.write(`Validation ${result.exitCode === 0 ? 'passed' : 'failed'} (${options.scope}, ${evidence.command}, cleanup=${evidence.cleanup}).\n`);
+            process.stdout.write(`Validation ${result.exitCode === 0 ? 'passed' : 'failed'} (${options.scope}, ${evidenceSummary.command}, cleanup=${evidenceSummary.cleanup}).\n`);
         }
         process.exitCode = result.exitCode;
     }

package/dist/lib/internal/task-verify.js

@@ -2,6 +2,7 @@ import { renderTaskVerification, verifyTaskEvent } from '../task/verification.js
 import { consumeHumanOverride, failureId } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'VERIFY_PAYLOAD_INVALID', message } })}\n`);
@@ -9,11 +10,14 @@ function fail(message) {
     process.exitCode = 1;
 }
 async function taskVerify(args = []) {
+    if (!ensureInternalHandlerRoute('task-verify', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (!args[0] || !args[1] || args[0].startsWith('--') || args[1].startsWith('--')) {
+    if (!args[0] || !args[1] || args[0].startsWith('--') || args[1].startsWith('--')
+        || !internalHandlerRoute('task-verify', 'event', args[1] ? 'event' : '')) {
         fail('task ref and verification event are required');
         return;
     }

package/dist/lib/internal/task-warning.js

@@ -2,6 +2,7 @@ import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js'
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
 const FLAGS = {
     '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
@@ -14,12 +15,18 @@ function usageFailure(message) {
     process.exitCode = 1;
 }
 async function taskWarning(args = []) {
+    if (!ensureInternalHandlerRoute('task-warning', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const [taskRef, kind] = args;
-    if (!taskRef || !kind || !['add', 'set-status', 'list'].includes(kind)) {
+    if (!taskRef || !kind || ![
+        internalHandlerRoute('task-warning', 'add', kind ?? ''),
+        internalHandlerRoute('task-warning', 'set-status', kind ?? ''),
+        internalHandlerRoute('task-warning', 'list', kind ?? '')
+    ].some(Boolean)) {
         usageFailure('task ref and a valid intent are required');
         return;
     }

package/dist/lib/owned-path.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+// Inspect descendants without following symlinks. The caller supplies the trusted root.
+export function inspectOwnedPath(rootInput, targetInput, expect) {
+    const root = path.resolve(rootInput);
+    const target = path.resolve(targetInput);
+    const relative = path.relative(root, target);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    try {
+        const rootStat = fs.lstatSync(root);
+        if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
+            return null;
+        let current = root;
+        for (const segment of relative.split(path.sep)) {
+            current = path.join(current, segment);
+            const stat = fs.lstatSync(current);
+            if (stat.isSymbolicLink())
+                return null;
+            if (process.platform !== 'win32' && typeof process.getuid === 'function' && stat.uid !== process.getuid())
+                return null;
+            if (current === target)
+                return (expect === 'file' ? stat.isFile() : stat.isDirectory()) ? stat : null;
+            if (!stat.isDirectory())
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+//# sourceMappingURL=owned-path.js.map

package/dist/lib/platform/check-status.js

@@ -0,0 +1,11 @@
+export function checkStatusBucket(status) {
+    const value = status.toLowerCase();
+    if (['pass', 'success', 'successful', 'neutral'].includes(value))
+        return 'pass';
+    if (['fail', 'failure', 'failed', 'error', 'timed_out', 'action_required'].includes(value))
+        return 'fail';
+    if (['cancel', 'cancelled', 'canceled', 'skipped', 'stale'].includes(value))
+        return 'cancel';
+    return 'pending';
+}
+//# sourceMappingURL=check-status.js.map

package/dist/lib/platform/comment-safety.js

@@ -0,0 +1,229 @@
+const CONTROL_MARKER_PATTERN = /<!--\s*(?:sync-issue|sync-pr|last-commit)\b[\s\S]*?-->|<!--\s*canonical-pr-change-report\s*-->/gi;
+function ok(value) {
+    return { ok: true, value };
+}
+function invalid(message, offset) {
+    return { ok: false, error: { code: 'COMMENT_DOCUMENT_INVALID', message, offset } };
+}
+function normalized(value) {
+    return value.replace(/\r\n?/g, '\n');
+}
+function linesOf(value) {
+    const lines = [];
+    let start = 0;
+    while (start < value.length) {
+        const newline = value.indexOf('\n', start);
+        const end = newline === -1 ? value.length : newline;
+        lines.push({ start, end: newline === -1 ? end : newline + 1, text: value.slice(start, end) });
+        start = newline === -1 ? value.length : newline + 1;
+    }
+    if (value.length === 0)
+        lines.push({ start: 0, end: 0, text: '' });
+    return lines;
+}
+function openingFence(line) {
+    const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (!match)
+        return null;
+    const character = match[1][0];
+    const info = match[2];
+    if (character === '`' && info.includes('`'))
+        return 'invalid';
+    return { character, length: match[1].length };
+}
+function closesFence(line, fence) {
+    const escaped = fence.character === '`' ? '`' : '~';
+    return new RegExp(`^ {0,3}${escaped}{${fence.length},}[ \\t]*$`).test(line);
+}
+function fenceRanges(value) {
+    const ranges = [];
+    let fence = null;
+    for (const line of linesOf(value)) {
+        if (!fence) {
+            const opening = openingFence(line.text);
+            if (opening === 'invalid')
+                return invalid('fenced code info string is invalid', line.start);
+            if (opening)
+                fence = { ...opening, start: line.start, openingEnd: line.end };
+            continue;
+        }
+        if (closesFence(line.text, fence)) {
+            ranges.push({
+                start: fence.start,
+                end: line.end,
+                openingEnd: fence.openingEnd,
+                closingStart: line.start,
+                character: fence.character,
+                opening: value.slice(fence.start, fence.openingEnd),
+                closing: value.slice(line.start, line.end)
+            });
+            fence = null;
+        }
+    }
+    if (fence)
+        return invalid('fenced code block is not closed', fence.start);
+    return ok(ranges);
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function escapeHtmlText(value) {
+    return escapeHtml(value);
+}
+function escapeHtmlAttribute(value) {
+    return escapeHtml(value);
+}
+function escapeMarkdownLiteral(value) {
+    return value.replace(/[\\`*_{}\[\]()#+.!|<>-]/g, '\\$&');
+}
+function markerSafe(value, markers) {
+    let result = value;
+    for (const marker of markers) {
+        const flags = marker.flags.includes('g') ? marker.flags : `${marker.flags}g`;
+        const pattern = new RegExp(marker.source, flags);
+        result = result.replace(pattern, (match) => escapeHtmlText(match));
+    }
+    return result;
+}
+function tagEnd(value, start) {
+    let quote = null;
+    for (let index = start + 1; index < value.length; index += 1) {
+        const character = value[index];
+        if (quote) {
+            if (character === quote)
+                quote = null;
+        }
+        else if (character === '"' || character === "'") {
+            quote = character;
+        }
+        else if (character === '>') {
+            return index;
+        }
+    }
+    return -1;
+}
+function isMarkdownAutolink(value, start) {
+    const end = value.indexOf('>', start + 1);
+    if (end === -1)
+        return false;
+    const target = value.slice(start + 1, end);
+    return /^(?:https?:\/\/|mailto:)[^<>\s]+$/i.test(target)
+        || /^[^<>\s@]+@[^<>\s@]+\.[^<>\s@]+$/.test(target);
+}
+function sanitizeOutside(value, baseOffset) {
+    let result = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.startsWith('<!--', index)) {
+            const end = value.indexOf('-->', index + 4);
+            if (end === -1)
+                return invalid('HTML comment is not closed', baseOffset + index);
+            const token = value.slice(index, end + 3);
+            result += escapeHtmlText(token);
+            index = end + 3;
+            continue;
+        }
+        if (value[index] === '<' && isMarkdownAutolink(value, index)) {
+            const end = value.indexOf('>', index + 1);
+            result += value.slice(index, end + 1);
+            index = end + 1;
+            continue;
+        }
+        if (value[index] === '<' && /[\\/!?A-Za-z]/.test(value[index + 1] || '')) {
+            const end = tagEnd(value, index);
+            if (end === -1)
+                return invalid('HTML-like tag is not closed', baseOffset + index);
+            result += escapeHtmlText(value.slice(index, end + 1));
+            index = end + 1;
+            continue;
+        }
+        result += value[index];
+        index += 1;
+    }
+    return ok(result);
+}
+function sanitizeMarkdownDocument(value, options = {}) {
+    const source = normalized(value);
+    const ranges = fenceRanges(source);
+    if (!ranges.ok)
+        return ranges;
+    const markers = options.reservedMarkers || [];
+    let result = '';
+    let cursor = 0;
+    for (const range of ranges.value) {
+        const outside = sanitizeOutside(source.slice(cursor, range.start), cursor);
+        if (!outside.ok)
+            return outside;
+        result += outside.value;
+        result += markerSafe(source.slice(range.start, range.end), markers);
+        cursor = range.end;
+    }
+    const tail = sanitizeOutside(source.slice(cursor), cursor);
+    if (!tail.ok)
+        return tail;
+    return ok(result + tail.value);
+}
+function canonicalizeCommentBody(value) {
+    return sanitizeMarkdownDocument(value, { reservedMarkers: [CONTROL_MARKER_PATTERN] });
+}
+function renderSafeCodeFence(value, language = '', reservedMarkers = [CONTROL_MARKER_PATTERN]) {
+    const content = markerSafe(normalized(value), reservedMarkers);
+    const longestRun = Math.max(0, ...(content.match(/`+/g) || []).map((run) => run.length));
+    const delimiter = '`'.repeat(Math.max(3, longestRun + 1));
+    const suffix = content.endsWith('\n') ? '' : '\n';
+    return `${delimiter}${language}\n${content}${suffix}${delimiter}`;
+}
+function commentRangesOutsideFences(source, ranges) {
+    const comments = [];
+    let cursor = 0;
+    for (const fence of [...ranges, { start: source.length, end: source.length }]) {
+        const segment = source.slice(cursor, fence.start);
+        let index = 0;
+        while (index < segment.length) {
+            const opening = segment.indexOf('<!--', index);
+            if (opening === -1)
+                break;
+            const absoluteStart = cursor + opening;
+            const closing = segment.indexOf('-->', opening + 4);
+            if (closing === -1)
+                return invalid('HTML comment is not closed', absoluteStart);
+            comments.push({ start: absoluteStart, end: cursor + closing + 3 });
+            index = closing + 3;
+        }
+        cursor = fence.end;
+    }
+    return ok(comments);
+}
+function splitDocumentPlaceholder(value, placeholder) {
+    const source = normalized(value);
+    const ranges = fenceRanges(source);
+    if (!ranges.ok)
+        return ranges;
+    const positions = [];
+    let cursor = source.indexOf(placeholder);
+    while (cursor !== -1) {
+        positions.push(cursor);
+        cursor = source.indexOf(placeholder, cursor + placeholder.length);
+    }
+    if (positions.length !== 1)
+        return invalid('document must contain exactly one placeholder', positions[1] ?? positions[0] ?? source.length);
+    const position = positions[0];
+    if (ranges.value.some((range) => position >= range.start && position < range.end)) {
+        return invalid('placeholder must be outside fenced code', position);
+    }
+    const comments = commentRangesOutsideFences(source, ranges.value);
+    if (!comments.ok)
+        return comments;
+    const containing = comments.value.find((comment) => position >= comment.start && position < comment.end);
+    if (containing && (containing.start !== position || containing.end !== position + placeholder.length)) {
+        return invalid('placeholder must not be nested in another HTML comment', position);
+    }
+    return ok({ prefix: source.slice(0, position), suffix: source.slice(position + placeholder.length) });
+}
+export { CONTROL_MARKER_PATTERN, escapeHtmlAttribute, escapeHtmlText, escapeMarkdownLiteral, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
+//# sourceMappingURL=comment-safety.js.map