@cratis/screenplay-language 4.53.0 → 4.55.0

package/README.md

@@ -31,6 +31,21 @@ monaco.editor.create(element, {
 - **Hover** — keyword documentation, concept definitions (primitive + attributes), policy require expressions, and event property lists.
 - **Diagnostics** — unknown slice types, unknown primitive types, references to undeclared policies and events, tab indentation, and unclosed code fences. Every one of them carries the compiler's own `PLAY` code (`diagnosticCodes`), so a squiggle and a CLI diagnostic for the same condition are the same code.
 
+## Quick fixes
+
+The registered code-action provider offers verified edits against the current buffer:
+
+- `PLAY0479`: replace one legacy `?` suffix with `optional`, or migrate the document.
+- `PLAY0471`: remove a redundant event `id` line. Trailing comments prevent removal.
+
+Redundant id removal works in placed and multi-document applications.
+Actions respect the requested diagnostic and kind, cache analysis per model version,
+and pin edits to that version. Range requests return every eligible intersecting occurrence, without duplicate
+actions. Independent recipes are verified together once per version to check the intended
+syntax changes and diagnostic removal without reparsing per marker; no .NET process is
+required. See [editor quick fixes](../../../../Documentation/screenplay/vscode.md#event-quick-fixes)
+for the redundant id removal behavior.
+
 ## Extending with new sub-languages
 
 ```typescript

package/dist/bundles/{chunk-7WJEZ72S.js → chunk-GJX4NJYC.js}

@@ -941,6 +941,48 @@ var DiagnosticCodes = {
   InvalidTriggerData: "PLAY0246"
 };
 
+// ../../Compiler/dist/Parsing/SourceLineSplitter.js
+function splitLines(source, hashComments = false, path) {
+  const result = [];
+  let number = 0;
+  let offset = 0;
+  for (const raw of source.split("\n")) {
+    number++;
+    const line = raw.endsWith("\r") ? raw.replace(/\r+$/, "") : raw;
+    const indent = line.length - line.trimStart().length;
+    const content = stripComment(line.substring(indent), hashComments).trimEnd();
+    result.push(path === void 0 ? { number, raw: line, indent, content, startOffset: offset } : { number, raw: line, indent, content, path, startOffset: offset });
+    offset += raw.length + 1;
+  }
+  return result;
+}
+function commentStart(text, hashComments = false) {
+  let inString = false;
+  let inTemplate = false;
+  for (let index = 0; index < text.length; index++) {
+    const current = text[index];
+    if (current === "\\" && inString && index + 1 < text.length) {
+      index++;
+    } else if (current === '"' && !inTemplate) {
+      inString = !inString;
+    } else if (current === "`" && !inString) {
+      inTemplate = !inTemplate;
+    } else if (!inString && !inTemplate) {
+      if (current === "/" && index + 1 < text.length && text[index + 1] === "/") {
+        return index;
+      }
+      if (hashComments && current === "#") {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function stripComment(text, hashComments) {
+  const comment = commentStart(text, hashComments);
+  return comment < 0 ? text : text.substring(0, comment);
+}
+
 // ../../Compiler/dist/Files/PlayPlacement.js
 var documentPlacement = [];
 var isDocumentPlacement = (placement) => placement.length === 0;
@@ -3824,48 +3866,6 @@ function parsePersona(context, line) {
   return { kind: "PersonaSyntax", name, description, policies, location: locationOf(line) };
 }
 
-// ../../Compiler/dist/Parsing/SourceLineSplitter.js
-function splitLines(source, hashComments = false, path) {
-  const result = [];
-  let number = 0;
-  let offset = 0;
-  for (const raw of source.split("\n")) {
-    number++;
-    const line = raw.endsWith("\r") ? raw.replace(/\r+$/, "") : raw;
-    const indent = line.length - line.trimStart().length;
-    const content = stripComment(line.substring(indent), hashComments).trimEnd();
-    result.push(path === void 0 ? { number, raw: line, indent, content, startOffset: offset } : { number, raw: line, indent, content, path, startOffset: offset });
-    offset += raw.length + 1;
-  }
-  return result;
-}
-function commentStart(text, hashComments = false) {
-  let inString = false;
-  let inTemplate = false;
-  for (let index = 0; index < text.length; index++) {
-    const current = text[index];
-    if (current === "\\" && inString && index + 1 < text.length) {
-      index++;
-    } else if (current === '"' && !inTemplate) {
-      inString = !inString;
-    } else if (current === "`" && !inString) {
-      inTemplate = !inTemplate;
-    } else if (!inString && !inTemplate) {
-      if (current === "/" && index + 1 < text.length && text[index + 1] === "/") {
-        return index;
-      }
-      if (hashComments && current === "#") {
-        return index;
-      }
-    }
-  }
-  return -1;
-}
-function stripComment(text, hashComments) {
-  const comment = commentStart(text, hashComments);
-  return comment < 0 ? text : text.substring(0, comment);
-}
-
 // ../../Compiler/dist/ScreenplayCompiler.js
 function parse(source, path, placement = documentPlacement) {
   const { value, diagnostics, success } = parseForAuthoring(source, path, placement);
@@ -3884,33 +3884,342 @@ function parseForAuthoring(source, path, placement = documentPlacement) {
   };
 }
 
-// ../../Compiler/dist/Syntax/SyntaxJson.js
-var isNode = (value) => typeof value === "object" && value !== null && typeof value.kind === "string";
-function toSyntaxJson(node) {
-  return write(node);
-}
-function write(value) {
-  if (Array.isArray(value)) {
-    return value.map(write);
+// ../../Compiler/dist/Syntax/ScreenplaySyntaxWalker.js
+var ScreenplaySyntaxWalker = class {
+  visitNode(_node) {
+  }
+  visitApplication(syntax) {
+    this.visitNode(syntax);
+    if (syntax.domain !== null)
+      this.visitDomain(syntax.domain);
+    syntax.imports.forEach((node) => this.visitImport(node));
+    syntax.fileImports.forEach((node) => this.visitFileImport(node));
+    syntax.concepts.forEach((node) => this.visitConcept(node));
+    syntax.types.forEach((node) => this.visitType(node));
+    syntax.personas.forEach((node) => this.visitPersona(node));
+    syntax.modules.forEach((node) => this.visitModule(node));
+  }
+  visitPersona(syntax) {
+    this.visitNode(syntax);
+  }
+  visitAuthorize(syntax) {
+    this.visitNode(syntax);
+    this.visitPolicyRequirement(syntax.requirement);
+  }
+  visitPolicyRequirement(syntax) {
+    this.visitNode(syntax);
+    if (syntax.kind === "LogicalPolicyRequirementSyntax") {
+      this.visitPolicyRequirement(syntax.left);
+      this.visitPolicyRequirement(syntax.right);
+    }
+  }
+  visitDomain(syntax) {
+    this.visitNode(syntax);
+  }
+  visitImport(syntax) {
+    this.visitNode(syntax);
+  }
+  visitFileImport(syntax) {
+    this.visitNode(syntax);
+  }
+  visitConcept(syntax) {
+    this.visitNode(syntax);
+    syntax.attributes.forEach((node) => this.visitNode(node));
+  }
+  visitType(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitProperty(node));
+  }
+  visitModule(syntax) {
+    this.visitNode(syntax);
+    syntax.fileImports.forEach((node) => this.visitFileImport(node));
+    if (syntax.authorize !== null)
+      this.visitAuthorize(syntax.authorize);
+    syntax.features.forEach((node) => this.visitFeature(node));
+  }
+  visitFeature(syntax) {
+    this.visitNode(syntax);
+    syntax.fileImports.forEach((node) => this.visitFileImport(node));
+    if (syntax.authorize !== null)
+      this.visitAuthorize(syntax.authorize);
+    syntax.features.forEach((node) => this.visitFeature(node));
+    syntax.slices.forEach((node) => this.visitSlice(node));
+  }
+  visitSlice(syntax) {
+    this.visitNode(syntax);
+    syntax.commands.forEach((node) => this.visitCommand(node));
+    syntax.events.forEach((node) => this.visitEvent(node));
+    syntax.constraints.forEach((node) => this.visitConstraint(node));
+    syntax.queries.forEach((node) => this.visitQuery(node));
+    syntax.projections.forEach((node) => this.visitProjection(node));
+    syntax.readModels.forEach((node) => this.visitReadModel(node));
+    syntax.captures.forEach((node) => this.visitCapture(node));
+    syntax.reactions.forEach((node) => this.visitReaction(node));
+    syntax.screens.forEach((node) => this.visitScreen(node));
+    syntax.specifications.forEach((node) => this.visitSpecification(node));
+  }
+  visitCommand(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitProperty(node));
+    if (syntax.authorize !== null)
+      this.visitAuthorize(syntax.authorize);
+    syntax.validations.forEach((node) => this.visitValidate(node));
+    syntax.produces.forEach((node) => this.visitProduces(node));
+  }
+  visitValidate(syntax) {
+    this.visitNode(syntax);
+    if (syntax.kind === "DeclarativeValidateSyntax")
+      syntax.rules.forEach((node) => this.visitValidationRule(node));
+  }
+  visitValidationRule(syntax) {
+    this.visitNode(syntax);
+    if (syntax.value !== null)
+      this.visitExpression(syntax.value);
+  }
+  visitEvent(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitProperty(node));
+    syntax.tags.forEach((node) => this.visitTag(node));
+  }
+  visitTag(syntax) {
+    this.visitNode(syntax);
+    this.visitExpression(syntax.value);
+  }
+  visitReadModel(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitProperty(node));
+  }
+  visitConstraint(syntax) {
+    this.visitNode(syntax);
+    if (syntax.kind === "FileConstraintSyntax")
+      this.visitNode(syntax.file);
+    syntax.additionalRules.forEach((node) => this.visitConstraint(node));
+  }
+  visitQuery(syntax) {
+    this.visitNode(syntax);
+    this.visitTypeRef(syntax.returnType);
+    if (syntax.by !== null)
+      this.visitQueryParameter(syntax.by);
+    syntax.filters.forEach((node) => this.visitQueryParameter(node));
+    if (syntax.authorize !== null)
+      this.visitAuthorize(syntax.authorize);
+  }
+  visitQueryParameter(syntax) {
+    this.visitNode(syntax);
+    this.visitTypeRef(syntax.type);
+  }
+  visitProjection(syntax) {
+    this.visitNode(syntax);
+    syntax.blocks.forEach((node) => this.visitProjectionBlock(node));
+  }
+  visitProjectionBlock(syntax) {
+    this.visitNode(syntax);
+    switch (syntax.kind) {
+      case "FromSyntax":
+        syntax.events.forEach((node) => this.visitNode(node));
+        syntax.mappings.forEach((node) => this.visitMapping(node));
+        break;
+      case "EverySyntax":
+      case "AllSyntax":
+        syntax.mappings.forEach((node) => this.visitMapping(node));
+        break;
+      case "JoinSyntax":
+        syntax.events.forEach((node) => this.visitJoinEvent(node));
+        break;
+      case "ProjectionVariantSyntax":
+        syntax.entersOn.forEach((node) => this.visitNode(node));
+        syntax.blocks.forEach((node) => this.visitProjectionBlock(node));
+        break;
+      case "ChildrenSyntax":
+      case "NestedSyntax":
+        syntax.blocks.forEach((node) => this.visitProjectionBlock(node));
+        break;
+    }
   }
-  if (isNode(value)) {
-    const result = { kind: value.kind };
-    const members = Object.keys(value).filter((member) => member !== "kind" && member !== "location").sort(ordinal);
-    for (const member of members) {
-      result[member] = write(value[member]);
+  visitJoinEvent(syntax) {
+    this.visitNode(syntax);
+    syntax.mappings.forEach((node) => this.visitMapping(node));
+  }
+  visitMapping(syntax) {
+    this.visitNode(syntax);
+  }
+  visitReaction(syntax) {
+    this.visitNode(syntax);
+    syntax.triggers.forEach((node) => this.visitReactionTrigger(node));
+  }
+  visitReactionTrigger(syntax) {
+    this.visitNode(syntax);
+    this.visitTriggerSource(syntax.source);
+    syntax.produces.forEach((node) => this.visitProduces(node));
+    syntax.invokes.forEach((node) => this.visitInvokes(node));
+  }
+  visitProduces(syntax) {
+    this.visitNode(syntax);
+    if (syntax.inlineEvent !== null)
+      this.visitEvent(syntax.inlineEvent);
+    if (syntax.for !== null)
+      this.visitExpression(syntax.for);
+    syntax.mappings.forEach((node) => this.visitPropertyMapping(node));
+    syntax.tags.forEach((node) => this.visitTag(node));
+  }
+  visitInvokes(syntax) {
+    this.visitNode(syntax);
+  }
+  visitCapture(syntax) {
+    this.visitNode(syntax);
+    if (syntax.source !== null)
+      this.visitCaptureSource(syntax.source);
+    syntax.appends.forEach((node) => this.visitCaptureAppend(node));
+    syntax.children.forEach((node) => this.visitCaptureChildren(node));
+    syntax.nested.forEach((node) => this.visitCaptureNested(node));
+  }
+  visitCaptureSource(syntax) {
+    this.visitNode(syntax);
+    syntax.settings.forEach((node) => this.visitCaptureSourceSetting(node));
+  }
+  visitCaptureSourceSetting(syntax) {
+    this.visitNode(syntax);
+  }
+  visitCaptureAppend(syntax) {
+    this.visitNode(syntax);
+  }
+  visitCaptureChildren(syntax) {
+    this.visitNode(syntax);
+    syntax.appends.forEach((node) => this.visitCaptureAppend(node));
+  }
+  visitCaptureNested(syntax) {
+    this.visitNode(syntax);
+    syntax.appends.forEach((node) => this.visitCaptureAppend(node));
+  }
+  visitTriggerSource(syntax) {
+    this.visitNode(syntax);
+  }
+  visitScreen(syntax) {
+    this.visitNode(syntax);
+    syntax.directives.forEach((node) => this.visitScreenDirective(node));
+  }
+  visitScreenDirective(syntax) {
+    this.visitNode(syntax);
+    switch (syntax.kind) {
+      case "ScreenDataSyntax":
+        this.visitTypeRef(syntax.type);
+        break;
+      case "ScreenActionSyntax":
+        if (syntax.navigate !== null)
+          this.visitScreenDirective(syntax.navigate);
+        break;
+      case "ScreenTemplateReferenceSyntax":
+        syntax.slots.forEach((slot2) => {
+          this.visitNode(slot2);
+          slot2.directives.forEach((node) => this.visitScreenDirective(node));
+        });
+        break;
+      case "ScreenSectionSyntax":
+        syntax.directives.forEach((node) => this.visitScreenDirective(node));
+        break;
+      case "ScreenTableSyntax":
+        syntax.columns.forEach((node) => this.visitNode(node));
+        if (syntax.rowClick !== null)
+          this.visitScreenDirective(syntax.rowClick);
+        break;
+      case "ScreenSummarySyntax":
+        syntax.fields.forEach((node) => this.visitNode(node));
+        break;
+      case "ScreenCodeSyntax":
+        this.visitNode(syntax.code);
+        break;
     }
-    return result;
   }
-  if (value === void 0) {
-    return null;
+  visitSpecification(syntax) {
+    this.visitNode(syntax);
+    if (syntax.givenClock !== null)
+      this.visitSpecificationClock(syntax.givenClock);
+    syntax.given.forEach((node) => this.visitSpecificationEvent(node));
+    syntax.givenReadModels.forEach((node) => this.visitSpecificationReadModel(node));
+    if (syntax.when !== null)
+      this.visitSpecificationCommand(syntax.when);
+    syntax.givenCaptures.forEach((node) => this.visitSpecificationCapture(node));
+    if (syntax.whenAppended !== null)
+      this.visitSpecificationEvent(syntax.whenAppended);
+    if (syntax.whenClock !== null)
+      this.visitSpecificationClock(syntax.whenClock);
+    if (syntax.whenTrigger !== null)
+      this.visitSpecificationTrigger(syntax.whenTrigger);
+    if (syntax.whenCapture !== null)
+      this.visitSpecificationCapture(syntax.whenCapture);
+    if (syntax.whenQuery !== null)
+      this.visitSpecificationWhenQuery(syntax.whenQuery);
+    syntax.thenEvents.forEach((node) => this.visitSpecificationEvent(node));
+    syntax.thenReadModels.forEach((node) => this.visitSpecificationReadModel(node));
+    syntax.thenResults.forEach((node) => this.visitSpecificationQueryResult(node));
+    if (syntax.thenNoResult !== null)
+      this.visitNode(syntax.thenNoResult);
+    syntax.thenErrors.forEach((node) => this.visitNode(node));
+  }
+  visitSpecificationClock(syntax) {
+    this.visitNode(syntax);
+  }
+  visitSpecificationTrigger(syntax) {
+    this.visitNode(syntax);
+    syntax.values.forEach((node) => this.visitPropertyMapping(node));
+  }
+  visitSpecificationCapture(syntax) {
+    this.visitNode(syntax);
+    syntax.record.forEach((node) => this.visitPropertyMapping(node));
+  }
+  visitSpecificationWhenQuery(syntax) {
+    this.visitNode(syntax);
+    syntax.arguments.forEach((node) => this.visitPropertyMapping(node));
+  }
+  visitSpecificationQueryResult(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitPropertyMapping(node));
+  }
+  visitSpecificationEvent(syntax) {
+    this.visitNode(syntax);
+    syntax.values.forEach((node) => this.visitPropertyMapping(node));
+    if (syntax.for !== null)
+      this.visitExpression(syntax.for);
+  }
+  visitSpecificationCommand(syntax) {
+    this.visitNode(syntax);
+    syntax.values.forEach((node) => this.visitPropertyMapping(node));
+    if (syntax.for !== null)
+      this.visitExpression(syntax.for);
+  }
+  visitSpecificationReadModel(syntax) {
+    this.visitNode(syntax);
+    syntax.properties.forEach((node) => this.visitPropertyMapping(node));
+  }
+  visitPropertyMapping(syntax) {
+    this.visitNode(syntax);
+    this.visitExpression(syntax.source);
+  }
+  visitProperty(syntax) {
+    this.visitNode(syntax);
+    this.visitTypeRef(syntax.type);
+  }
+  visitTypeRef(syntax) {
+    this.visitNode(syntax);
+  }
+  visitExpression(syntax) {
+    this.visitNode(syntax);
+    if (syntax.kind === "ListExpressionSyntax") {
+      syntax.items.forEach((item) => this.visitExpression(item));
+    } else if (syntax.kind === "ObjectExpressionSyntax") {
+      syntax.members.forEach((member) => this.visitObjectMember(member));
+    }
+  }
+  visitObjectMember(syntax) {
+    this.visitNode(syntax);
+    this.visitExpression(syntax.value);
   }
-  return value;
-}
-function ordinal(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
+};
 
 // ../../Compiler/dist/Authoring/QuickFixes.js
+function isQuickFixDiagnostic(code) {
+  return code === DiagnosticCodes.LegacyOptionalSuffix || code === DiagnosticCodes.RedundantEventId;
+}
 function legacyOptionalTypeLength(line, diagnostic) {
   if (diagnostic.code !== DiagnosticCodes.LegacyOptionalSuffix)
     return 0;
@@ -3920,48 +4229,111 @@ function prepareQuickFixes(source, options = {}) {
   const original = parseForAuthoring(source, void 0, options.placement);
   if (!original.success)
     return () => [];
-  const lines = source.split(/\r\n|\r|\n/);
-  const starts = [0];
-  for (const match of source.matchAll(/\r\n|\r|\n/g))
-    starts.push(match.index + match[0].length);
-  const occurrences = original.diagnostics.filter((diagnostic) => diagnostic.code === DiagnosticCodes.LegacyOptionalSuffix).flatMap((diagnostic) => {
-    const length = legacyOptionalTypeLength(lines[diagnostic.location.line - 1], diagnostic);
-    return length === 0 ? [] : [{ diagnostic, edit: { start: starts[diagnostic.location.line - 1] + diagnostic.location.column + length - 2, length: 1, text: " optional" } }];
-  });
-  if (occurrences.length === 0)
-    return () => [];
+  const lines = splitLines(source);
+  const eventsByLine = /* @__PURE__ */ new Map();
+  const walker = new class extends ScreenplaySyntaxWalker {
+    visitEvent(event2) {
+      eventsByLine.set(event2.location.line, event2);
+    }
+  }();
+  walker.visitApplication(original.value);
+  const counts = /* @__PURE__ */ new Map();
+  const byLine = /* @__PURE__ */ new Map();
+  const events = /* @__PURE__ */ new Map();
+  let event;
+  for (const line of lines) {
+    event = eventsByLine.get(line.number) ?? event;
+    if (event !== void 0)
+      events.set(line.number, event);
+  }
+  for (const diagnostic of original.diagnostics) {
+    counts.set(diagnostic.code, (counts.get(diagnostic.code) ?? 0) + 1);
+    const line = lines[diagnostic.location.line - 1];
+    const length = legacyOptionalTypeLength(line.raw, diagnostic);
+    if (length > 0) {
+      byLine.set(line.number, { line: line.number, fix: { diagnosticCode: diagnostic.code, title: "Use 'optional' instead of '?'", scope: "occurrence", edits: [{ start: line.startOffset + diagnostic.location.column + length - 2, length: 1, text: " optional" }] } });
+    } else if (diagnostic.code === DiagnosticCodes.RedundantEventId && commentStart(line.raw) < 0) {
+      const declaration = events.get(line.number);
+      if (declaration?.id !== declaration?.name || declaration === void 0)
+        continue;
+      byLine.set(line.number, {
+        line: line.number,
+        fix: { diagnosticCode: diagnostic.code, title: "Remove the redundant event id", scope: "occurrence", edits: [{ start: line.startOffset, length: (lines[line.number]?.startOffset ?? source.length) - line.startOffset, text: "" }] },
+        change: { node: declaration, replacement: { ...declaration, id: null } }
+      });
+    }
+  }
+  const optional = [...byLine.values()].filter((candidate) => candidate.fix.diagnosticCode === DiagnosticCodes.LegacyOptionalSuffix);
   const syntax = verificationShape(original);
-  const byLine = new Map(occurrences.map((occurrence) => [occurrence.diagnostic.location.line, occurrence]));
-  const verifiedOccurrences = /* @__PURE__ */ new Map();
+  const verified = /* @__PURE__ */ new Map();
+  let rangeVerdicts;
   let documentChecked = false;
   let documentFix;
-  const verify = (fix, line) => {
+  const verify = (fix, change) => {
     const candidate = applyQuickFixEdits(source, fix.edits);
     if (candidate === void 0)
       return void 0;
     const parsed = parseForAuthoring(candidate, void 0, options.placement);
-    return parsed.success && verificationShape(parsed) === syntax && !parsed.diagnostics.some((diagnostic) => diagnostic.code === fix.diagnosticCode && (line === void 0 || line === diagnostic.location.line)) ? fix : void 0;
+    if (!parsed.success || verificationShape(parsed) !== (change === void 0 ? syntax : verificationShape(original, [change])))
+      return void 0;
+    return parsed.diagnostics.filter((diagnostic) => diagnostic.code === fix.diagnosticCode).length === (counts.get(fix.diagnosticCode) ?? 0) - fix.edits.length ? fix : void 0;
   };
-  return (line) => {
-    if (!documentChecked) {
-      documentFix = verify({ diagnosticCode: DiagnosticCodes.LegacyOptionalSuffix, title: "Use 'optional' throughout this document", scope: "document", edits: occurrences.map((occurrence) => occurrence.edit) });
+  return (line, diagnosticCode) => {
+    const requests = typeof line === "number" || line === void 0 ? void 0 : line;
+    const includeDocument = requests === void 0 ? diagnosticCode === void 0 || diagnosticCode === DiagnosticCodes.LegacyOptionalSuffix : requests.some((request) => request.diagnosticCode === DiagnosticCodes.LegacyOptionalSuffix);
+    if (includeDocument && !documentChecked) {
+      if (optional.length > 0)
+        documentFix = verify({ diagnosticCode: DiagnosticCodes.LegacyOptionalSuffix, title: "Use 'optional' throughout this document", scope: "document", edits: optional.flatMap((candidate) => candidate.fix.edits) });
       documentChecked = true;
     }
-    const selected = line === void 0 ? void 0 : byLine.get(line);
+    if (requests !== void 0) {
+      if (rangeVerdicts === void 0) {
+        rangeVerdicts = /* @__PURE__ */ new Map();
+        const candidates = lines.flatMap((line2) => byLine.has(line2.number) ? [byLine.get(line2.number)] : []);
+        const edits = candidates.flatMap((candidate) => candidate.fix.edits);
+        const candidateSource = applyQuickFixEdits(source, edits);
+        if (edits.length > 0 && candidateSource !== void 0) {
+          const parsed = parseForAuthoring(candidateSource, void 0, options.placement);
+          const changes = candidates.flatMap((candidate) => candidate.change === void 0 ? [] : [candidate.change]);
+          if (parsed.success && verificationShape(parsed) === verificationShape(original, changes)) {
+            const remaining = /* @__PURE__ */ new Map();
+            const removed = /* @__PURE__ */ new Map();
+            for (const diagnostic of parsed.diagnostics)
+              remaining.set(diagnostic.code, (remaining.get(diagnostic.code) ?? 0) + 1);
+            for (const candidate of candidates)
+              removed.set(candidate.fix.diagnosticCode, (removed.get(candidate.fix.diagnosticCode) ?? 0) + candidate.fix.edits.length);
+            if ([...removed].every(([code, count]) => (remaining.get(code) ?? 0) === (counts.get(code) ?? 0) - count)) {
+              for (const candidate of candidates)
+                rangeVerdicts.set(candidate.line, candidate.fix);
+            }
+          }
+        }
+      }
+      const selected2 = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        const fix = rangeVerdicts.get(request.line);
+        if (fix?.diagnosticCode === request.diagnosticCode)
+          selected2.set(request.line, fix);
+      }
+      return [...selected2.values(), ...includeDocument && documentFix !== void 0 ? [documentFix] : []];
+    }
+    const occurrenceLine = typeof line === "number" ? line : void 0;
+    const selected = occurrenceLine === void 0 ? void 0 : byLine.get(occurrenceLine);
     let occurrenceFix;
-    if (selected !== void 0 && line !== void 0) {
-      if (!verifiedOccurrences.has(line)) {
-        if (verifiedOccurrences.size === 32)
-          verifiedOccurrences.delete(verifiedOccurrences.keys().next().value);
-        verifiedOccurrences.set(line, verify({ diagnosticCode: DiagnosticCodes.LegacyOptionalSuffix, title: "Use 'optional' instead of '?'", scope: "occurrence", edits: [selected.edit] }, line));
+    if (selected !== void 0 && occurrenceLine !== void 0 && (diagnosticCode === void 0 || selected.fix.diagnosticCode === diagnosticCode)) {
+      if (!verified.has(occurrenceLine)) {
+        if (verified.size === 32)
+          verified.delete(verified.keys().next().value);
+        verified.set(occurrenceLine, verify(selected.fix, selected.change));
       }
-      occurrenceFix = verifiedOccurrences.get(line);
+      occurrenceFix = verified.get(occurrenceLine);
     }
-    return [occurrenceFix, documentFix].filter((fix) => fix !== void 0);
+    return [occurrenceFix, includeDocument ? documentFix : void 0].filter((fix) => fix !== void 0);
   };
 }
-function verificationShape(parsed) {
-  return JSON.stringify([toSyntaxJson(parsed.value), parsed.triggerData.map((value) => toSyntaxJson(value))]);
+function verificationShape(parsed, changes = []) {
+  const replacements = new Map(changes.map((change) => [change.node, change.replacement]));
+  return JSON.stringify([parsed.value, parsed.triggerData], (key, value) => key === "location" ? void 0 : replacements.get(value) ?? value);
 }
 function applyQuickFixEdits(source, edits) {
   const parts = [];
@@ -4451,6 +4823,7 @@ export {
   productionDestinations,
   destinationHints,
   DiagnosticCodes,
+  isQuickFixDiagnostic,
   prepareQuickFixes,
   diagnosticCodes,
   isFileImportLine,
@@ -4460,4 +4833,4 @@ export {
   validateLines,
   validateEventContextPaths
 };
-//# sourceMappingURL=chunk-7WJEZ72S.js.map
+//# sourceMappingURL=chunk-GJX4NJYC.js.map