@cratis/screenplay-language 4.55.0 → 4.55.1

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

@@ -261,531 +261,50 @@ function nearestEnclosingLine(lines, fences, lineIndex, indent) {
   return void 0;
 }
 
-// event-analysis-source.ts
-function eventAnalysisSource(lines) {
-  let fenced = false;
-  return lines.map((line) => {
-    if (fenced) {
-      if (line.trim() === "```") fenced = false;
-      return line;
-    }
-    const text = withoutComment(line);
-    if (/^\s*```(?:[a-z]+)?\s*$/.test(text)) fenced = true;
-    return text.trimEnd();
-  });
-}
-
-// symbols.ts
-var conceptPattern = /^concept\s+(\w+)\s*:\s*(\w+)((?:\s+@\w+)*)\s*$/;
-var propertyPattern = /^\s*(@?[a-z_]\w*)\s+([\w.]+(?:\[\])?(?:\?|\s+optional)?)(\s+identifier)?\s*$/;
-var attributeReasonPattern = /^([a-z_]\w*)\s+reason\s+"((?:[^"\\]|\\.)*)"\s*$/;
-var readPattern = /^\s*reads\s+([A-Z]\w*)(?:\s+as\s+([a-z_]\w*))?(?:\s+by\s+([a-z_]\w*))?\s*$/;
-var commandReserved = ["authorize", "produces", "reads"];
-var authorizationContinuation = /^(?:(?:or|and)\s+)?[A-Za-z_(][\p{L}\p{Mn}\p{Nd}\p{Pc}\s()]*$/u;
-var eventReserved = clauseKeywords.filter((keyword) => !["id", "description", "documentation"].includes(keyword));
-var queryParameterPattern = /^\s*(?:by|filter)\s+([a-z_]\w*)\s+([\w.]+(?:\[\])?(?:\?|\s+optional)?)(?:\s+from\s+.+)?\s*$/;
-function propertyTypeReference(property) {
-  return property.typeReference ?? typeReferenceSymbol(property.type);
-}
-function propertiesIn(lines, body, reserved3) {
-  return body.map((index) => ({ index, match: lines[index].match(propertyPattern) })).filter((entry) => entry.match !== null).filter(({ match }) => match[1].startsWith("@") || match[1] === "as" || !reserved3.includes(match[1])).map(({ index, match }) => ({
-    name: match[1].replace(/^@/, ""),
-    type: match[2],
-    typeReference: typeReferenceSymbol(match[2]),
-    isIdentifier: match[3] !== void 0,
-    line: index
-  }));
-}
-function collectBody(lines, fences, start, indent) {
-  const body = [];
-  for (let index = start + 1; index < lines.length; index++) {
-    if (fences[index]) {
-      continue;
+// file-references.ts
+var fileReferenceKeyword = "file";
+var typeReferencePattern = /^[A-Za-z_]\w*(?:\[\])?(?:\?|\s+optional)?$/;
+var absolutePathPattern = /^(?:[/\\]|[A-Za-z]:[/\\]|~[/\\])/;
+function isAbsoluteFileReferencePath(path) {
+  return absolutePathPattern.test(path);
+}
+function withoutComment2(text) {
+  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 && current === "/" && text[index + 1] === "/") {
+      return text.slice(0, index);
     }
-    const line = lines[index];
-    if (line.trim().length === 0) continue;
-    if (indentOf(line) <= indent) break;
-    body.push(index);
   }
-  return body;
-}
-function directBody(lines, fences, start, indent) {
-  const body = collectBody(lines, fences, start, indent).filter((index) => !fences[index] && !/^\s*(?:\/\/|#)/.test(lines[index]));
-  if (!/^\s*command\b/.test(lines[start])) return body;
-  let blockIndent;
-  let authorization = false;
-  return body.filter((index) => {
-    const childIndent = indentOf(lines[index]);
-    const text = lines[index].trim();
-    if (blockIndent !== void 0 && childIndent > blockIndent && (!authorization || authorizationContinuation.test(text))) return false;
-    const property = text !== "validate csharp" && propertiesIn(lines, [index], commandReserved).length > 0;
-    const leaf = property || /^description(?:\s|$)/.test(text);
-    blockIndent = leaf ? void 0 : childIndent;
-    authorization = /^authorize(?:\s|$)/.test(text);
-    return true;
-  });
+  return text;
 }
-function scanDocument(lines) {
-  const symbols = {
-    imports: [],
-    concepts: [],
-    types: [],
-    policies: [],
-    events: [],
-    commands: [],
-    queries: [],
-    screens: [],
-    triggers: []
-  };
-  lines = eventAnalysisSource(lines);
+function fileReferenceOn(line, lineIndex) {
+  const indent = indentOf(line);
+  const content = withoutComment2(line.slice(indent)).trimEnd();
+  if (firstWord(content) !== fileReferenceKeyword) return void 0;
+  const afterKeyword = content.slice(fileReferenceKeyword.length);
+  const path = afterKeyword.trim();
+  if (path.length === 0 || typeReferencePattern.test(path)) return void 0;
+  const separatorLength = afterKeyword.length - afterKeyword.trimStart().length;
+  const startColumn = indent + fileReferenceKeyword.length + separatorLength + 1;
+  return { path, line: lineIndex, startColumn, endColumn: startColumn + path.length };
+}
+function fileReferences(lines) {
   const fences = fenceMap(lines);
-  const eventLines = lines;
-  const eventFences = fences;
-  const eventPropertyLines = lines.map((line) => line.replace(/\s*=(?!=|>).*/, ""));
+  const references = [];
   for (let index = 0; index < lines.length; index++) {
     if (fences[index]) continue;
-    const line = lines[index];
-    const trimmed = line.trim();
-    const indent = indentOf(line);
-    const importMatch = eventLines[index].trim().match(/^import\s+([\w.]+)\s*$/);
-    if (importMatch && indent === 0) {
-      const qualifiedName = importMatch[1];
-      const shortName = qualifiedName.split(".").pop() ?? qualifiedName;
-      symbols.imports.push({ qualifiedName, shortName, line: index });
-      continue;
-    }
-    const conceptMatch = trimmed.match(conceptPattern);
-    if (conceptMatch) {
-      const body = collectBody(lines, fences, index, indent).map((i) => lines[i].trim());
-      const attributeReasons = {};
-      for (const line2 of body) {
-        const reason = line2.match(attributeReasonPattern);
-        if (reason && attributeReasons[reason[1]] === void 0) {
-          attributeReasons[reason[1]] = reason[2];
-        }
-      }
-      const enumValues = conceptMatch[2] === "Enum" ? body.filter((line2) => !attributeReasonPattern.test(line2)) : [];
-      symbols.concepts.push({
-        name: conceptMatch[1],
-        primitive: conceptMatch[2],
-        attributes: conceptMatch[3].trim().split(/\s+/).filter(Boolean),
-        attributeReasons,
-        enumValues,
-        line: index
-      });
-      continue;
-    }
-    const typeMatch = trimmed.match(/^type\s+(\w+)\s*$/);
-    if (typeMatch) {
-      symbols.types.push({
-        name: typeMatch[1],
-        properties: propertiesIn(lines, collectBody(lines, fences, index, indent), clauseKeywords),
-        line: index
-      });
-      continue;
-    }
-    const policyMatch = trimmed.match(/^policy\s+(\w+)\s*$/);
-    if (policyMatch) {
-      const requires = collectBody(lines, fences, index, indent).filter((i) => !fences[i]).map((i) => lines[i].trim());
-      symbols.policies.push({ name: policyMatch[1], requires, line: index });
-      continue;
-    }
-    const eventMatch = eventLines[index].trim().match(/^(?:produces\s+)?event\s+(\w+)(?:\s+generation\s+(\d+))?\s*$/);
-    if (eventMatch) {
-      symbols.events.push({
-        name: eventMatch[1],
-        ...eventMatch[2] ? { generation: Number(eventMatch[2]) } : {},
-        inline: trimmed.startsWith("produces "),
-        properties: propertiesIn(
-          trimmed.startsWith("produces ") ? eventPropertyLines : eventLines,
-          directBody(eventLines, eventFences, index, indent),
-          eventReserved
-        ),
-        line: index
-      });
-      continue;
-    }
-    const commandMatch = eventLines[index].trim().match(/^command\s+(\w+)\s*$/);
-    if (commandMatch) {
-      const body = directBody(lines, fences, index, indent);
-      const productionHeaders = body.filter((line2) => /^\s*produces\b/.test(lines[line2]));
-      symbols.commands.push({
-        name: commandMatch[1],
-        properties: propertiesIn(lines, body.filter((line2) => lines[line2].trim() !== "validate csharp"), commandReserved),
-        productionHeaders,
-        produces: productionHeaders.flatMap((line2) => {
-          const header10 = eventLines[line2].trim();
-          const inline = /^produces\s+event\b/.test(header10);
-          const conditional2 = /^produces\s+when\b/.test(header10);
-          const eventLine = conditional2 ? directBody(eventLines, eventFences, line2, indentOf(eventLines[line2]))[0] : line2;
-          if (eventLine === void 0) return [];
-          const name = conditional2 ? eventLines[eventLine].trim() : header10.match(inline ? /^produces\s+event\s+([A-Za-z_]\w*)(?:\s+generation\s+\d+)?\s*$/ : /^produces\s+([A-Z]\w*)\s*$/)?.[1];
-          if (name === void 0 || !/^[A-Za-z_]\w*$/.test(name)) return [];
-          const children = directBody(eventLines, eventFences, eventLine, indentOf(eventLines[eventLine]));
-          const targets = children.map((index2) => eventLines[index2].trim().match(/^for(?:\s+(.*))?$/)).filter((match) => match !== null);
-          const target = targets.length === 0 ? void 0 : targets.length === 1 ? targets[0][1] ?? "" : "";
-          const mappings = children.flatMap((index2) => {
-            const match = eventLines[index2].trim().match(inline ? /^(@?[a-z_]\w*)\s+[\w.]+(?:\[\])?(?:\?|\s+optional)?\s*=(?!=|>)\s*(.+)$/ : /^(@?[\w.]+)\s*=(?!=|>)\s*(.+)$/);
-            return match === null ? [] : [{ name: match[1].replace(/^@/, ""), source: match[2], line: index2 }];
-          });
-          return [{ name, inline, conditional: conditional2, line: line2, target, mappings }];
-        }),
-        reads: body.filter((line2) => !fences[line2]).map((line2) => ({ line: line2, match: lines[line2].match(readPattern) })).filter((entry) => entry.match !== null).map(({ line: line2, match }) => ({
-          view: match[1],
-          ...match[2] ? { alias: match[2] } : {},
-          ...match[3] ? { by: match[3] } : {},
-          line: line2
-        })),
-        line: index
-      });
-      continue;
-    }
-    const queryMatch = trimmed.match(/^query\s+(\w+)\s*=>\s*(?:observable\s+)?([\w.]+(?:\[\])?(?:\?|\s+optional)?)\s*$/);
-    if (queryMatch) {
-      const parameters = collectBody(lines, fences, index, indent).map((i) => ({ index: i, match: lines[i].match(queryParameterPattern) })).filter(
-        (entry) => entry.match !== null
-      ).map(({ index: line2, match }) => ({
-        name: match[1],
-        type: match[2],
-        typeReference: typeReferenceSymbol(match[2]),
-        isIdentifier: false,
-        line: line2
-      }));
-      symbols.queries.push({
-        name: queryMatch[1],
-        returnType: queryMatch[2],
-        returnTypeReference: typeReferenceSymbol(queryMatch[2]),
-        parameters,
-        line: index
-      });
-      continue;
-    }
-    const screenMatch = trimmed.match(/^screen\s+(\w+)\s*$/);
-    if (screenMatch) {
-      symbols.screens.push({ name: screenMatch[1], line: index });
-      continue;
-    }
-    const triggerMatch = trimmed.match(/^trigger\s+(\w+)\s*$/);
-    if (triggerMatch && indent === 0) {
-      symbols.triggers.push({ name: triggerMatch[1], line: index });
-    }
+    const reference = fileReferenceOn(lines[index], index);
+    if (reference) references.push(reference);
   }
-  return symbols;
-}
-function mergeSymbols(...documents) {
-  return {
-    imports: documents.flatMap((document) => document.imports),
-    concepts: documents.flatMap((document) => document.concepts),
-    types: documents.flatMap((document) => document.types),
-    policies: documents.flatMap((document) => document.policies),
-    events: documents.flatMap((document) => document.events),
-    commands: documents.flatMap((document) => document.commands),
-    queries: documents.flatMap((document) => document.queries),
-    screens: documents.flatMap((document) => document.screens),
-    triggers: documents.flatMap((document) => document.triggers)
-  };
-}
-function knownEventNames(symbols) {
-  return [
-    ...symbols.events.map((event) => event.name),
-    ...symbols.imports.map((imported) => imported.shortName)
-  ];
-}
-var builtInTriggerNames = ["Startup", "Shutdown"];
-function knownTriggerNames(symbols) {
-  return [
-    ...knownEventNames(symbols),
-    ...symbols.triggers.map((trigger) => trigger.name),
-    ...builtInTriggerNames
-  ];
-}
-function knownTypeNames(symbols, primitives) {
-  return [
-    ...primitives,
-    ...symbols.concepts.map((concept) => concept.name),
-    ...symbols.types.map((type) => type.name),
-    ...symbols.imports.map((imported) => imported.shortName)
-  ];
-}
-
-// event-context-catalog.ts
-var eventContextRootType = "EventContext";
-var eventContextTypes = {
-  "EventContext": [
-    { name: "eventType", type: "EventType", kind: "composite", description: "The type of the event - its identifier, generation and whether it is a tombstone." },
-    { name: "eventSourceType", type: "EventSourceType", kind: "value", description: "The type of the event source the event was appended to." },
-    { name: "eventSourceId", type: "EventSourceId", kind: "value", description: "The identifier of the event source the event was appended to - the value $eventSourceId resolves." },
-    { name: "eventStreamType", type: "EventStreamType", kind: "value", description: "The type of the event stream the event belongs to." },
-    { name: "eventStreamId", type: "EventStreamId", kind: "value", description: "The identifier of the event stream the event belongs to." },
-    { name: "sequenceNumber", type: "EventSequenceNumber", kind: "value", description: "The position of the event in its event sequence." },
-    { name: "occurred", type: "DateTimeOffset", kind: "value", description: "When the event occurred - the time it was appended unless one was given." },
-    { name: "eventStore", type: "EventStoreName", kind: "value", description: "The name of the event store the event belongs to." },
-    { name: "namespace", type: "EventStoreNamespaceName", kind: "value", description: "The namespace within the event store the event belongs to." },
-    { name: "correlationId", type: "CorrelationId", kind: "value", description: "The correlation identifier the event was appended with." },
-    { name: "causation", type: "IEnumerable<Causation>", kind: "collection", description: "The chain of causes that led to the event - a collection, not addressable below." },
-    { name: "causedBy", type: "Identity", kind: "composite", description: "The identity that caused the event." },
-    { name: "tags", type: "IEnumerable<Tag>", kind: "collection", description: "The tags the event was appended with - a collection, not addressable below." },
-    { name: "hash", type: "EventHash", kind: "value", description: "The hash of the event content." },
-    { name: "observationState", type: "EventObservationState", kind: "value", description: "Whether the observer sees the event for the first time or again on replay - differs between live processing and replay." },
-    { name: "subject", type: "Subject", kind: "value", description: "The compliance subject the event is about - the event source identifier unless one was given." },
-    { name: "subjectIsEventSourceId", type: "bool", kind: "value", description: "Whether the subject is the event source identifier." }
-  ],
-  "EventType": [
-    { name: "id", type: "EventTypeId", kind: "value", description: "The identifier of the event type." },
-    { name: "generation", type: "EventTypeGeneration", kind: "value", description: "The generation of the event type." },
-    { name: "tombstone", type: "bool", kind: "value", description: "Whether the event is a tombstone event." }
-  ],
-  "EventSourceType": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventSourceId": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventStreamType": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventStreamId": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventSequenceNumber": [
-    { name: "value", type: "ulong", kind: "value", description: "The underlying ulong value." }
-  ],
-  "DateTimeOffset": [
-    { name: "Week", type: "int", kind: "function", description: "The ISO 8601 week of the year the value falls in." }
-  ],
-  "EventStoreName": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventStoreNamespaceName": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "CorrelationId": [
-    { name: "value", type: "Guid", kind: "value", description: "The underlying Guid value." }
-  ],
-  "Identity": [
-    { name: "subject", type: "string", kind: "value", description: "The subject identifier of the identity." },
-    { name: "name", type: "string", kind: "value", description: "The display name of the identity." },
-    { name: "userName", type: "string", kind: "value", description: "The user name of the identity." },
-    { name: "onBehalfOf", type: "Identity", kind: "composite", description: "The identity this identity acted on behalf of, if any - an identity with the same members." }
-  ],
-  "EventHash": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "Subject": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventTypeId": [
-    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
-  ],
-  "EventTypeGeneration": [
-    { name: "value", type: "uint", kind: "value", description: "The underlying uint value." }
-  ]
-};
-var eventContextPaths = [
-  { path: "eventType", name: "eventType", type: "EventType", kind: "composite", description: "The type of the event - its identifier, generation and whether it is a tombstone." },
-  { path: "eventType.id", name: "id", type: "EventTypeId", kind: "value", description: "The identifier of the event type." },
-  { path: "eventType.id.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "eventType.generation", name: "generation", type: "EventTypeGeneration", kind: "value", description: "The generation of the event type." },
-  { path: "eventType.generation.value", name: "value", type: "uint", kind: "value", description: "The underlying uint value." },
-  { path: "eventType.tombstone", name: "tombstone", type: "bool", kind: "value", description: "Whether the event is a tombstone event." },
-  { path: "eventSourceType", name: "eventSourceType", type: "EventSourceType", kind: "value", description: "The type of the event source the event was appended to." },
-  { path: "eventSourceType.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "eventSourceId", name: "eventSourceId", type: "EventSourceId", kind: "value", description: "The identifier of the event source the event was appended to - the value $eventSourceId resolves." },
-  { path: "eventSourceId.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "eventStreamType", name: "eventStreamType", type: "EventStreamType", kind: "value", description: "The type of the event stream the event belongs to." },
-  { path: "eventStreamType.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "eventStreamId", name: "eventStreamId", type: "EventStreamId", kind: "value", description: "The identifier of the event stream the event belongs to." },
-  { path: "eventStreamId.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "sequenceNumber", name: "sequenceNumber", type: "EventSequenceNumber", kind: "value", description: "The position of the event in its event sequence." },
-  { path: "sequenceNumber.value", name: "value", type: "ulong", kind: "value", description: "The underlying ulong value." },
-  { path: "occurred", name: "occurred", type: "DateTimeOffset", kind: "value", description: "When the event occurred - the time it was appended unless one was given." },
-  { path: "occurred.Week", name: "Week", type: "int", kind: "function", description: "The ISO 8601 week of the year the value falls in." },
-  { path: "eventStore", name: "eventStore", type: "EventStoreName", kind: "value", description: "The name of the event store the event belongs to." },
-  { path: "eventStore.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "namespace", name: "namespace", type: "EventStoreNamespaceName", kind: "value", description: "The namespace within the event store the event belongs to." },
-  { path: "namespace.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "correlationId", name: "correlationId", type: "CorrelationId", kind: "value", description: "The correlation identifier the event was appended with." },
-  { path: "correlationId.value", name: "value", type: "Guid", kind: "value", description: "The underlying Guid value." },
-  { path: "causation", name: "causation", type: "IEnumerable<Causation>", kind: "collection", description: "The chain of causes that led to the event - a collection, not addressable below." },
-  { path: "causedBy", name: "causedBy", type: "Identity", kind: "composite", description: "The identity that caused the event." },
-  { path: "causedBy.subject", name: "subject", type: "string", kind: "value", description: "The subject identifier of the identity." },
-  { path: "causedBy.name", name: "name", type: "string", kind: "value", description: "The display name of the identity." },
-  { path: "causedBy.userName", name: "userName", type: "string", kind: "value", description: "The user name of the identity." },
-  { path: "causedBy.onBehalfOf", name: "onBehalfOf", type: "Identity", kind: "composite", description: "The identity this identity acted on behalf of, if any - an identity with the same members." },
-  { path: "tags", name: "tags", type: "IEnumerable<Tag>", kind: "collection", description: "The tags the event was appended with - a collection, not addressable below." },
-  { path: "hash", name: "hash", type: "EventHash", kind: "value", description: "The hash of the event content." },
-  { path: "hash.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "observationState", name: "observationState", type: "EventObservationState", kind: "value", description: "Whether the observer sees the event for the first time or again on replay - differs between live processing and replay." },
-  { path: "subject", name: "subject", type: "Subject", kind: "value", description: "The compliance subject the event is about - the event source identifier unless one was given." },
-  { path: "subject.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
-  { path: "subjectIsEventSourceId", name: "subjectIsEventSourceId", type: "bool", kind: "value", description: "Whether the subject is the event source identifier." }
-];
-
-// event-context.ts
-function namesEventContextMember(member, segment) {
-  if (member.kind === "function") {
-    return segment === member.name || segment === `${member.name}()`;
-  }
-  const declared = member.name[0].toUpperCase() + member.name.slice(1);
-  return segment === declared || segment.length > 0 && segment[0].toUpperCase() + segment.slice(1) === declared;
-}
-var eventContextMembers = eventContextTypes[eventContextRootType];
-function eventContextMembersAfter(segments) {
-  let members = eventContextMembers;
-  for (const segment of segments) {
-    const member = members.find((candidate) => namesEventContextMember(candidate, segment));
-    if (!member || member.kind === "collection" || member.kind === "function") {
-      return void 0;
-    }
-    members = eventContextTypes[member.type] ?? [];
-  }
-  return members;
-}
-function eventContextMemberAt(segments) {
-  if (segments.length === 0) {
-    return void 0;
-  }
-  const members = eventContextMembersAfter(segments.slice(0, -1));
-  return members?.find((member) => namesEventContextMember(member, segments[segments.length - 1]));
-}
-function resolveEventContextPath(path) {
-  let current;
-  let expected = eventContextMembers;
-  for (const segment of path.split(".")) {
-    if (segment.length === 0) {
-      return { status: "missing", member: current, expected };
-    }
-    if (current?.kind === "collection") {
-      return { status: "belowCollection", member: current, segment, expected: [] };
-    }
-    const next = expected.find((member) => namesEventContextMember(member, segment));
-    if (!next) {
-      return { status: current ? "unknownSubPath" : "unknownMember", member: current, segment, expected };
-    }
-    current = next;
-    expected = next.kind === "function" ? [] : eventContextTypes[next.type] ?? [];
-  }
-  return { status: "known", member: current, expected: [] };
-}
-function describeEventContext() {
-  return [
-    "**$eventContext**",
-    "",
-    "Metadata about the event being projected. Paths are checked against the event-context catalog; `causation` and `tags` are collections and cannot be addressed below.",
-    "",
-    "**Members:**",
-    ...eventContextMembers.map((member) => `- \`${member.name}\` (${member.type}) - ${member.description}`)
-  ].join("\n");
-}
-function describeEventContextMember(path, member) {
-  const below = member.kind === "collection" || member.kind === "function" ? [] : eventContextTypes[member.type] ?? [];
-  const lines = [`**$eventContext.${path}**: \`${member.type}\``, "", member.description];
-  if (below.length > 0) {
-    lines.push("", `**Members:** ${below.map((child) => `\`${child.name}\``).join(", ")}`);
-  }
-  return lines.join("\n");
-}
-
-// production-destinations.ts
-function productionDestinations(command) {
-  const identifiers = command.properties.filter((property) => property.isIdentifier && !propertyTypeReference(property).isOptional && !propertyTypeReference(property).isCollection);
-  const identifier = identifiers.length === 1 ? identifiers[0].name : void 0;
-  const productions = command.produces ?? [];
-  const mixed = productions.some((production) => production.target !== void 0 && production.target !== identifier) || productions.some((production) => production.inline && production.target === void 0) && productions.some((production) => !production.inline && production.target === void 0);
-  return { identifier, mixed };
-}
-function destinationHints(lines) {
-  const source = eventAnalysisSource(lines);
-  return scanDocument(source).commands.flatMap((command) => {
-    const { identifier, mixed } = productionDestinations(command);
-    if (mixed || command.productionHeaders?.length !== command.produces?.length) return [];
-    const hasPromotedDestination = command.produces?.some((sibling) => sibling.target !== void 0 || sibling.inline);
-    return (command.produces ?? []).flatMap((production) => {
-      if (production.target !== void 0 || production.inline && (identifier === void 0 || /\bgeneration\b/.test(source[production.line]))) return [];
-      if (!production.inline && hasPromotedDestination) return [];
-      return [{ line: production.line, column: source[production.line].length + 1, label: production.inline ? `for ${identifier}` : "for <new event source>" }];
-    });
-  });
-}
-
-// diagnostic-codes.ts
-var diagnosticCodes = {
-  eventSourceIdInPayload: "PLAY0469",
-  explicitProducesTargetsRequired: "PLAY0470",
-  redundantEventId: "PLAY0471",
-  invalidEventId: "PLAY0472",
-  inlineEventCollision: "PLAY0473",
-  inlineEventOutsideCommand: "PLAY0474",
-  inlineEventGeneration: "PLAY0475",
-  reservedProductionMetadata: "PLAY0476",
-  invalidEventDocumentation: "PLAY0477",
-  tabIndentation: "PLAY0006",
-  unknownPrimitiveType: "PLAY0008",
-  unknownSliceType: "PLAY0028",
-  duplicateCommandIdentifier: "PLAY0036",
-  unknownContextPath: "PLAY0153",
-  unknownContextCausedByProperty: "PLAY0154",
-  unknownContextIdentityProperty: "PLAY0155",
-  unclosedCodeBlock: "PLAY0164",
-  unknownType: "PLAY0165",
-  unknownEvent: "PLAY0166",
-  unknownPolicy: "PLAY0167",
-  duplicateDeclaration: "PLAY0168",
-  unknownEventContextMember: "PLAY0295",
-  unknownEventContextPath: "PLAY0296",
-  eventContextPathBelowCollection: "PLAY0297",
-  missingEventContextPath: "PLAY0298",
-  unresolvedDynamicKeySource: "PLAY0299",
-  invalidFileImport: "PLAY0454",
-  omittedProductionDestination: "PLAY0478",
-  legacyOptionalSuffix: "PLAY0479",
-  invalidOptionalModifierOrder: "PLAY0480",
-  optionalReadsNotSupported: "PLAY0481"
-};
-
-// file-imports.ts
-var fileImportPattern = /^import(\s+)"([^"\\]+)"\s*(?:\/\/.*)?$/;
-var quotedImportPattern = /^import\s+"/;
-function isFileImportLine(line) {
-  return quotedImportPattern.test(line.trim());
-}
-function fileImportOn(line, lineIndex) {
-  const indent = indentOf(line);
-  const match = line.slice(indent).match(fileImportPattern);
-  if (!match) return void 0;
-  const startColumn = indent + "import".length + match[1].length + 2;
-  return { pattern: match[2], line: lineIndex, startColumn, endColumn: startColumn + match[2].length };
-}
-function fileImports(lines) {
-  const fences = fenceMap(lines);
-  const found = [];
-  for (let index = 0; index < lines.length; index++) {
-    if (fences[index]) continue;
-    const fileImport = fileImportOn(lines[index], index);
-    if (fileImport) found.push(fileImport);
-  }
-  return found;
-}
-var folderOf = (path) => path.split("/").slice(0, -1);
-function relativeTo(from, path) {
-  const segments = path.split("/");
-  let common = 0;
-  while (common < from.length && common < segments.length - 1 && from[common] === segments[common]) common++;
-  return [...from.slice(common).map(() => ".."), ...segments.slice(common)].join("/");
-}
-function importablePaths(documentPath, files) {
-  const from = folderOf(documentPath);
-  const paths = /* @__PURE__ */ new Set();
-  for (const file of files.filter((candidate) => candidate !== documentPath && candidate.toLowerCase().endsWith(".play"))) {
-    const relative = relativeTo(from, file);
-    const folders = folderOf(relative);
-    paths.add(relative);
-    paths.add([...folders, "*.play"].join("/"));
-    for (let depth = 0; depth <= folders.length; depth++) {
-      paths.add([...folders.slice(0, depth), "**", "*.play"].join("/"));
-    }
-  }
-  return [...paths].sort();
+  return references;
 }
 
 // ../../Compiler/dist/Diagnostics/DiagnosticCodes.js
@@ -1221,11 +740,11 @@ function keep(context, line, existing, owner, description) {
 }
 
 // ../../Compiler/dist/Parsing/FileImportParser.js
-var fileImportPattern2 = pattern('^import\\s+"([^"\\\\]+)"$');
+var fileImportPattern = pattern('^import\\s+"([^"\\\\]+)"$');
 var quotedPattern = pattern('^import\\s+"');
 var isFileImport = (content) => quotedPattern.test(content);
 function tryParseFileImport(line) {
-  const match = fileImportPattern2.exec(line.content);
+  const match = fileImportPattern.exec(line.content);
   return match === null ? void 0 : { kind: "FileImportSyntax", pattern: match[1], location: locationOf(line) };
 }
 function parseFileImport(context, line, imports) {
@@ -1560,6 +1079,9 @@ function parseLiteral(text, location) {
   return void 0;
 }
 
+// ../../Compiler/dist/Text/ReservedWords.js
+var eventBodyReservedWords = ["tag"];
+
 // ../../Compiler/dist/Parsing/EventMetadataParser.js
 var idPattern = pattern(`^id\\s+"(${stringBodyPattern})"$`);
 var EventMetadataParser = class {
@@ -1608,16 +1130,16 @@ var EventMetadataParser = class {
 };
 
 // ../../Compiler/dist/Parsing/FileReferences.js
-var typeReferencePattern = pattern("^[A-Za-z_]\\w*(?:\\[\\])?(?:\\?|\\s+optional)?$");
+var typeReferencePattern2 = pattern("^[A-Za-z_]\\w*(?:\\[\\])?(?:\\?|\\s+optional)?$");
 var pathOf = (line) => firstWord2(line.content) === "file" ? line.content.substring("file".length).trim() : "";
 var isFileDirective = (line) => pathOf(line).length > 0;
-var isFileDirectiveAmongProperties = (line) => isFileDirective(line) && !typeReferencePattern.test(pathOf(line));
+var isFileDirectiveAmongProperties = (line) => isFileDirective(line) && !typeReferencePattern2.test(pathOf(line));
 
 // ../../Compiler/dist/Parsing/PropertyLineParser.js
-var propertyPattern2 = pattern("^(@?[a-z_]\\w*)\\s+([\\w.]+(?:\\[\\])?(?:\\?|\\s+optional)?)(?:\\s+(identifier))?$");
+var propertyPattern = pattern("^(@?[a-z_]\\w*)\\s+([\\w.]+(?:\\[\\])?(?:\\?|\\s+optional)?)(?:\\s+(identifier))?$");
 var reversedModifiers = pattern("^@?[a-z_]\\w*\\s+[\\w.]+(?:\\[\\])?\\s+identifier\\s+optional(?:\\s*=.*)?$");
 function tryParseProperty(line) {
-  const match = propertyPattern2.exec(line.content);
+  const match = propertyPattern.exec(line.content);
   if (match === null) {
     return void 0;
   }
@@ -1733,7 +1255,7 @@ function parseEvent(context, header10) {
     if (isFileDirectiveAmongProperties(line)) {
       continue;
     }
-    if (firstWord2(line.content) === "tag") {
+    if (eventBodyReservedWords.includes(firstWord2(line.content))) {
       const tag = parseTag(context, line);
       if (tag !== void 0) {
         tags.push(tag);
@@ -3638,9 +3160,9 @@ var ParserContext = class {
 // ../../Compiler/dist/Parsing/ScreenplayParser.js
 var domainPattern = pattern("^domain\\s+([A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*)$");
 var importPattern = pattern("^import\\s+([\\w.]+)$");
-var conceptPattern2 = pattern("^concept\\s+(\\w+)\\s*:\\s*(\\w+)((?:\\s+@\\w+)*)$");
+var conceptPattern = pattern("^concept\\s+(\\w+)\\s*:\\s*(\\w+)((?:\\s+@\\w+)*)$");
 var enumValuePattern = pattern("^@?[a-z_]\\w*$");
-var attributeReasonPattern2 = pattern(`^([a-z_]\\w*)\\s+reason\\s+"(${stringBodyPattern})"$`);
+var attributeReasonPattern = pattern(`^([a-z_]\\w*)\\s+reason\\s+"(${stringBodyPattern})"$`);
 var personaPattern = pattern("^persona\\s+([A-Za-z_]\\w*)$");
 var personaPolicyPattern = pattern("^policy\\s+([A-Za-z_]\\w*)$");
 var tabIndentPattern = /^[ ]*\t/;
@@ -3789,7 +3311,7 @@ function warnOnTabIndentation(context, lines) {
   }
 }
 function parseConcept(context, line) {
-  const match = conceptPattern2.exec(line.content);
+  const match = conceptPattern.exec(line.content);
   if (match === null) {
     context.error(DiagnosticCodes.InvalidConceptDeclaration, `Invalid concept declaration '${line.content}' - expected 'concept <Name> : <Type>'`, locationOf(line));
     context.skipBlock(line.indent);
@@ -3808,7 +3330,7 @@ function parseConcept(context, line) {
   const values = [];
   for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
     context.reader.takeSignificant();
-    const reason = attributeReasonPattern2.exec(child.content);
+    const reason = attributeReasonPattern.exec(child.content);
     if (isFileDirective(child)) {
       continue;
     } else if (firstWord2(child.content) === "validate") {
@@ -4094,258 +3616,789 @@ var ScreenplaySyntaxWalker = class {
   visitTriggerSource(syntax) {
     this.visitNode(syntax);
   }
-  visitScreen(syntax) {
-    this.visitNode(syntax);
-    syntax.directives.forEach((node) => this.visitScreenDirective(node));
+  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;
+    }
+  }
+  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);
+  }
+};
+
+// ../../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;
+  return /^[\p{L}\p{Mn}\p{Nd}\p{Pc}.]+(?:\[\])?\?/u.exec(line.slice(diagnostic.location.column - 1))?.[0].length ?? 0;
+}
+function prepareQuickFixes(source, options = {}) {
+  const original = parseForAuthoring(source, void 0, options.placement);
+  if (!original.success)
+    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 verified = /* @__PURE__ */ new Map();
+  let rangeVerdicts;
+  let documentChecked = false;
+  let documentFix;
+  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);
+    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, 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;
+    }
+    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 && 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 = verified.get(occurrenceLine);
+    }
+    return [occurrenceFix, includeDocument ? documentFix : void 0].filter((fix) => fix !== void 0);
+  };
+}
+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 = [];
+  let end = 0;
+  for (const edit of edits) {
+    if (edit.start < end || edit.start < 0 || edit.length < 0 || edit.start + edit.length > source.length)
+      return void 0;
+    parts.push(source.slice(end, edit.start), edit.text);
+    end = edit.start + edit.length;
+  }
+  parts.push(source.slice(end));
+  return parts.join("");
+}
+
+// event-analysis-source.ts
+function eventAnalysisSource(lines) {
+  let fenced = false;
+  return lines.map((line) => {
+    if (fenced) {
+      if (line.trim() === "```") fenced = false;
+      return line;
+    }
+    const text = withoutComment(line);
+    if (/^\s*```(?:[a-z]+)?\s*$/.test(text)) fenced = true;
+    return text.trimEnd();
+  });
+}
+
+// symbols.ts
+var conceptPattern2 = /^concept\s+(\w+)\s*:\s*(\w+)((?:\s+@\w+)*)\s*$/;
+var propertyPattern2 = /^\s*(@?[a-z_]\w*)\s+([\w.]+(?:\[\])?(?:\?|\s+optional)?)(\s+identifier)?\s*$/;
+var attributeReasonPattern2 = /^([a-z_]\w*)\s+reason\s+"((?:[^"\\]|\\.)*)"\s*$/;
+var readPattern = /^\s*reads\s+([A-Z]\w*)(?:\s+as\s+([a-z_]\w*))?(?:\s+by\s+([a-z_]\w*))?\s*$/;
+var commandReserved = ["authorize", "produces", "reads"];
+var authorizationContinuation = /^(?:(?:or|and)\s+)?[A-Za-z_(][\p{L}\p{Mn}\p{Nd}\p{Pc}\s()]*$/u;
+var eventReserved = eventBodyReservedWords;
+var inlineEventReserved = ["tag", "for", "generation", "origin", "namespace", "sequence", "correlation", "causation", "causedBy", "occurred"];
+var queryParameterPattern = /^\s*(?:by|filter)\s+([a-z_]\w*)\s+([\w.]+(?:\[\])?(?:\?|\s+optional)?)(?:\s+from\s+.+)?\s*$/;
+function propertyTypeReference(property) {
+  return property.typeReference ?? typeReferenceSymbol(property.type);
+}
+function propertiesIn(lines, body, reserved3) {
+  return body.map((index) => ({ index, match: lines[index].match(propertyPattern2) })).filter((entry) => entry.match !== null).filter(({ match }) => match[1].startsWith("@") || match[1] === "as" || !reserved3.includes(match[1])).map(({ index, match }) => ({
+    name: match[1].replace(/^@/, ""),
+    type: match[2],
+    typeReference: typeReferenceSymbol(match[2]),
+    isIdentifier: match[3] !== void 0,
+    line: index
+  }));
+}
+function collectBody(lines, fences, start, indent) {
+  const body = [];
+  for (let index = start + 1; index < lines.length; index++) {
+    if (fences[index]) {
+      continue;
+    }
+    const line = lines[index];
+    if (line.trim().length === 0) continue;
+    if (indentOf(line) <= indent) break;
+    body.push(index);
   }
-  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 body;
+}
+function directBody(lines, fences, start, indent) {
+  const body = collectBody(lines, fences, start, indent).filter((index) => !fences[index] && !/^\s*(?:\/\/|#)/.test(lines[index]));
+  if (!/^\s*command\b/.test(lines[start])) return body;
+  let blockIndent;
+  let authorization = false;
+  return body.filter((index) => {
+    const childIndent = indentOf(lines[index]);
+    const text = lines[index].trim();
+    if (blockIndent !== void 0 && childIndent > blockIndent && (!authorization || authorizationContinuation.test(text))) return false;
+    const property = text !== "validate csharp" && propertiesIn(lines, [index], commandReserved).length > 0;
+    const leaf = property || /^description(?:\s|$)/.test(text);
+    blockIndent = leaf ? void 0 : childIndent;
+    authorization = /^authorize(?:\s|$)/.test(text);
+    return true;
+  });
+}
+function scanDocument(lines) {
+  const symbols = {
+    imports: [],
+    concepts: [],
+    types: [],
+    policies: [],
+    events: [],
+    commands: [],
+    queries: [],
+    screens: [],
+    triggers: []
+  };
+  lines = eventAnalysisSource(lines);
+  const fences = fenceMap(lines);
+  const eventLines = lines;
+  const eventFences = fences;
+  const eventPropertyLines = lines.map((line) => line.replace(/\s*=(?!=|>).*/, ""));
+  for (let index = 0; index < lines.length; index++) {
+    if (fences[index]) continue;
+    const line = lines[index];
+    const trimmed = line.trim();
+    const indent = indentOf(line);
+    const importMatch = eventLines[index].trim().match(/^import\s+([\w.]+)\s*$/);
+    if (importMatch && indent === 0) {
+      const qualifiedName = importMatch[1];
+      const shortName = qualifiedName.split(".").pop() ?? qualifiedName;
+      symbols.imports.push({ qualifiedName, shortName, line: index });
+      continue;
+    }
+    const conceptMatch = trimmed.match(conceptPattern2);
+    if (conceptMatch) {
+      const body = collectBody(lines, fences, index, indent).map((i) => lines[i].trim());
+      const attributeReasons = {};
+      for (const line2 of body) {
+        const reason = line2.match(attributeReasonPattern2);
+        if (reason && attributeReasons[reason[1]] === void 0) {
+          attributeReasons[reason[1]] = reason[2];
+        }
+      }
+      const enumValues = conceptMatch[2] === "Enum" ? body.filter((line2) => !attributeReasonPattern2.test(line2)) : [];
+      symbols.concepts.push({
+        name: conceptMatch[1],
+        primitive: conceptMatch[2],
+        attributes: conceptMatch[3].trim().split(/\s+/).filter(Boolean),
+        attributeReasons,
+        enumValues,
+        line: index
+      });
+      continue;
+    }
+    const typeMatch = trimmed.match(/^type\s+(\w+)\s*$/);
+    if (typeMatch) {
+      symbols.types.push({
+        name: typeMatch[1],
+        properties: propertiesIn(lines, collectBody(lines, fences, index, indent), clauseKeywords),
+        line: index
+      });
+      continue;
+    }
+    const policyMatch = trimmed.match(/^policy\s+(\w+)\s*$/);
+    if (policyMatch) {
+      const requires = collectBody(lines, fences, index, indent).filter((i) => !fences[i]).map((i) => lines[i].trim());
+      symbols.policies.push({ name: policyMatch[1], requires, line: index });
+      continue;
+    }
+    const eventMatch = eventLines[index].trim().match(/^(?:produces\s+)?event\s+(\w+)(?:\s+generation\s+(\d+))?\s*$/);
+    if (eventMatch) {
+      const inline = trimmed.startsWith("produces ");
+      const body = directBody(eventLines, eventFences, index, indent);
+      const propertyBody = inline ? body : body.filter((line2) => fileReferenceOn(eventLines[line2], line2) === void 0);
+      symbols.events.push({
+        name: eventMatch[1],
+        ...eventMatch[2] ? { generation: Number(eventMatch[2]) } : {},
+        inline,
+        properties: propertiesIn(
+          inline ? eventPropertyLines : eventLines,
+          propertyBody,
+          inline ? inlineEventReserved : eventReserved
+        ),
+        line: index
+      });
+      continue;
+    }
+    const commandMatch = eventLines[index].trim().match(/^command\s+(\w+)\s*$/);
+    if (commandMatch) {
+      const body = directBody(lines, fences, index, indent);
+      const productionHeaders = body.filter((line2) => /^\s*produces\b/.test(lines[line2]));
+      symbols.commands.push({
+        name: commandMatch[1],
+        properties: propertiesIn(lines, body.filter((line2) => lines[line2].trim() !== "validate csharp"), commandReserved),
+        productionHeaders,
+        produces: productionHeaders.flatMap((line2) => {
+          const header10 = eventLines[line2].trim();
+          const inline = /^produces\s+event\b/.test(header10);
+          const conditional2 = /^produces\s+when\b/.test(header10);
+          const eventLine = conditional2 ? directBody(eventLines, eventFences, line2, indentOf(eventLines[line2]))[0] : line2;
+          if (eventLine === void 0) return [];
+          const name = conditional2 ? eventLines[eventLine].trim() : header10.match(inline ? /^produces\s+event\s+([A-Za-z_]\w*)(?:\s+generation\s+\d+)?\s*$/ : /^produces\s+([A-Z]\w*)\s*$/)?.[1];
+          if (name === void 0 || !/^[A-Za-z_]\w*$/.test(name)) return [];
+          const children = directBody(eventLines, eventFences, eventLine, indentOf(eventLines[eventLine]));
+          const targets = children.map((index2) => eventLines[index2].trim().match(/^for(?:\s+(.*))?$/)).filter((match) => match !== null);
+          const target = targets.length === 0 ? void 0 : targets.length === 1 ? targets[0][1] ?? "" : "";
+          const mappings = children.flatMap((index2) => {
+            const match = eventLines[index2].trim().match(inline ? /^(@?[a-z_]\w*)\s+[\w.]+(?:\[\])?(?:\?|\s+optional)?\s*=(?!=|>)\s*(.+)$/ : /^(@?[\w.]+)\s*=(?!=|>)\s*(.+)$/);
+            return match === null ? [] : [{ name: match[1].replace(/^@/, ""), source: match[2], line: index2 }];
+          });
+          return [{ name, inline, conditional: conditional2, line: line2, target, mappings }];
+        }),
+        reads: body.filter((line2) => !fences[line2]).map((line2) => ({ line: line2, match: lines[line2].match(readPattern) })).filter((entry) => entry.match !== null).map(({ line: line2, match }) => ({
+          view: match[1],
+          ...match[2] ? { alias: match[2] } : {},
+          ...match[3] ? { by: match[3] } : {},
+          line: line2
+        })),
+        line: index
+      });
+      continue;
+    }
+    const queryMatch = trimmed.match(/^query\s+(\w+)\s*=>\s*(?:observable\s+)?([\w.]+(?:\[\])?(?:\?|\s+optional)?)\s*$/);
+    if (queryMatch) {
+      const parameters = collectBody(lines, fences, index, indent).map((i) => ({ index: i, match: lines[i].match(queryParameterPattern) })).filter(
+        (entry) => entry.match !== null
+      ).map(({ index: line2, match }) => ({
+        name: match[1],
+        type: match[2],
+        typeReference: typeReferenceSymbol(match[2]),
+        isIdentifier: false,
+        line: line2
+      }));
+      symbols.queries.push({
+        name: queryMatch[1],
+        returnType: queryMatch[2],
+        returnTypeReference: typeReferenceSymbol(queryMatch[2]),
+        parameters,
+        line: index
+      });
+      continue;
+    }
+    const screenMatch = trimmed.match(/^screen\s+(\w+)\s*$/);
+    if (screenMatch) {
+      symbols.screens.push({ name: screenMatch[1], line: index });
+      continue;
+    }
+    const triggerMatch = trimmed.match(/^trigger\s+(\w+)\s*$/);
+    if (triggerMatch && indent === 0) {
+      symbols.triggers.push({ name: triggerMatch[1], line: index });
     }
   }
-  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);
+  return symbols;
+}
+function mergeSymbols(...documents) {
+  return {
+    imports: documents.flatMap((document) => document.imports),
+    concepts: documents.flatMap((document) => document.concepts),
+    types: documents.flatMap((document) => document.types),
+    policies: documents.flatMap((document) => document.policies),
+    events: documents.flatMap((document) => document.events),
+    commands: documents.flatMap((document) => document.commands),
+    queries: documents.flatMap((document) => document.queries),
+    screens: documents.flatMap((document) => document.screens),
+    triggers: documents.flatMap((document) => document.triggers)
+  };
+}
+function knownEventNames(symbols) {
+  return [
+    ...symbols.events.map((event) => event.name),
+    ...symbols.imports.map((imported) => imported.shortName)
+  ];
+}
+var builtInTriggerNames = ["Startup", "Shutdown"];
+function knownTriggerNames(symbols) {
+  return [
+    ...knownEventNames(symbols),
+    ...symbols.triggers.map((trigger) => trigger.name),
+    ...builtInTriggerNames
+  ];
+}
+function knownTypeNames(symbols, primitives) {
+  return [
+    ...primitives,
+    ...symbols.concepts.map((concept) => concept.name),
+    ...symbols.types.map((type) => type.name),
+    ...symbols.imports.map((imported) => imported.shortName)
+  ];
+}
+
+// event-context-catalog.ts
+var eventContextRootType = "EventContext";
+var eventContextTypes = {
+  "EventContext": [
+    { name: "eventType", type: "EventType", kind: "composite", description: "The type of the event - its identifier, generation and whether it is a tombstone." },
+    { name: "eventSourceType", type: "EventSourceType", kind: "value", description: "The type of the event source the event was appended to." },
+    { name: "eventSourceId", type: "EventSourceId", kind: "value", description: "The identifier of the event source the event was appended to - the value $eventSourceId resolves." },
+    { name: "eventStreamType", type: "EventStreamType", kind: "value", description: "The type of the event stream the event belongs to." },
+    { name: "eventStreamId", type: "EventStreamId", kind: "value", description: "The identifier of the event stream the event belongs to." },
+    { name: "sequenceNumber", type: "EventSequenceNumber", kind: "value", description: "The position of the event in its event sequence." },
+    { name: "occurred", type: "DateTimeOffset", kind: "value", description: "When the event occurred - the time it was appended unless one was given." },
+    { name: "eventStore", type: "EventStoreName", kind: "value", description: "The name of the event store the event belongs to." },
+    { name: "namespace", type: "EventStoreNamespaceName", kind: "value", description: "The namespace within the event store the event belongs to." },
+    { name: "correlationId", type: "CorrelationId", kind: "value", description: "The correlation identifier the event was appended with." },
+    { name: "causation", type: "IEnumerable<Causation>", kind: "collection", description: "The chain of causes that led to the event - a collection, not addressable below." },
+    { name: "causedBy", type: "Identity", kind: "composite", description: "The identity that caused the event." },
+    { name: "tags", type: "IEnumerable<Tag>", kind: "collection", description: "The tags the event was appended with - a collection, not addressable below." },
+    { name: "hash", type: "EventHash", kind: "value", description: "The hash of the event content." },
+    { name: "observationState", type: "EventObservationState", kind: "value", description: "Whether the observer sees the event for the first time or again on replay - differs between live processing and replay." },
+    { name: "subject", type: "Subject", kind: "value", description: "The compliance subject the event is about - the event source identifier unless one was given." },
+    { name: "subjectIsEventSourceId", type: "bool", kind: "value", description: "Whether the subject is the event source identifier." }
+  ],
+  "EventType": [
+    { name: "id", type: "EventTypeId", kind: "value", description: "The identifier of the event type." },
+    { name: "generation", type: "EventTypeGeneration", kind: "value", description: "The generation of the event type." },
+    { name: "tombstone", type: "bool", kind: "value", description: "Whether the event is a tombstone event." }
+  ],
+  "EventSourceType": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventSourceId": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventStreamType": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventStreamId": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventSequenceNumber": [
+    { name: "value", type: "ulong", kind: "value", description: "The underlying ulong value." }
+  ],
+  "DateTimeOffset": [
+    { name: "Week", type: "int", kind: "function", description: "The ISO 8601 week of the year the value falls in." }
+  ],
+  "EventStoreName": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventStoreNamespaceName": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "CorrelationId": [
+    { name: "value", type: "Guid", kind: "value", description: "The underlying Guid value." }
+  ],
+  "Identity": [
+    { name: "subject", type: "string", kind: "value", description: "The subject identifier of the identity." },
+    { name: "name", type: "string", kind: "value", description: "The display name of the identity." },
+    { name: "userName", type: "string", kind: "value", description: "The user name of the identity." },
+    { name: "onBehalfOf", type: "Identity", kind: "composite", description: "The identity this identity acted on behalf of, if any - an identity with the same members." }
+  ],
+  "EventHash": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "Subject": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventTypeId": [
+    { name: "value", type: "string", kind: "value", description: "The underlying string value." }
+  ],
+  "EventTypeGeneration": [
+    { name: "value", type: "uint", kind: "value", description: "The underlying uint value." }
+  ]
+};
+var eventContextPaths = [
+  { path: "eventType", name: "eventType", type: "EventType", kind: "composite", description: "The type of the event - its identifier, generation and whether it is a tombstone." },
+  { path: "eventType.id", name: "id", type: "EventTypeId", kind: "value", description: "The identifier of the event type." },
+  { path: "eventType.id.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "eventType.generation", name: "generation", type: "EventTypeGeneration", kind: "value", description: "The generation of the event type." },
+  { path: "eventType.generation.value", name: "value", type: "uint", kind: "value", description: "The underlying uint value." },
+  { path: "eventType.tombstone", name: "tombstone", type: "bool", kind: "value", description: "Whether the event is a tombstone event." },
+  { path: "eventSourceType", name: "eventSourceType", type: "EventSourceType", kind: "value", description: "The type of the event source the event was appended to." },
+  { path: "eventSourceType.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "eventSourceId", name: "eventSourceId", type: "EventSourceId", kind: "value", description: "The identifier of the event source the event was appended to - the value $eventSourceId resolves." },
+  { path: "eventSourceId.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "eventStreamType", name: "eventStreamType", type: "EventStreamType", kind: "value", description: "The type of the event stream the event belongs to." },
+  { path: "eventStreamType.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "eventStreamId", name: "eventStreamId", type: "EventStreamId", kind: "value", description: "The identifier of the event stream the event belongs to." },
+  { path: "eventStreamId.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "sequenceNumber", name: "sequenceNumber", type: "EventSequenceNumber", kind: "value", description: "The position of the event in its event sequence." },
+  { path: "sequenceNumber.value", name: "value", type: "ulong", kind: "value", description: "The underlying ulong value." },
+  { path: "occurred", name: "occurred", type: "DateTimeOffset", kind: "value", description: "When the event occurred - the time it was appended unless one was given." },
+  { path: "occurred.Week", name: "Week", type: "int", kind: "function", description: "The ISO 8601 week of the year the value falls in." },
+  { path: "eventStore", name: "eventStore", type: "EventStoreName", kind: "value", description: "The name of the event store the event belongs to." },
+  { path: "eventStore.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "namespace", name: "namespace", type: "EventStoreNamespaceName", kind: "value", description: "The namespace within the event store the event belongs to." },
+  { path: "namespace.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "correlationId", name: "correlationId", type: "CorrelationId", kind: "value", description: "The correlation identifier the event was appended with." },
+  { path: "correlationId.value", name: "value", type: "Guid", kind: "value", description: "The underlying Guid value." },
+  { path: "causation", name: "causation", type: "IEnumerable<Causation>", kind: "collection", description: "The chain of causes that led to the event - a collection, not addressable below." },
+  { path: "causedBy", name: "causedBy", type: "Identity", kind: "composite", description: "The identity that caused the event." },
+  { path: "causedBy.subject", name: "subject", type: "string", kind: "value", description: "The subject identifier of the identity." },
+  { path: "causedBy.name", name: "name", type: "string", kind: "value", description: "The display name of the identity." },
+  { path: "causedBy.userName", name: "userName", type: "string", kind: "value", description: "The user name of the identity." },
+  { path: "causedBy.onBehalfOf", name: "onBehalfOf", type: "Identity", kind: "composite", description: "The identity this identity acted on behalf of, if any - an identity with the same members." },
+  { path: "tags", name: "tags", type: "IEnumerable<Tag>", kind: "collection", description: "The tags the event was appended with - a collection, not addressable below." },
+  { path: "hash", name: "hash", type: "EventHash", kind: "value", description: "The hash of the event content." },
+  { path: "hash.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "observationState", name: "observationState", type: "EventObservationState", kind: "value", description: "Whether the observer sees the event for the first time or again on replay - differs between live processing and replay." },
+  { path: "subject", name: "subject", type: "Subject", kind: "value", description: "The compliance subject the event is about - the event source identifier unless one was given." },
+  { path: "subject.value", name: "value", type: "string", kind: "value", description: "The underlying string value." },
+  { path: "subjectIsEventSourceId", name: "subjectIsEventSourceId", type: "bool", kind: "value", description: "Whether the subject is the event source identifier." }
+];
+
+// event-context.ts
+function namesEventContextMember(member, segment) {
+  if (member.kind === "function") {
+    return segment === member.name || segment === `${member.name}()`;
   }
-  visitProperty(syntax) {
-    this.visitNode(syntax);
-    this.visitTypeRef(syntax.type);
+  const declared = member.name[0].toUpperCase() + member.name.slice(1);
+  return segment === declared || segment.length > 0 && segment[0].toUpperCase() + segment.slice(1) === declared;
+}
+var eventContextMembers = eventContextTypes[eventContextRootType];
+function eventContextMembersAfter(segments) {
+  let members = eventContextMembers;
+  for (const segment of segments) {
+    const member = members.find((candidate) => namesEventContextMember(candidate, segment));
+    if (!member || member.kind === "collection" || member.kind === "function") {
+      return void 0;
+    }
+    members = eventContextTypes[member.type] ?? [];
   }
-  visitTypeRef(syntax) {
-    this.visitNode(syntax);
+  return members;
+}
+function eventContextMemberAt(segments) {
+  if (segments.length === 0) {
+    return void 0;
   }
-  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));
+  const members = eventContextMembersAfter(segments.slice(0, -1));
+  return members?.find((member) => namesEventContextMember(member, segments[segments.length - 1]));
+}
+function resolveEventContextPath(path) {
+  let current;
+  let expected = eventContextMembers;
+  for (const segment of path.split(".")) {
+    if (segment.length === 0) {
+      return { status: "missing", member: current, expected };
+    }
+    if (current?.kind === "collection") {
+      return { status: "belowCollection", member: current, segment, expected: [] };
+    }
+    const next = expected.find((member) => namesEventContextMember(member, segment));
+    if (!next) {
+      return { status: current ? "unknownSubPath" : "unknownMember", member: current, segment, expected };
     }
+    current = next;
+    expected = next.kind === "function" ? [] : eventContextTypes[next.type] ?? [];
   }
-  visitObjectMember(syntax) {
-    this.visitNode(syntax);
-    this.visitExpression(syntax.value);
+  return { status: "known", member: current, expected: [] };
+}
+function describeEventContext() {
+  return [
+    "**$eventContext**",
+    "",
+    "Metadata about the event being projected. Paths are checked against the event-context catalog; `causation` and `tags` are collections and cannot be addressed below.",
+    "",
+    "**Members:**",
+    ...eventContextMembers.map((member) => `- \`${member.name}\` (${member.type}) - ${member.description}`)
+  ].join("\n");
+}
+function describeEventContextMember(path, member) {
+  const below = member.kind === "collection" || member.kind === "function" ? [] : eventContextTypes[member.type] ?? [];
+  const lines = [`**$eventContext.${path}**: \`${member.type}\``, "", member.description];
+  if (below.length > 0) {
+    lines.push("", `**Members:** ${below.map((child) => `\`${child.name}\``).join(", ")}`);
   }
+  return lines.join("\n");
+}
+
+// production-destinations.ts
+function productionDestinations(command) {
+  const identifiers = command.properties.filter((property) => property.isIdentifier && !propertyTypeReference(property).isOptional && !propertyTypeReference(property).isCollection);
+  const identifier = identifiers.length === 1 ? identifiers[0].name : void 0;
+  const productions = command.produces ?? [];
+  const mixed = productions.some((production) => production.target !== void 0 && production.target !== identifier) || productions.some((production) => production.inline && production.target === void 0) && productions.some((production) => !production.inline && production.target === void 0);
+  return { identifier, mixed };
+}
+function destinationHints(lines) {
+  const source = eventAnalysisSource(lines);
+  return scanDocument(source).commands.flatMap((command) => {
+    const { identifier, mixed } = productionDestinations(command);
+    if (mixed || command.productionHeaders?.length !== command.produces?.length) return [];
+    const hasPromotedDestination = command.produces?.some((sibling) => sibling.target !== void 0 || sibling.inline);
+    return (command.produces ?? []).flatMap((production) => {
+      if (production.target !== void 0 || production.inline && (identifier === void 0 || /\bgeneration\b/.test(source[production.line]))) return [];
+      if (!production.inline && hasPromotedDestination) return [];
+      return [{ line: production.line, column: source[production.line].length + 1, label: production.inline ? `for ${identifier}` : "for <new event source>" }];
+    });
+  });
+}
+
+// diagnostic-codes.ts
+var diagnosticCodes = {
+  eventSourceIdInPayload: "PLAY0469",
+  explicitProducesTargetsRequired: "PLAY0470",
+  redundantEventId: "PLAY0471",
+  invalidEventId: "PLAY0472",
+  inlineEventCollision: "PLAY0473",
+  inlineEventOutsideCommand: "PLAY0474",
+  inlineEventGeneration: "PLAY0475",
+  reservedProductionMetadata: "PLAY0476",
+  invalidEventDocumentation: "PLAY0477",
+  tabIndentation: "PLAY0006",
+  unknownPrimitiveType: "PLAY0008",
+  unknownSliceType: "PLAY0028",
+  duplicateCommandIdentifier: "PLAY0036",
+  unknownContextPath: "PLAY0153",
+  unknownContextCausedByProperty: "PLAY0154",
+  unknownContextIdentityProperty: "PLAY0155",
+  unclosedCodeBlock: "PLAY0164",
+  unknownType: "PLAY0165",
+  unknownEvent: "PLAY0166",
+  unknownPolicy: "PLAY0167",
+  duplicateDeclaration: "PLAY0168",
+  unknownEventContextMember: "PLAY0295",
+  unknownEventContextPath: "PLAY0296",
+  eventContextPathBelowCollection: "PLAY0297",
+  missingEventContextPath: "PLAY0298",
+  unresolvedDynamicKeySource: "PLAY0299",
+  invalidFileImport: "PLAY0454",
+  omittedProductionDestination: "PLAY0478",
+  legacyOptionalSuffix: "PLAY0479",
+  invalidOptionalModifierOrder: "PLAY0480",
+  optionalReadsNotSupported: "PLAY0481"
 };
 
-// ../../Compiler/dist/Authoring/QuickFixes.js
-function isQuickFixDiagnostic(code) {
-  return code === DiagnosticCodes.LegacyOptionalSuffix || code === DiagnosticCodes.RedundantEventId;
+// file-imports.ts
+var fileImportPattern2 = /^import(\s+)"([^"\\]+)"\s*(?:\/\/.*)?$/;
+var quotedImportPattern = /^import\s+"/;
+function isFileImportLine(line) {
+  return quotedImportPattern.test(line.trim());
 }
-function legacyOptionalTypeLength(line, diagnostic) {
-  if (diagnostic.code !== DiagnosticCodes.LegacyOptionalSuffix)
-    return 0;
-  return /^[\p{L}\p{Mn}\p{Nd}\p{Pc}.]+(?:\[\])?\?/u.exec(line.slice(diagnostic.location.column - 1))?.[0].length ?? 0;
+function fileImportOn(line, lineIndex) {
+  const indent = indentOf(line);
+  const match = line.slice(indent).match(fileImportPattern2);
+  if (!match) return void 0;
+  const startColumn = indent + "import".length + match[1].length + 2;
+  return { pattern: match[2], line: lineIndex, startColumn, endColumn: startColumn + match[2].length };
 }
-function prepareQuickFixes(source, options = {}) {
-  const original = parseForAuthoring(source, void 0, options.placement);
-  if (!original.success)
-    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 } }
-      });
-    }
+function fileImports(lines) {
+  const fences = fenceMap(lines);
+  const found = [];
+  for (let index = 0; index < lines.length; index++) {
+    if (fences[index]) continue;
+    const fileImport = fileImportOn(lines[index], index);
+    if (fileImport) found.push(fileImport);
   }
-  const optional = [...byLine.values()].filter((candidate) => candidate.fix.diagnosticCode === DiagnosticCodes.LegacyOptionalSuffix);
-  const syntax = verificationShape(original);
-  const verified = /* @__PURE__ */ new Map();
-  let rangeVerdicts;
-  let documentChecked = false;
-  let documentFix;
-  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);
-    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, 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;
-    }
-    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 && 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 = verified.get(occurrenceLine);
-    }
-    return [occurrenceFix, includeDocument ? documentFix : void 0].filter((fix) => fix !== void 0);
-  };
+  return found;
 }
-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);
+var folderOf = (path) => path.split("/").slice(0, -1);
+function relativeTo(from, path) {
+  const segments = path.split("/");
+  let common = 0;
+  while (common < from.length && common < segments.length - 1 && from[common] === segments[common]) common++;
+  return [...from.slice(common).map(() => ".."), ...segments.slice(common)].join("/");
 }
-function applyQuickFixEdits(source, edits) {
-  const parts = [];
-  let end = 0;
-  for (const edit of edits) {
-    if (edit.start < end || edit.start < 0 || edit.length < 0 || edit.start + edit.length > source.length)
-      return void 0;
-    parts.push(source.slice(end, edit.start), edit.text);
-    end = edit.start + edit.length;
+function importablePaths(documentPath, files) {
+  const from = folderOf(documentPath);
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of files.filter((candidate) => candidate !== documentPath && candidate.toLowerCase().endsWith(".play"))) {
+    const relative = relativeTo(from, file);
+    const folders = folderOf(relative);
+    paths.add(relative);
+    paths.add([...folders, "*.play"].join("/"));
+    for (let depth = 0; depth <= folders.length; depth++) {
+      paths.add([...folders.slice(0, depth), "**", "*.play"].join("/"));
+    }
   }
-  parts.push(source.slice(end));
-  return parts.join("");
+  return [...paths].sort();
 }
 
 // inline-event-validation.ts
@@ -4799,12 +4852,19 @@ export {
   languageConfiguration,
   typeReferenceSymbol,
   typeReferenceText,
+  DiagnosticCodes,
+  isQuickFixDiagnostic,
+  prepareQuickFixes,
   indentOf,
   firstWord,
   fenceMap,
   enclosingChain,
   nearestEnclosingLine,
   eventAnalysisSource,
+  fileReferenceKeyword,
+  isAbsoluteFileReferencePath,
+  fileReferenceOn,
+  fileReferences,
   propertyTypeReference,
   directBody,
   scanDocument,
@@ -4822,9 +4882,6 @@ export {
   describeEventContextMember,
   productionDestinations,
   destinationHints,
-  DiagnosticCodes,
-  isQuickFixDiagnostic,
-  prepareQuickFixes,
   diagnosticCodes,
   isFileImportLine,
   fileImportOn,
@@ -4833,4 +4890,4 @@ export {
   validateLines,
   validateEventContextPaths
 };
-//# sourceMappingURL=chunk-GJX4NJYC.js.map
+//# sourceMappingURL=chunk-LXM5L4YK.js.map