@cratis/screenplay-language 4.51.0 → 4.53.0

package/dist/bundles/chunk-7WJEZ72S.js

@@ -0,0 +1,4463 @@
+// language.ts
+var languageId = "screenplay";
+var languageExtensionPoint = {
+  id: languageId,
+  extensions: [".play"],
+  aliases: ["Screenplay", "screenplay", "play"],
+  mimetypes: ["text/x-screenplay"]
+};
+var constructKeywords = [
+  "domain",
+  "import",
+  "concept",
+  "type",
+  "policy",
+  "persona",
+  "authentication",
+  "module",
+  "layout",
+  "theme",
+  "ui",
+  "feature",
+  "slice",
+  "event",
+  "command",
+  "query",
+  "projection",
+  "capture",
+  "reaction",
+  "reducer",
+  "trigger",
+  "screen",
+  "dialog",
+  "form",
+  "contribute",
+  "constraint",
+  "specification",
+  "seed",
+  "behavior"
+];
+var clauseKeywords = [
+  "description",
+  "template",
+  "profile",
+  "require",
+  "authenticated",
+  "role",
+  "claim",
+  "subject",
+  "authorize",
+  "validate",
+  "produces",
+  "reads",
+  // A clause in command bodies and reaction trigger bodies; @reads remains a value.
+  "as",
+  "handler",
+  "performer",
+  "observable",
+  "identifier",
+  "reason",
+  "from",
+  "when",
+  "given",
+  "then",
+  "arguments",
+  "result",
+  "clock",
+  // A specification step - 'given clock' and 'when clock' state an instant.
+  "exactly",
+  "error",
+  "message",
+  "not",
+  "empty",
+  "rule",
+  "matches",
+  "all",
+  "max",
+  "min",
+  "length",
+  "today",
+  "true",
+  "false",
+  "and",
+  "or",
+  "by",
+  "filter",
+  "data",
+  "via",
+  "action",
+  "navigate",
+  "to",
+  "label",
+  "section",
+  "table",
+  "summary",
+  "title",
+  "column",
+  "field",
+  "on",
+  "unique",
+  "file",
+  "concurrency",
+  "eventSource",
+  "sourceType",
+  "streamType",
+  "streamId",
+  "tag",
+  "for",
+  "readmodel",
+  "no",
+  "when",
+  "every",
+  "at",
+  "where",
+  "invokes",
+  "contains",
+  "starts",
+  "with",
+  "provider",
+  // Interaction: the words a behavior body uses. The built-in interaction kinds ('click', 'submit', and
+  // friends) are only reserved inside an `on` clause, so they are clause words rather than constructs -
+  // an identifier of the same name elsewhere in a document remains an identifier.
+  "uses",
+  "parameter",
+  "order",
+  "execute",
+  "open",
+  "close",
+  "refresh",
+  "set",
+  "notify",
+  "confirm",
+  "raise",
+  "interval",
+  "success",
+  "failure",
+  "click",
+  "double",
+  "select",
+  "submit",
+  "change",
+  "load",
+  "unload",
+  "enter",
+  "leave",
+  "info",
+  "warning"
+];
+var codeBlockTags = ["csharp", "typescript", "react", "html", "sql"];
+var contextRoots = [
+  "command",
+  "arguments",
+  "tenant",
+  "causedBy",
+  "causation",
+  "occurred",
+  "identity"
+];
+var causedByProperties = ["subject", "name", "userName"];
+var identityProperties = ["id", "name", "userName", "isAuthenticated", "roles", "claims"];
+var sliceTypes = ["StateChange", "StateView", "Automation", "Translate"];
+var primitiveTypes = ["Uuid", "String", "Int", "Decimal", "Bool", "Date", "DateTime"];
+var conceptAttributes = ["@pii", "@sensitive"];
+var languageConfiguration = {
+  comments: {
+    lineComment: "//"
+  },
+  brackets: [
+    ["(", ")"],
+    ["[", "]"]
+  ],
+  autoClosingPairs: [
+    { open: "(", close: ")" },
+    { open: "[", close: "]" },
+    { open: '"', close: '"' }
+  ],
+  surroundingPairs: [
+    { open: "(", close: ")" },
+    { open: "[", close: "]" },
+    { open: '"', close: '"' }
+  ],
+  folding: {
+    offSide: true
+  },
+  indentationRules: {
+    increaseIndentPattern: /^\s*(module|feature|slice|policy|persona|authentication|provider|event|command|query|type|screen|projection|capture|reaction|trigger|constraint|specification|layout|template|validate|produces|handler|performer|rule|section|concurrency|seed|for|when|then|arguments|result|every|at)\b.*$/,
+    // Dedents are always explicit in an offside language — never auto-dedent.
+    decreaseIndentPattern: /(?!)/
+  }
+};
+
+// TypeReferenceSymbol.ts
+function typeReferenceSymbol(text) {
+  const match = /^([\w.]+)(\[\])?(\?|\s+optional)?$/.exec(text);
+  return { name: match?.[1] ?? text, isCollection: match?.[2] !== void 0, isOptional: match?.[3] !== void 0 };
+}
+function typeReferenceText(type) {
+  return `${type.name}${type.isCollection ? "[]" : ""}${type.isOptional ? " optional" : ""}`;
+}
+
+// document-context.ts
+function withoutComment(line) {
+  let inString = false;
+  let inTemplate = false;
+  for (let index = 0; index < line.length; index++) {
+    const character = line[index];
+    if (character === "\\" && inString && index + 1 < line.length) {
+      index++;
+    } else if (character === '"' && !inTemplate) {
+      inString = !inString;
+    } else if (character === "`" && !inString) {
+      inTemplate = !inTemplate;
+    } else if (!inString && !inTemplate && character === "/" && line[index + 1] === "/") {
+      return line.slice(0, index);
+    }
+  }
+  return line;
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function firstWord(line) {
+  return line.trim().split(/\s+/)[0] ?? "";
+}
+function fenceMap(lines) {
+  const map = new Array(lines.length).fill(false);
+  let open = false;
+  for (let index = 0; index < lines.length; index++) {
+    if (/^\s*```(?:[a-z]+)?\s*$/.test(lines[index]) && (!open || /^\s*```\s*$/.test(lines[index]))) {
+      map[index] = true;
+      open = !open;
+      continue;
+    }
+    map[index] = open;
+  }
+  return map;
+}
+function enclosingChain(lines, fences, lineIndex, indent) {
+  const chain = [];
+  let currentIndent = indent;
+  for (let index = lineIndex - 1; index >= 0 && currentIndent > 0; index--) {
+    if (fences[index]) continue;
+    const line = withoutComment(lines[index]);
+    if (line.trim().length === 0) continue;
+    const lineIndent = indentOf(line);
+    if (lineIndent < currentIndent) {
+      chain.push(firstWord(line));
+      currentIndent = lineIndent;
+    }
+  }
+  return chain;
+}
+function nearestEnclosingLine(lines, fences, lineIndex, indent) {
+  for (let index = lineIndex - 1; index >= 0 && indent > 0; index--) {
+    if (fences[index]) continue;
+    const line = withoutComment(lines[index]);
+    if (line.trim().length === 0) continue;
+    if (indentOf(line) < indent) {
+      return line.trim();
+    }
+  }
+  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;
+    }
+    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;
+  });
+}
+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(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 });
+    }
+  }
+  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();
+}
+
+// ../../Compiler/dist/Diagnostics/DiagnosticCodes.js
+var DiagnosticCodes = {
+  InvalidProducesDeclaration: "PLAY0042",
+  ProducesWhenWithoutEvent: "PLAY0043",
+  InvalidPropertyMapping: "PLAY0044",
+  DuplicateProducesTarget: "PLAY0193",
+  EventSourceIdInPayload: "PLAY0469",
+  ExplicitProducesTargetsRequired: "PLAY0470",
+  RedundantEventId: "PLAY0471",
+  InvalidEventId: "PLAY0472",
+  InlineEventCollision: "PLAY0473",
+  InlineEventOutsideCommand: "PLAY0474",
+  InlineEventGeneration: "PLAY0475",
+  ReservedProductionMetadata: "PLAY0476",
+  InvalidEventDocumentation: "PLAY0477",
+  UnknownTopLevelConstruct: "PLAY0001",
+  InvalidDomainDeclaration: "PLAY0002",
+  DuplicateDomain: "PLAY0003",
+  DomainNotFirst: "PLAY0004",
+  InvalidImportDeclaration: "PLAY0005",
+  TabIndentation: "PLAY0006",
+  InvalidConceptDeclaration: "PLAY0007",
+  UnknownPrimitiveType: "PLAY0008",
+  InvalidEnumerationValue: "PLAY0009",
+  UnknownConceptDirective: "PLAY0010",
+  ValidateReadAsEnumerationBlock: "PLAY0011",
+  AttributeReasonWithoutAttribute: "PLAY0012",
+  DuplicateAttributeReason: "PLAY0013",
+  InvalidTypeDeclaration: "PLAY0014",
+  TypeWithoutProperties: "PLAY0015",
+  InvalidPropertyDeclaration: "PLAY0016",
+  IdentifierOutsideCommand: "PLAY0017",
+  InvalidEventDeclaration: "PLAY0018",
+  IdentifierOnEventProperty: "PLAY0019",
+  TagPropertyReadAsTag: "PLAY0020",
+  InvalidModuleDeclaration: "PLAY0021",
+  UnknownModuleDirective: "PLAY0022",
+  InvalidFeatureDeclaration: "PLAY0023",
+  UnknownFeatureDirective: "PLAY0024",
+  InvalidSliceDeclaration: "PLAY0027",
+  UnknownSliceType: "PLAY0028",
+  UnknownSliceDirective: "PLAY0029",
+  InvalidPersonaDeclaration: "PLAY0030",
+  InvalidPersonaPolicyReference: "PLAY0031",
+  UnknownPersonaDirective: "PLAY0032",
+  InvalidCommandDeclaration: "PLAY0033",
+  UnknownCommandDirective: "PLAY0034",
+  DuplicateCommandIdentifier: "PLAY0036",
+  InvalidQueryDeclaration: "PLAY0047",
+  UnknownQueryDirective: "PLAY0048",
+  InvalidQueryParameter: "PLAY0049",
+  InvalidProjectionDeclaration: "PLAY0056",
+  EmptyProjection: "PLAY0057",
+  UnknownProjectionDirective: "PLAY0058",
+  FromWithoutEvent: "PLAY0061",
+  InvalidEventReference: "PLAY0062",
+  InvalidJoinDeclaration: "PLAY0063",
+  JoinWithoutEvent: "PLAY0064",
+  InvalidChildrenDeclaration: "PLAY0065",
+  InvalidNestedDeclaration: "PLAY0066",
+  NestedBlockWithoutFrom: "PLAY0067",
+  InvalidRemoveDeclaration: "PLAY0068",
+  UnknownRemoveDirective: "PLAY0069",
+  InvalidClearDeclaration: "PLAY0070",
+  ClearWithOutsideNestedBlock: "PLAY0071",
+  InvalidSpecificationDeclaration: "PLAY0094",
+  UnknownSpecificationDirective: "PLAY0095",
+  InvalidSpecificationWhen: "PLAY0096",
+  DuplicateSpecificationWhen: "PLAY0097",
+  InvalidThenError: "PLAY0098",
+  InvalidReadModelStep: "PLAY0099",
+  InvalidEventStep: "PLAY0100",
+  InvalidSpecificationValue: "PLAY0101",
+  InvalidScreenDeclaration: "PLAY0102",
+  UnknownScreenDirective: "PLAY0103",
+  InvalidDataDirective: "PLAY0104",
+  InvalidActionDirective: "PLAY0105",
+  UnknownActionDirective: "PLAY0106",
+  InvalidNavigation: "PLAY0107",
+  InvalidScreenLayoutSlot: "PLAY0108",
+  InvalidTitleDirective: "PLAY0109",
+  UnknownTableDirective: "PLAY0110",
+  UnknownSummaryDirective: "PLAY0111",
+  AuthorizeWithoutPolicy: "PLAY0122",
+  InvalidPolicyReference: "PLAY0123",
+  InvalidConstraintDeclaration: "PLAY0132",
+  ConstraintWithoutRule: "PLAY0133",
+  InvalidConstraintBody: "PLAY0134",
+  DuplicateConstraintBody: "PLAY0135",
+  InvalidReactionDeclaration: "PLAY0136",
+  InvalidReactionTrigger: "PLAY0137",
+  ReactionWithoutTrigger: "PLAY0138",
+  InvalidValidateDeclaration: "PLAY0140",
+  InvalidValidationRule: "PLAY0141",
+  InvalidRuleName: "PLAY0143",
+  InvalidDescription: "PLAY0145",
+  EmptyDescription: "PLAY0146",
+  DuplicateDescription: "PLAY0147",
+  TagWithoutValue: "PLAY0148",
+  InvalidTagValue: "PLAY0149",
+  UnknownContextPath: "PLAY0153",
+  UnknownContextCausedByProperty: "PLAY0154",
+  UnknownContextIdentityProperty: "PLAY0155",
+  ExpectedCodeFence: "PLAY0163",
+  UnclosedCodeBlock: "PLAY0164",
+  DuplicateDeclaration: "PLAY0168",
+  RepeatedSingularDeclarationAcrossFiles: "PLAY0172",
+  RepeatedDeclarationAcrossFiles: "PLAY0173",
+  ConflictingDescriptionAcrossFiles: "PLAY0174",
+  UnexpectedTokenInAuthorize: "PLAY0184",
+  UnclosedAuthorizeGroup: "PLAY0185",
+  InvalidReadModelDeclaration: "PLAY0186",
+  InvalidInvokesDeclaration: "PLAY0194",
+  InvalidScopeDeclaration: "PLAY0199",
+  DuplicateScope: "PLAY0200",
+  InvalidIntervalTrigger: "PLAY0249",
+  InvalidScheduleTrigger: "PLAY0250",
+  DuplicateReactionTrigger: "PLAY0253",
+  InvalidSpecificationEventSource: "PLAY0275",
+  DuplicateSpecificationEventSource: "PLAY0276",
+  InvalidProjectionVariantDeclaration: "PLAY0277",
+  InvalidEntersOnDeclaration: "PLAY0279",
+  NestedProjectionVariantNotAllowed: "PLAY0280",
+  InvalidStructuredValue: "PLAY0291",
+  DuplicateStructuredValueMember: "PLAY0294",
+  ConflictingSpecificationActions: "PLAY0358",
+  InvalidSpecificationEventOrder: "PLAY0359",
+  InvalidValidationSeverity: "PLAY0368",
+  VariantRequiresEnteringEvent: "PLAY0382",
+  DuplicateProjectionVariant: "PLAY0384",
+  DuplicateVariantEnteringEvent: "PLAY0385",
+  InvalidSpecificationDenied: "PLAY0388",
+  DuplicateAuthorizationAcrossFiles: "PLAY0394",
+  FileConstraintOnlySupportsUniqueness: "PLAY0396",
+  LegacyInlineCodeFence: "PLAY0397",
+  InvalidEventGeneration: "PLAY0446",
+  InvalidFileImport: "PLAY0454",
+  FileImportMatchesNothing: "PLAY0455",
+  ImportedFileNotFound: "PLAY0456",
+  ConflictingImportPlacement: "PLAY0457",
+  ImportCycle: "PLAY0458",
+  ModuleInPlacedFile: "PLAY0459",
+  UnexpectedInPlacedFile: "PLAY0460",
+  InvalidSpecificationClock: "PLAY0461",
+  InvalidSpecificationTrigger: "PLAY0462",
+  InvalidSpecificationCapture: "PLAY0463",
+  InvalidSpecificationQueryAction: "PLAY0464",
+  LegacyOptionalSuffix: "PLAY0479",
+  InvalidOptionalModifierOrder: "PLAY0480",
+  OptionalReadsNotSupported: "PLAY0481",
+  InvalidTriggerData: "PLAY0246"
+};
+
+// ../../Compiler/dist/Files/PlayPlacement.js
+var documentPlacement = [];
+var isDocumentPlacement = (placement) => placement.length === 0;
+function describePlacement(placement) {
+  if (placement.length === 0)
+    return "the application";
+  if (placement.length === 1)
+    return `module '${placement[0]}'`;
+  return `feature '${placement.join(".")}'`;
+}
+
+// ../../Compiler/dist/Text/patterns.js
+var wordCharacters = "\\p{L}\\p{Mn}\\p{Nd}\\p{Pc}";
+function pattern(source) {
+  let result = "";
+  let inClass = false;
+  for (let index = 0; index < source.length; index++) {
+    const current = source[index];
+    if (current === "\\" && index + 1 < source.length) {
+      const next = source[index + 1];
+      index++;
+      if (next === "w") {
+        result += inClass ? wordCharacters : `[${wordCharacters}]`;
+      } else if (next === "d") {
+        result += "\\p{Nd}";
+      } else {
+        result += `\\${next}`;
+      }
+      continue;
+    }
+    if (current === "[" && !inClass) {
+      inClass = true;
+    } else if (current === "]" && inClass) {
+      inClass = false;
+    }
+    result += current;
+  }
+  return new RegExp(result, "u");
+}
+
+// ../../Compiler/dist/Diagnostics/SourceLocation.js
+var sourceLocation = (line, column2, path) => path === void 0 ? { line, column: column2 } : { line, column: column2, path };
+
+// ../../Compiler/dist/Parsing/SourceLine.js
+var isBlank = (line) => line.content.length === 0;
+var locationOf = (line) => sourceLocation(line.number, line.indent + 1, line.path);
+var startOf = (line) => sourceLocation(line.number, 1, line.path);
+
+// ../../Compiler/dist/Parsing/AuthorizeParser.js
+var continuationPattern = pattern("^(?:(?:or|and)\\s+)?[A-Za-z_(][\\w\\s()]*$");
+var tokenPattern = new RegExp(pattern("\\(|\\)|[A-Za-z_]\\w*").source, "gu");
+var namePattern = pattern("^[A-Z]\\w*$");
+function parseAuthorize(context, line) {
+  let text = line.content.substring("authorize".length);
+  for (let child = context.peekChild(line.indent); child !== void 0 && continuationPattern.test(child.content); child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    text += ` ${child.content}`;
+  }
+  const tokens = tokenize(text);
+  const location = locationOf(line);
+  if (tokens.length === 0) {
+    context.error(DiagnosticCodes.AuthorizeWithoutPolicy, "Expected at least one policy after 'authorize'", location);
+    return null;
+  }
+  const parser = new RequirementParser(context, tokens, location);
+  const requirement = parser.parse();
+  return requirement === null ? null : { kind: "AuthorizeSyntax", requirement, location };
+}
+function combineAuthorize(first, next) {
+  if (first === null)
+    return next;
+  if (next === null)
+    return first;
+  return {
+    kind: "AuthorizeSyntax",
+    requirement: { kind: "LogicalPolicyRequirementSyntax", left: first.requirement, operator: "And", right: next.requirement, location: first.location },
+    location: first.location
+  };
+}
+function tokenize(text) {
+  const tokens = [];
+  for (const token of text.match(tokenPattern) ?? []) {
+    if (tokens.length > 0 && isOperandEnd(tokens[tokens.length - 1]) && isOperandStart(token)) {
+      tokens.push("and");
+    }
+    tokens.push(token);
+  }
+  return tokens;
+}
+var isName = (token) => token !== "(" && token !== ")" && token !== "and" && token !== "or";
+var isOperandEnd = (token) => token === ")" || isName(token);
+var isOperandStart = (token) => token === "(" || isName(token);
+var RequirementParser = class {
+  context;
+  tokens;
+  location;
+  #position = 0;
+  constructor(context, tokens, location) {
+    this.context = context;
+    this.tokens = tokens;
+    this.location = location;
+  }
+  parse() {
+    const requirement = this.#or();
+    if (requirement !== null && this.#position < this.tokens.length) {
+      this.context.error(DiagnosticCodes.UnexpectedTokenInAuthorize, `Unexpected '${this.tokens[this.#position]}' in authorize`, this.location);
+    }
+    return requirement;
+  }
+  #or() {
+    return this.#chain("or", "Or", () => this.#and());
+  }
+  #and() {
+    return this.#chain("and", "And", () => this.#groupOrReference());
+  }
+  #chain(token, operator, operand2) {
+    let left = operand2();
+    while (left !== null && this.tokens[this.#position] === token) {
+      this.#position++;
+      const right = operand2();
+      if (right === null) {
+        return null;
+      }
+      left = { kind: "LogicalPolicyRequirementSyntax", left, operator, right, location: this.location };
+    }
+    return left;
+  }
+  #groupOrReference() {
+    if (this.tokens[this.#position] !== "(") {
+      return this.#reference();
+    }
+    this.#position++;
+    const requirement = this.#or();
+    if (this.tokens[this.#position] === ")") {
+      this.#position++;
+    } else {
+      this.context.error(DiagnosticCodes.UnclosedAuthorizeGroup, "Expected ')' in authorize", this.location);
+    }
+    return requirement;
+  }
+  #reference() {
+    if (this.#position >= this.tokens.length) {
+      this.context.error(DiagnosticCodes.AuthorizeWithoutPolicy, "Expected a policy name", this.location);
+      return null;
+    }
+    const token = this.tokens[this.#position++];
+    if (!namePattern.test(token)) {
+      this.context.error(DiagnosticCodes.InvalidPolicyReference, `Invalid policy reference '${token}' - policy names are PascalCase identifiers`, this.location);
+      return null;
+    }
+    return { kind: "PolicyReferenceSyntax", name: token, location: this.location };
+  }
+};
+
+// ../../Compiler/dist/Text/StringLiteral.js
+var stringBodyPattern = '(?:[^"\\\\]|\\\\.)*';
+var escapes = { "\\": "\\", '"': '"', n: "\n", r: "\r", t: "	" };
+function unescapeString(value) {
+  if (!value.includes("\\")) {
+    return value;
+  }
+  let result = "";
+  for (let index = 0; index < value.length; index++) {
+    const escaped = index + 1 < value.length ? escapes[value[index + 1]] : void 0;
+    if (value[index] === "\\" && escaped !== void 0) {
+      result += escaped;
+      index++;
+    } else {
+      result += value[index];
+    }
+  }
+  return result;
+}
+
+// ../../Compiler/dist/Parsing/CodeBlockParser.js
+function parseFencedText(context, opener, tagLine, allowMarkdown = false) {
+  const onTagLine = tagLine.content.startsWith("```");
+  const open = onTagLine ? tagLine : context.reader.peekSignificant();
+  const expectedFence = opener === "description" ? "```text" : `\`\`\`${opener}`;
+  if (open === void 0 || open !== tagLine && open.indent <= tagLine.indent || open.content !== expectedFence && !(allowMarkdown && opener === "description" && open.content === "```markdown") && !(open.content === "```" && open !== tagLine)) {
+    context.error(DiagnosticCodes.ExpectedCodeFence, `Expected an opening \`\`\`${opener === "description" ? "text" : opener} fence after '${opener}'`, locationOf(tagLine));
+    return null;
+  }
+  if (open !== tagLine) {
+    context.reader.takeSignificant();
+  }
+  if (opener === "description" && open.content === "```") {
+    context.warning(DiagnosticCodes.LegacyInlineCodeFence, "A bare description fence is deprecated - use '```text' instead", locationOf(open));
+  }
+  const code = [];
+  for (; ; ) {
+    const line = context.reader.takeRaw();
+    if (line === void 0) {
+      context.error(DiagnosticCodes.UnclosedCodeBlock, "Unclosed inline code block - expected a closing ``` line", locationOf(open));
+      break;
+    }
+    if (line.raw.trim() === "```") {
+      break;
+    }
+    let strip = 0;
+    while (strip < open.indent && strip < line.raw.length && line.raw[strip] === " ") {
+      strip++;
+    }
+    code.push(line.raw.substring(strip));
+  }
+  return code.join("\n");
+}
+
+// ../../Compiler/dist/Parsing/DescriptionParser.js
+var descriptionPattern = pattern(`^description\\s+"(${stringBodyPattern})"$`);
+function parseDescription(context, line, existing, owner, allowMarkdown = false) {
+  if (line.content === "description") {
+    const text = parseFencedText(context, "description", line, allowMarkdown);
+    if (text === null) {
+      return existing;
+    }
+    if (text.trim().length === 0) {
+      context.error(DiagnosticCodes.EmptyDescription, `${owner} declares an empty description - the fenced block must contain text`, locationOf(line));
+      return existing;
+    }
+    return keep(context, line, existing, owner, text);
+  }
+  const match = descriptionPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidDescription, `Invalid description '${line.content}' - expected 'description "<text>"'`, locationOf(line));
+    return existing;
+  }
+  return keep(context, line, existing, owner, unescapeString(match[1]));
+}
+function keep(context, line, existing, owner, description) {
+  if (existing !== null) {
+    context.error(DiagnosticCodes.DuplicateDescription, `${owner} already declares a description - at most one is allowed`, locationOf(line));
+    return existing;
+  }
+  return description;
+}
+
+// ../../Compiler/dist/Parsing/FileImportParser.js
+var fileImportPattern2 = pattern('^import\\s+"([^"\\\\]+)"$');
+var quotedPattern = pattern('^import\\s+"');
+var isFileImport = (content) => quotedPattern.test(content);
+function tryParseFileImport(line) {
+  const match = fileImportPattern2.exec(line.content);
+  return match === null ? void 0 : { kind: "FileImportSyntax", pattern: match[1], location: locationOf(line) };
+}
+function parseFileImport(context, line, imports) {
+  const fileImport = tryParseFileImport(line);
+  if (fileImport !== void 0) {
+    imports.push(fileImport);
+    return;
+  }
+  context.error(DiagnosticCodes.InvalidFileImport, `Invalid import '${line.content}' - inside a module or feature, import names files: 'import "<path or glob>"'`, locationOf(line));
+  context.skipBlock(line.indent);
+}
+
+// ../../Compiler/dist/Parsing/LineText.js
+var firstWord2 = (content) => {
+  const space = content.indexOf(" ");
+  return space === -1 ? content : content.substring(0, space);
+};
+var unescapeIdentifier = (identifier) => identifier.replaceAll("@", "");
+function splitTopLevel(text, separator) {
+  const parts = [];
+  let start = 0;
+  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 (current === separator && !inString && !inTemplate) {
+      parts.push(text.substring(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(text.substring(start));
+  return parts;
+}
+
+// ../../Compiler/dist/Syntax/Structure.js
+var sliceTypes2 = ["StateChange", "StateView", "Automation", "Translate"];
+
+// ../../Compiler/dist/Parsing/CaptureParser.js
+var header = pattern("^capture\\s+([A-Za-z_]\\w*)$");
+var appendPattern = pattern("^append\\s+([A-Z]\\w*)$");
+var childrenPattern = pattern("^children\\s+([a-z_]\\w*)\\s+identified\\s+by\\s+([\\w.]+)$");
+var nestedPattern = pattern("^nested\\s+([\\w.]+)$");
+function parseCapture(context, line) {
+  const name = header.exec(line.content)?.[1] ?? "";
+  let source = null;
+  let key = null;
+  const appends = [];
+  const children = [];
+  const nested = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    switch (firstWord2(child.content)) {
+      case "source":
+        source = parseSource(context, child);
+        break;
+      case "key":
+        key = child.content.substring("key".length).trim();
+        break;
+      case "append":
+        pushAppend(context, child, appends);
+        break;
+      case "children": {
+        const match = childrenPattern.exec(child.content);
+        const blockAppends = appendsOf(context, child);
+        if (match !== null) {
+          children.push({ kind: "CaptureChildrenSyntax", property: match[1], identifiedBy: match[2], appends: blockAppends, location: locationOf(child) });
+        }
+        break;
+      }
+      case "nested": {
+        const match = nestedPattern.exec(child.content);
+        const blockAppends = appendsOf(context, child);
+        if (match !== null) {
+          nested.push({ kind: "CaptureNestedSyntax", property: match[1], appends: blockAppends, location: locationOf(child) });
+        }
+        break;
+      }
+      default:
+        context.skipOpaqueBlock(child.indent);
+    }
+  }
+  return { kind: "CaptureSyntax", name, source, key, appends, children, nested, location: locationOf(line) };
+}
+function parseSource(context, line) {
+  const settings = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const settingName = firstWord2(child.content);
+    settings.push({ kind: "CaptureSourceSettingSyntax", name: settingName, value: child.content.substring(settingName.length).trim(), location: locationOf(child) });
+  }
+  return { kind: "CaptureSourceSyntax", syntaxKind: line.content.substring("source".length).trim(), settings, location: locationOf(line) };
+}
+function appendsOf(context, line) {
+  const appends = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (firstWord2(child.content) === "append") {
+      pushAppend(context, child, appends);
+    } else {
+      context.skipOpaqueBlock(child.indent);
+    }
+  }
+  return appends;
+}
+function pushAppend(context, line, appends) {
+  const match = appendPattern.exec(line.content);
+  context.skipOpaqueBlock(line.indent);
+  if (match !== null) {
+    appends.push({ kind: "CaptureAppendSyntax", event: match[1], location: locationOf(line) });
+  }
+}
+
+// ../../Compiler/dist/Parsing/StructuredValueParser.js
+var maximumDepth = 64;
+var InvalidStructuredValue = class extends Error {
+};
+var StructuredValueParser = class {
+  text;
+  start;
+  context;
+  #position = 0;
+  constructor(text, start, context) {
+    this.text = text;
+    this.start = start;
+    this.context = context;
+  }
+  parse() {
+    const value = this.#value(0);
+    this.#whitespace();
+    if (this.#position < this.text.length) {
+      throw new InvalidStructuredValue(`'${this.text[this.#position]}' is invalid after a single JSON value.`);
+    }
+    return value;
+  }
+  #value(depth) {
+    this.#whitespace();
+    const location = this.#at();
+    const current = this.text[this.#position];
+    if (current === "[" || current === "{") {
+      if (depth >= maximumDepth) {
+        throw new InvalidStructuredValue(`The value nests deeper than ${maximumDepth} levels.`);
+      }
+      return current === "[" ? this.#list(depth, location) : this.#object(depth, location);
+    }
+    if (current === '"') {
+      return { kind: "LiteralExpressionSyntax", value: this.#string(), location };
+    }
+    for (const [word, value] of [["true", true], ["false", false], ["null", null]]) {
+      if (this.text.startsWith(word, this.#position)) {
+        this.#position += word.length;
+        return { kind: "LiteralExpressionSyntax", value, location };
+      }
+    }
+    return { kind: "LiteralExpressionSyntax", value: this.#number(), location };
+  }
+  #list(depth, location) {
+    this.#position++;
+    const items = [];
+    this.#whitespace();
+    if (this.#take("]")) {
+      return { kind: "ListExpressionSyntax", items, location };
+    }
+    for (; ; ) {
+      items.push(this.#value(depth + 1));
+      this.#whitespace();
+      if (this.#take("]")) {
+        return { kind: "ListExpressionSyntax", items, location };
+      }
+      this.#expect(",");
+    }
+  }
+  #object(depth, location) {
+    this.#position++;
+    const members = [];
+    const names = /* @__PURE__ */ new Set();
+    this.#whitespace();
+    if (this.#take("}")) {
+      return { kind: "ObjectExpressionSyntax", members, location };
+    }
+    for (; ; ) {
+      this.#whitespace();
+      const keyLocation = this.#at();
+      if (this.text[this.#position] !== '"') {
+        throw new InvalidStructuredValue("Expected a property name in double quotes.");
+      }
+      const name = this.#string();
+      this.#whitespace();
+      this.#expect(":");
+      const value = this.#value(depth + 1);
+      if (names.has(name)) {
+        this.context?.error(DiagnosticCodes.DuplicateStructuredValueMember, `Duplicate property '${name}' in structured value`, keyLocation);
+      } else {
+        names.add(name);
+        members.push({ kind: "ObjectMemberSyntax", name, value, location: keyLocation });
+      }
+      this.#whitespace();
+      if (this.#take("}")) {
+        return { kind: "ObjectExpressionSyntax", members, location };
+      }
+      this.#expect(",");
+    }
+  }
+  #string() {
+    const end = this.#stringEnd(this.#position);
+    const raw = this.text.substring(this.#position, end);
+    this.#position = end;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new InvalidStructuredValue(`${raw} is not a valid JSON string.`);
+    }
+  }
+  #stringEnd(from) {
+    for (let index = from + 1; index < this.text.length; index++) {
+      if (this.text[index] === "\\") {
+        index++;
+      } else if (this.text[index] === '"') {
+        return index + 1;
+      }
+    }
+    throw new InvalidStructuredValue("A string is not closed.");
+  }
+  #number() {
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(this.text.substring(this.#position));
+    if (match === null) {
+      throw new InvalidStructuredValue(`'${this.text[this.#position] ?? ""}' is an invalid start of a value.`);
+    }
+    this.#position += match[0].length;
+    const number = Number(match[0]);
+    if (!Number.isFinite(number)) {
+      throw new InvalidStructuredValue("JSON number is outside the finite Double range.");
+    }
+    return number;
+  }
+  #at() {
+    return { ...this.start, column: this.start.column + this.#position };
+  }
+  #whitespace() {
+    while (this.#position < this.text.length && " 	\n\r".includes(this.text[this.#position])) {
+      this.#position++;
+    }
+  }
+  #take(character) {
+    if (this.text[this.#position] !== character) {
+      return false;
+    }
+    this.#position++;
+    return true;
+  }
+  #expect(character) {
+    if (!this.#take(character)) {
+      throw new InvalidStructuredValue(`Expected '${character}' at position ${this.#position}.`);
+    }
+  }
+};
+
+// ../../Compiler/dist/Parsing/ExpressionParser.js
+var pathPattern = pattern("^@?[A-Za-z_]\\w*(\\.@?[A-Za-z_$]\\w*)*$");
+var numberPattern = pattern("^-?\\d+(\\.\\d+)?$");
+var contextRoots2 = ["command", "arguments", "tenant", "causedBy", "causation", "occurred", "identity"];
+var causedByProperties2 = ["subject", "name", "userName"];
+var identityProperties2 = ["id", "name", "userName", "isAuthenticated", "roles", "claims"];
+function parseMappingSource(text, location, context) {
+  text = text.trim();
+  if (text.startsWith("$context.")) {
+    const path = text.substring("$context.".length);
+    warnOnUnknownContextPath(path, location, context);
+    return { kind: "ContextExpressionSyntax", path, location };
+  }
+  if (text.startsWith("$env.")) {
+    return { kind: "EnvironmentExpressionSyntax", name: text.substring("$env.".length), location };
+  }
+  if (text.startsWith("$strings.")) {
+    return { kind: "StringsExpressionSyntax", key: text.substring("$strings.".length), location };
+  }
+  if (text.startsWith("$.")) {
+    return { kind: "SourceItemExpressionSyntax", path: text.substring("$.".length), location };
+  }
+  if (text.startsWith("{") || text.startsWith("[")) {
+    try {
+      return new StructuredValueParser(text, location, context).parse();
+    } catch (error) {
+      if (!(error instanceof InvalidStructuredValue)) {
+        throw error;
+      }
+      context?.error(DiagnosticCodes.InvalidStructuredValue, `Invalid inline structured value: ${error.message}`, location);
+      return { kind: "RawExpressionSyntax", text, location };
+    }
+  }
+  const literal = parseLiteral(text, location);
+  if (literal !== void 0) {
+    return literal;
+  }
+  if (pathPattern.test(text)) {
+    return { kind: "PathExpressionSyntax", path: text, location };
+  }
+  return { kind: "RawExpressionSyntax", text, location };
+}
+function warnOnUnknownContextPath(path, location, context) {
+  const [root, member] = path.split(".");
+  if (!contextRoots2.includes(root)) {
+    context?.warning(DiagnosticCodes.UnknownContextPath, `Unknown $context path '${path}' - expected one of ${contextRoots2.join(", ")}`, location);
+  } else if (member !== void 0 && root === "causedBy" && !causedByProperties2.includes(member)) {
+    context?.warning(DiagnosticCodes.UnknownContextCausedByProperty, `Unknown $context.causedBy property '${member}' - expected ${causedByProperties2.join(", ")}`, location);
+  } else if (member !== void 0 && root === "identity" && !identityProperties2.includes(member)) {
+    context?.warning(DiagnosticCodes.UnknownContextIdentityProperty, `Unknown $context.identity property '${member}' - expected ${identityProperties2.join(", ")}`, location);
+  }
+}
+function parseLiteral(text, location) {
+  const literal = (value) => ({ kind: "LiteralExpressionSyntax", value, location });
+  switch (text) {
+    case "true":
+      return literal(true);
+    case "false":
+      return literal(false);
+    case "null":
+      return literal(null);
+  }
+  const quoted = text.length >= 2 && (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'"));
+  if (quoted) {
+    return literal(unescapeString(text.substring(1, text.length - 1)));
+  }
+  if (numberPattern.test(text) && !Number.isNaN(Number(text))) {
+    return literal(Number(text));
+  }
+  return void 0;
+}
+
+// ../../Compiler/dist/Parsing/EventMetadataParser.js
+var idPattern = pattern(`^id\\s+"(${stringBodyPattern})"$`);
+var EventMetadataParser = class {
+  name;
+  value = { id: null, description: null, documentation: null };
+  constructor(name) {
+    this.name = name;
+  }
+  tryParse(context, line) {
+    const location = locationOf(line);
+    switch (firstWord2(line.content)) {
+      case "id": {
+        const match = idPattern.exec(line.content);
+        const id = match === null ? "" : unescapeString(match[1]);
+        if (id.trim().length === 0 || this.value.id !== null) {
+          context.error(DiagnosticCodes.InvalidEventId, `Event '${this.name}' accepts one nonempty 'id "<old-name>"'`, location);
+        } else {
+          this.value.id = id;
+          if (id === this.name) {
+            context.information(DiagnosticCodes.RedundantEventId, `Event '${this.name}' already has this name as its identity - remove the redundant id`, location);
+          }
+        }
+        return true;
+      }
+      case "description":
+        this.value.description = parseDescription(context, line, this.value.description, `Event '${this.name}'`, true);
+        return true;
+      case "documentation": {
+        if (line.content !== "documentation" || context.peekChild(line.indent)?.content !== "```markdown") {
+          context.error(DiagnosticCodes.InvalidEventDocumentation, `Event '${this.name}' documentation requires a fenced markdown block`, location);
+          context.skipOpaqueBlock(line.indent);
+          return true;
+        }
+        const text = parseFencedText(context, "markdown", line);
+        if (text === null || text.trim().length === 0 || this.value.documentation !== null) {
+          context.error(DiagnosticCodes.InvalidEventDocumentation, `Event '${this.name}' accepts one nonempty documentation block`, location);
+        } else {
+          this.value.documentation = text;
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+};
+
+// ../../Compiler/dist/Parsing/FileReferences.js
+var typeReferencePattern = 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));
+
+// ../../Compiler/dist/Parsing/PropertyLineParser.js
+var propertyPattern2 = 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);
+  if (match === null) {
+    return void 0;
+  }
+  const location = locationOf(line);
+  return {
+    kind: "PropertySyntax",
+    name: unescapeIdentifier(match[1]),
+    type: parseTypeRef(match[2], { ...location, column: location.column + line.content.indexOf(match[2], match[1].length) }),
+    isIdentifier: match[3] !== void 0,
+    location
+  };
+}
+function parseTypeRef(text, location) {
+  const legacy = text.endsWith("?");
+  const canonical = /\soptional$/.test(text);
+  const isOptional = legacy || canonical;
+  if (isOptional) {
+    text = text.substring(0, text.length - (legacy ? 1 : "optional".length)).trimEnd();
+  }
+  const isCollection = text.endsWith("[]");
+  if (isCollection) {
+    text = text.substring(0, text.length - 2);
+  }
+  return { kind: "TypeRefSyntax", name: text, isCollection, isOptional, location };
+}
+function parseProperty(context, line) {
+  const property = tryParseProperty(line);
+  if (property !== void 0) {
+    reportLegacyOptionalSuffix(context, property.type, line);
+  } else {
+    reportInvalidModifierOrder(context, line);
+  }
+  return property;
+}
+function reportLegacyOptionalSuffix(context, type, line) {
+  const length = type.name.length + (type.isCollection ? 2 : 0);
+  const offset = type.location.column - line.indent - 1 + length;
+  if (type.isOptional && line.content[offset] === "?") {
+    const name = type.name + (type.isCollection ? "[]" : "");
+    context.information(DiagnosticCodes.LegacyOptionalSuffix, `Write '${name} optional' instead of '${name}?'.`, type.location);
+  }
+}
+function reportInvalidModifierOrder(context, line) {
+  if (reversedModifiers.test(line.content)) {
+    context.error(DiagnosticCodes.InvalidOptionalModifierOrder, "Write 'optional' before 'identifier': '<name> <Type> optional identifier'.", locationOf(line));
+  }
+}
+
+// ../../Compiler/dist/Parsing/DeclarationParsers.js
+var typeHeader = pattern("^type\\s+([A-Za-z_]\\w*)$");
+var eventHeader = pattern("^event\\s+([A-Za-z_]\\w*)(?:\\s+generation\\s+([0-9]+))?$");
+var readModelHeader = pattern("^readmodel\\s+([A-Za-z_]\\w*)$");
+var maximumGeneration = 4294967295;
+var typeShapedPattern = pattern("^[A-Z]\\w*(?:\\[\\])?(?:\\?|\\s+optional)?$");
+var tagIdentifierPattern = pattern("^[A-Za-z_]\\w*$");
+var isDescription = (line) => firstWord2(line.content) === "description" && tryParseProperty(line) === void 0;
+function withoutIdentifier(context, property, line, code, message) {
+  if (!property.isIdentifier) {
+    return property;
+  }
+  context.error(code, message, locationOf(line));
+  return { ...property, isIdentifier: false };
+}
+function parseType(context, header10) {
+  const name = typeHeader.exec(header10.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidTypeDeclaration, `Invalid type declaration '${header10.content}' - expected 'type <Name>'`, locationOf(header10));
+  }
+  const properties = [];
+  let description = null;
+  for (let line = context.peekChild(header10.indent); line !== void 0; line = context.peekChild(header10.indent)) {
+    context.reader.takeSignificant();
+    if (isDescription(line)) {
+      description = parseDescription(context, line, description, `Type '${name}'`);
+      continue;
+    }
+    if (isFileDirectiveAmongProperties(line)) {
+      continue;
+    }
+    const property = parseProperty(context, line);
+    if (property === void 0) {
+      context.error(DiagnosticCodes.InvalidPropertyDeclaration, `Invalid property '${line.content}' - expected '<name> <Type>'`, locationOf(line));
+      continue;
+    }
+    properties.push(withoutIdentifier(context, property, line, DiagnosticCodes.IdentifierOutsideCommand, `Property '${property.name}' of type '${name}' cannot be marked identifier - only a command property can be`));
+  }
+  if (properties.length === 0) {
+    context.error(DiagnosticCodes.TypeWithoutProperties, `Type '${name}' must declare at least one property`, locationOf(header10));
+  }
+  return { kind: "TypeSyntax", name, properties, description, location: locationOf(header10) };
+}
+function parseEvent(context, header10) {
+  const match = eventHeader.exec(header10.content);
+  const name = match?.[1] ?? "";
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidEventDeclaration, `Invalid event declaration '${header10.content}' - expected 'event <Name> [generation <N>]'`, locationOf(header10));
+  }
+  const hasGenerationMarker = match?.[2] !== void 0;
+  let generation = 1;
+  if (hasGenerationMarker) {
+    const declared = Number(match[2]);
+    if (!Number.isSafeInteger(declared) || declared === 0 || declared >= maximumGeneration) {
+      context.error(DiagnosticCodes.InvalidEventGeneration, `Event '${name}' must declare a generation between 1 and ${maximumGeneration - 1}`, locationOf(header10));
+    } else {
+      generation = declared;
+    }
+  }
+  const properties = [];
+  const tags = [];
+  const metadata = new EventMetadataParser(name);
+  for (let line = context.peekChild(header10.indent); line !== void 0; line = context.peekChild(header10.indent)) {
+    context.reader.takeSignificant();
+    if (isFileDirectiveAmongProperties(line)) {
+      continue;
+    }
+    if (firstWord2(line.content) === "tag") {
+      const tag = parseTag(context, line);
+      if (tag !== void 0) {
+        tags.push(tag);
+      }
+      continue;
+    }
+    const property = parseProperty(context, line);
+    if (property === void 0) {
+      if (!metadata.tryParse(context, line)) {
+        context.error(DiagnosticCodes.InvalidPropertyDeclaration, `Invalid property '${line.content}' - expected '<name> <Type>'`, locationOf(line));
+      }
+      continue;
+    }
+    properties.push(withoutIdentifier(context, property, line, DiagnosticCodes.IdentifierOnEventProperty, `Property '${property.name}' of event '${name}' cannot be marked identifier - an event never carries its event source id`));
+  }
+  return { kind: "EventSyntax", name, properties, tags, generation, hasGenerationMarker, ...metadata.value, location: locationOf(header10) };
+}
+function parseTag(context, line, eventDeclaration = true) {
+  const value = line.content.substring("tag".length).trim();
+  if (eventDeclaration && typeShapedPattern.test(value)) {
+    context.warning(DiagnosticCodes.TagPropertyReadAsTag, `'${line.content}' declares a static tag with the value '${value}', not a property named 'tag' - write 'tag "${value}"' for the tag, or '@${line.content}' for the property`, locationOf(line));
+  }
+  if (value.length === 0) {
+    context.error(DiagnosticCodes.TagWithoutValue, "Expected a value after 'tag' - an identifier, a string literal or a context expression", locationOf(line));
+    return void 0;
+  }
+  if (tagIdentifierPattern.test(value)) {
+    return { kind: "TagSyntax", value: { kind: "LiteralExpressionSyntax", value, location: locationOf(line) }, location: locationOf(line) };
+  }
+  const expression = parseMappingSource(value, locationOf(line), context);
+  if (expression.kind === "RawExpressionSyntax") {
+    context.error(DiagnosticCodes.InvalidTagValue, `Invalid tag value '${value}' - expected an identifier, a string literal or a context expression`, locationOf(line));
+    return void 0;
+  }
+  return { kind: "TagSyntax", value: expression, location: locationOf(line) };
+}
+function parseReadModel(context, header10) {
+  const name = readModelHeader.exec(header10.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidReadModelDeclaration, `Invalid read model declaration '${header10.content}' - expected 'readmodel <Name>'`, locationOf(header10));
+  }
+  const properties = [];
+  let description = null;
+  for (let line = context.peekChild(header10.indent); line !== void 0; line = context.peekChild(header10.indent)) {
+    context.reader.takeSignificant();
+    if (isDescription(line)) {
+      description = parseDescription(context, line, description, `Read model '${name}'`);
+    } else if (isFileDirectiveAmongProperties(line)) {
+      continue;
+    } else {
+      const property = parseProperty(context, line);
+      if (property === void 0) {
+        context.error(DiagnosticCodes.InvalidPropertyDeclaration, `Invalid property '${line.content}' - expected '<name> <Type>'`, locationOf(line));
+        continue;
+      }
+      properties.push(withoutIdentifier(context, property, line, DiagnosticCodes.IdentifierOutsideCommand, `Property '${property.name}' of read model '${name}' cannot be marked identifier - only a command property can be`));
+    }
+  }
+  return { kind: "ReadModelSyntax", name, properties, description, location: locationOf(header10) };
+}
+
+// ../../Compiler/dist/Parsing/ProducesParser.js
+var inlineHeader = pattern("^produces\\s+event\\s+([A-Za-z_]\\w*)(?:\\s+(generation)(?:\\s+.*)?)?$");
+var plainHeader = pattern("^produces\\s+([A-Z]\\w*)$");
+var conditional = pattern("^produces\\s+when\\s+(.+)$");
+var eventName = pattern("^[A-Z]\\w*$");
+var targetPattern = pattern("^for\\s+(\\S.*)$");
+var mappingPattern = pattern("^(@?[\\w.]+)\\s*=(?!=|>)\\s*(.+)$");
+var typedMappingPattern = pattern("^(.+?)\\s*=(?!=|>)\\s*(.+)$");
+var reserved = /* @__PURE__ */ new Set(["namespace", "sequence", "correlation", "causation", "causedBy", "occurred"]);
+function parseProduces(context, header10, inCommand = false) {
+  const inline = inlineHeader.exec(header10.content);
+  let parent = header10;
+  let name;
+  if (inline !== null) {
+    if (!inCommand) {
+      context.error(DiagnosticCodes.InlineEventOutsideCommand, "Inline events can only be declared inside commands", locationOf(header10));
+      context.skipOpaqueBlock(header10.indent);
+      return void 0;
+    }
+    if (inline[2] !== void 0) {
+      context.error(DiagnosticCodes.InlineEventGeneration, "Inline events are generation 1 - extract the event before declaring generations", locationOf(header10));
+    }
+    name = inline[1];
+  } else if (conditional.test(header10.content)) {
+    const child = context.peekChild(header10.indent);
+    if (child === void 0 || !eventName.test(child.content)) {
+      context.error(DiagnosticCodes.ProducesWhenWithoutEvent, "Expected an event name on the line after 'produces when'", locationOf(header10));
+      context.skipOpaqueBlock(header10.indent);
+      return void 0;
+    }
+    context.reader.takeSignificant();
+    parent = child;
+    name = child.content;
+  } else {
+    const plain = plainHeader.exec(header10.content);
+    if (plain === null) {
+      context.error(DiagnosticCodes.InvalidProducesDeclaration, `Invalid produces declaration '${header10.content}' - expected 'produces <EventType>' or 'produces when <condition>'`, locationOf(header10));
+      context.skipOpaqueBlock(header10.indent);
+      return void 0;
+    }
+    name = plain[1];
+  }
+  const properties = [];
+  const propertyNames = /* @__PURE__ */ new Set();
+  const mappings = [];
+  const tags = [];
+  const metadata = new EventMetadataParser(name);
+  let target = null;
+  for (let line = context.peekChild(parent.indent); line !== void 0; line = context.peekChild(parent.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(line.content);
+    const location = locationOf(line);
+    if (reserved.has(keyword)) {
+      context.error(DiagnosticCodes.ReservedProductionMetadata, `'${keyword}' is system-assigned production metadata and cannot be supplied here`, location);
+      context.skipOpaqueBlock(line.indent);
+      continue;
+    }
+    if (inline !== null && (keyword === "generation" || keyword === "origin")) {
+      context.error(keyword === "generation" ? DiagnosticCodes.InlineEventGeneration : DiagnosticCodes.ReservedProductionMetadata, keyword === "generation" ? "Inline events are generation 1 - extract the event before declaring generations" : "An inline event is local to its command and cannot declare origin", location);
+      context.skipOpaqueBlock(line.indent);
+      continue;
+    }
+    if (keyword === "tag") {
+      const tag = parseTag(context, line, false);
+      if (tag !== void 0)
+        tags.push(tag);
+      continue;
+    }
+    const forMatch = targetPattern.exec(line.content);
+    if (forMatch !== null) {
+      if (target !== null) {
+        context.error(DiagnosticCodes.DuplicateProducesTarget, `'${parent.content}' already declares where it lands - an event is appended to one event source`, location);
+      } else {
+        target = parseMappingSource(forMatch[1], location, context);
+      }
+      continue;
+    }
+    const match = (inline === null ? mappingPattern : typedMappingPattern).exec(line.content);
+    let property = match === null || inline === null ? void 0 : parseProperty(context, { ...line, content: match[1].trimEnd() });
+    if (match !== null && (inline === null || property !== void 0)) {
+      if (property !== void 0) {
+        if (property.isIdentifier) {
+          context.error(DiagnosticCodes.IdentifierOnEventProperty, `Property '${property.name}' of event '${name}' cannot be marked identifier - an event never carries its event source id`, location);
+          property = { ...property, isIdentifier: false };
+        }
+        const propertyName = property.name;
+        if (propertyNames.has(propertyName)) {
+          context.error(DiagnosticCodes.DuplicateDeclaration, `Event '${name}' already declares property '${property.name}'`, location);
+        }
+        propertyNames.add(propertyName);
+        properties.push(property);
+      }
+      mappings.push({ kind: "PropertyMappingSyntax", property: property?.name ?? unescapeIdentifier(match[1]), source: parseMappingSource(match[2], location, context), location });
+    } else if (inline === null || !metadata.tryParse(context, line)) {
+      context.error(DiagnosticCodes.InvalidPropertyMapping, `Invalid ${inline === null ? "" : "inline "}property mapping '${line.content}' - expected '<property>${inline === null ? "" : " <Type>"} = <source>'`, location);
+    }
+  }
+  if (parent !== header10)
+    context.skipBlock(header10.indent);
+  return {
+    kind: "ProducesSyntax",
+    event: name,
+    mappings,
+    for: target,
+    tags: inline === null ? tags : [],
+    location: locationOf(header10),
+    inlineEvent: inline === null ? null : { kind: "EventSyntax", name, properties, tags, generation: 1, hasGenerationMarker: false, ...metadata.value, location: locationOf(header10) }
+  };
+}
+
+// ../../Compiler/dist/Parsing/CommandParser.js
+var header2 = pattern("^command\\s+([A-Za-z_]\\w*)$");
+var severityPattern = pattern("\\bseverity\\s+(\\S+)$");
+var messagePattern = pattern(`\\bmessage\\s+(?:"(${stringBodyPattern})"|(\\$strings\\.\\S*))$`);
+var rulePattern = pattern("^([\\w.]+)\\s+(.+)$");
+var operandPattern = pattern("^(not empty|length ==|all >=|all >|matches|max|min|rule|>=|<=|==|!=|>|<)\\s*(.*)$");
+var ruleNamePattern = pattern("^[A-Za-z_]\\w*$");
+var optionalReads = pattern("^reads\\s+[A-Z]\\w*\\s+optional(?:\\s|$)");
+var operandKinds = {
+  max: "Max",
+  min: "Min",
+  ">": "GreaterThan",
+  ">=": "GreaterThanOrEqual",
+  "<": "LessThan",
+  "<=": "LessThanOrEqual",
+  "==": "Equal",
+  "!=": "NotEqual",
+  "length ==": "Length",
+  matches: "Matches",
+  "all >": "AllGreaterThan",
+  "all >=": "AllGreaterThanOrEqual"
+};
+var severities = { information: "Information", warning: "Warning", error: "Error" };
+var opaqueDirectives = /* @__PURE__ */ new Set(["reads", "handler", "concurrency"]);
+var propertyShapedDirectives = /* @__PURE__ */ new Set(["description", "handler", "concurrency"]);
+function parseCommand(context, line) {
+  const name = header2.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidCommandDeclaration, `Invalid command declaration '${line.content}' - expected 'command <Name>'`, locationOf(line));
+  }
+  const properties = [];
+  let identifier;
+  const validations = [];
+  const produces = [];
+  let description = null;
+  let authorize = null;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    const asProperty = tryParseProperty(child);
+    if (asProperty !== void 0 && (propertyShapedDirectives.has(keyword) || keyword === "validate" && child.content !== "validate csharp")) {
+      identifier = addProperty(context, properties, asProperty, name, child, identifier);
+    } else if (keyword === "description") {
+      description = parseDescription(context, child, description, `Command '${name}'`);
+    } else if (keyword === "authorize") {
+      authorize = combineAuthorize(authorize, parseAuthorize(context, child));
+    } else if (keyword === "validate") {
+      const validate = parseValidate(context, child);
+      if (validate !== void 0) {
+        validations.push(validate);
+      }
+    } else if (keyword === "produces") {
+      const production = parseProduces(context, child, true);
+      if (production !== void 0)
+        produces.push(production);
+    } else if (opaqueDirectives.has(keyword)) {
+      if (optionalReads.test(child.content)) {
+        context.error(DiagnosticCodes.OptionalReadsNotSupported, "Optional reads are not yet supported (see #308).", locationOf(child));
+      }
+      context.skipOpaqueBlock(child.indent);
+    } else if (asProperty !== void 0) {
+      identifier = addProperty(context, properties, asProperty, name, child, identifier);
+    } else {
+      reportInvalidModifierOrder(context, child);
+      context.error(DiagnosticCodes.UnknownCommandDirective, `Unexpected '${child.content}' in command body`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  return { kind: "CommandSyntax", name, description, authorize, properties, validations, produces, location: locationOf(line) };
+}
+function addProperty(context, properties, property, commandName, line, identifier) {
+  reportLegacyOptionalSuffix(context, property.type, line);
+  if (property.isIdentifier && identifier !== void 0) {
+    context.error(DiagnosticCodes.DuplicateCommandIdentifier, `Command '${commandName}' already marks '${identifier.name}' as identifier - only one property can be the identifier`, property.location);
+    property = { ...property, isIdentifier: false };
+  }
+  properties.push(property);
+  return identifier ?? (property.isIdentifier ? property : void 0);
+}
+function parseValidate(context, line) {
+  if (line.content === "validate") {
+    const fence = context.peekChild(line.indent);
+    if (fence !== void 0 && fence.content.startsWith("```")) {
+      context.reader.takeSignificant();
+      context.skipFencedBody();
+      return { kind: "CodeValidateSyntax", location: locationOf(line) };
+    }
+    const rules = [];
+    for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+      context.reader.takeSignificant();
+      if (firstWord2(child.content) === "require") {
+        context.skipOpaqueBlock(child.indent);
+        continue;
+      }
+      const rule2 = parseValidationRule(context, child);
+      if (rule2 !== void 0) {
+        rules.push(rule2);
+      }
+    }
+    return { kind: "DeclarativeValidateSyntax", rules, location: locationOf(line) };
+  }
+  if (line.content === "validate csharp") {
+    context.skipOpaqueBlock(line.indent);
+    return { kind: "CodeValidateSyntax", location: locationOf(line) };
+  }
+  context.error(DiagnosticCodes.InvalidValidateDeclaration, `Invalid validate declaration '${line.content}' - expected 'validate' or 'validate csharp'`, locationOf(line));
+  context.skipBlock(line.indent);
+  return void 0;
+}
+function parseValidationRule(context, line) {
+  const { content: withSeverity, message } = splitMessage(line.content);
+  const severity = splitSeverity(context, line, withSeverity);
+  if (severity === void 0) {
+    return void 0;
+  }
+  const match = rulePattern.exec(severity.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidValidationRule, `Invalid validation rule '${line.content}'`, locationOf(line));
+    return void 0;
+  }
+  const parsed = parseRule(context, match[2], line);
+  if (parsed === void 0) {
+    return void 0;
+  }
+  if (parsed.kind === "Rule") {
+    context.skipOpaqueBlock(line.indent);
+  }
+  return {
+    kind: "ValidationRuleSyntax",
+    property: match[1],
+    rule: parsed.kind,
+    value: parsed.value,
+    message,
+    severity: severity.severity,
+    location: locationOf(line)
+  };
+}
+function splitMessage(content) {
+  const match = messagePattern.exec(content);
+  if (match === null) {
+    return { content, message: null };
+  }
+  const message = match[1] !== void 0 ? unescapeString(match[1]) : match[2];
+  return { content: content.substring(0, match.index).trimEnd(), message };
+}
+function splitSeverity(context, line, text) {
+  const match = severityPattern.exec(text);
+  if (match === null) {
+    return { content: text, severity: "Error" };
+  }
+  const severity = severities[match[1]];
+  if (severity === void 0) {
+    context.error(DiagnosticCodes.InvalidValidationSeverity, `Unknown validation severity '${match[1]}' - expected information, warning or error`, locationOf(line));
+    return void 0;
+  }
+  return { content: text.substring(0, match.index).trimEnd(), severity };
+}
+function parseRule(context, rule2, line) {
+  if (rule2 === "not empty") {
+    return { kind: "NotEmpty", value: null };
+  }
+  const operand2 = operandPattern.exec(rule2);
+  if (operand2 === null) {
+    context.error(DiagnosticCodes.InvalidValidationRule, `Invalid validation rule '${line.content}'`, locationOf(line));
+    return void 0;
+  }
+  if (operand2[1] === "rule") {
+    const name = operand2[2].trim();
+    if (!ruleNamePattern.test(name)) {
+      context.error(DiagnosticCodes.InvalidRuleName, `Invalid rule name '${name}' in '${line.content}' - expected 'rule <Name>' with an identifier`, locationOf(line));
+      return void 0;
+    }
+    return { kind: "Rule", value: { kind: "PathExpressionSyntax", path: name, location: locationOf(line) } };
+  }
+  return { kind: operandKinds[operand2[1]], value: parseMappingSource(operand2[2], locationOf(line), context) };
+}
+
+// ../../Compiler/dist/Parsing/ConstraintParser.js
+var header3 = pattern("^constraint\\s+([A-Za-z_]\\w*)$");
+var uniqueEventPattern = pattern("^unique\\s+event\\s+([A-Z]\\w*)$");
+var uniquePropertyPattern = pattern("^unique\\s+([a-z_][\\w.]*(?:\\s*,\\s*[a-z_][\\w.]*)*)\\s+on\\s+([A-Z]\\w*)$");
+var releasePattern = pattern("^released\\s+by\\s+([A-Z]\\w*)$");
+var messagePattern2 = pattern(`^message\\s+"(${stringBodyPattern})"$`);
+var targetOf = (rule2) => rule2.kind === "FileConstraintSyntax" ? void 0 : rule2.event;
+function parseConstraint(context, line) {
+  const headerMatch = header3.exec(line.content);
+  if (headerMatch === null) {
+    context.error(DiagnosticCodes.InvalidConstraintDeclaration, `Invalid constraint declaration '${line.content}' - expected 'constraint <Name>'`, locationOf(line));
+  }
+  const name = headerMatch?.[1] ?? firstWord2(line.content);
+  const rules = [];
+  const releases = [];
+  const releasedEvents = /* @__PURE__ */ new Set();
+  const targets = /* @__PURE__ */ new Set();
+  let message = null;
+  let ignoreCasing = false;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const release = releasePattern.exec(child.content);
+    const text = messagePattern2.exec(child.content);
+    if (release !== null) {
+      if (releasedEvents.has(release[1])) {
+        context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' already releases with event '${release[1]}'`, locationOf(child));
+      } else {
+        releases.push(release[1]);
+        releasedEvents.add(release[1]);
+      }
+    } else if (text !== null) {
+      if (message !== null) {
+        context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' already has a message`, locationOf(child));
+      } else {
+        message = unescapeString(text[1]);
+      }
+    } else if (child.content === "ignore casing") {
+      if (ignoreCasing) {
+        context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' already ignores casing`, locationOf(child));
+      }
+      ignoreCasing = true;
+    } else {
+      addRule(context, name, child, rules, targets);
+    }
+  }
+  for (const release of releases.filter((release2) => targets.has(release2))) {
+    context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' cannot target and release event '${release}'`, locationOf(line));
+  }
+  if (rules.length === 0) {
+    context.error(DiagnosticCodes.ConstraintWithoutRule, `Constraint '${name}' must declare 'unique ... on ...', 'unique event ...' or 'file ...'`, locationOf(line));
+    rules.push(rule(name, locationOf(line), { kind: "UniqueEventConstraintSyntax", event: "" }));
+  }
+  if (rules[0].kind === "FileConstraintSyntax" && (releases.length > 0 || message !== null || ignoreCasing)) {
+    context.error(DiagnosticCodes.InvalidConstraintBody, `File constraint '${name}' cannot have declarative options`, locationOf(line));
+  }
+  return { ...rules[0], additionalRules: rules.slice(1), releasedBy: releases, message, ignoreCasing };
+}
+function addRule(context, name, line, rules, targets) {
+  const parsed = parseRule2(context, name, line);
+  if (parsed === void 0) {
+    return;
+  }
+  if (rules.length > 0 && (parsed.kind === "FileConstraintSyntax" || rules[0].kind === "FileConstraintSyntax" || parsed.kind === "UniqueEventConstraintSyntax" !== (rules[0].kind === "UniqueEventConstraintSyntax"))) {
+    context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' cannot mix constraint kinds`, locationOf(line));
+    return;
+  }
+  const target = targetOf(parsed);
+  if (target !== void 0 && targets.has(target)) {
+    context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' already targets event '${target}'`, locationOf(line));
+    return;
+  }
+  if (target !== void 0)
+    targets.add(target);
+  rules.push(parsed);
+}
+function parseRule2(context, name, line) {
+  const location = locationOf(line);
+  const uniqueEvent = uniqueEventPattern.exec(line.content);
+  if (uniqueEvent !== null) {
+    return rule(name, location, { kind: "UniqueEventConstraintSyntax", event: uniqueEvent[1] });
+  }
+  const uniqueProperty = uniquePropertyPattern.exec(line.content);
+  if (uniqueProperty !== null) {
+    const properties = uniqueProperty[1].split(",").map((property) => property.trim());
+    if (new Set(properties).size !== properties.length) {
+      context.error(DiagnosticCodes.DuplicateConstraintBody, `Constraint '${name}' repeats a property in its composite key`, location);
+      return void 0;
+    }
+    return rule(name, location, { kind: "UniquePropertyConstraintSyntax", property: properties[0], additionalProperties: properties.slice(1), event: uniqueProperty[2] });
+  }
+  if (isFileDirective(line)) {
+    context.warning(DiagnosticCodes.FileConstraintOnlySupportsUniqueness, "A file constraint can only declare unique constraints in Chronicle - declare them with 'unique ...' so they are portable; a rule that is not uniqueness belongs in command validation or a 'require' condition", location);
+    const path = line.content.substring("file".length).trim();
+    return rule(name, location, { kind: "FileConstraintSyntax", file: { kind: "FileReferenceSyntax", path, location } });
+  }
+  context.error(DiagnosticCodes.InvalidConstraintBody, `Invalid constraint body '${line.content}'`, location);
+  return void 0;
+}
+function rule(name, location, shape) {
+  return { ...shape, name, additionalRules: [], releasedBy: [], ignoreCasing: false, message: null, location };
+}
+
+// ../../Compiler/dist/Parsing/ProjectionParser.js
+var header4 = pattern("^projection\\s+(@?[\\w.]+)\\s*(?:=>\\s*([\\w.]+))?$");
+var eventSpecPattern = pattern("^(@?[\\w.]+)(?:\\s+key\\s+(.+))?$");
+var joinPattern = pattern("^join\\s+(@?[\\w.]+)\\s+on\\s+(@?[\\w.]+)$");
+var withPattern = pattern("^with\\s+(@?[\\w.]+)$");
+var childrenPattern2 = pattern("^children\\s+(@?[\\w.]+)\\s+identified\\s+by\\s+(.+)$");
+var nestedPattern2 = pattern("^nested\\s+(@?[\\w.]+)$");
+var removeWithPattern = pattern("^remove\\s+with\\s+(@?[\\w.]+)(?:\\s+key\\s+(.+))?$");
+var removeViaJoinPattern = pattern("^remove\\s+via\\s+join\\s+on\\s+(@?[\\w.]+)(?:\\s+key\\s+(.+))?$");
+var clearWithPattern = pattern("^clear\\s+with\\s+(@?[\\w.]+)$");
+var variantPattern = pattern("^variant\\s+(@?[\\w.]+)\\s*$");
+var entersOnPattern = pattern("^enters\\s+on\\s+(@?[\\w.]+)(?:\\s+key\\s+(.+))?$");
+var keywordMappingPattern = pattern("^(increment|decrement|count|clear)\\s+(@?[$\\w.]+)$");
+var arithmeticPattern = pattern("^(add|subtract)\\s+(@?[$\\w.]+)\\s+by\\s+(.+)$");
+var setPattern = pattern("^set\\s+(@?[$\\w.]+)\\s+(?:=|to)\\s+(.+)$");
+var assignmentPattern = pattern("^(@?[$\\w.@]+)\\s*=(?!=|>)\\s*(.+)$");
+var keywordMappings = {
+  increment: "IncrementMappingSyntax",
+  decrement: "DecrementMappingSyntax",
+  clear: "ClearMappingSyntax",
+  count: "CountMappingSyntax"
+};
+function parseProjection(context, line) {
+  const match = header4.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidProjectionDeclaration, `Invalid projection declaration '${line.content}' - expected 'projection <Name> [=> <ReadModel>]'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "ProjectionSyntax", name: firstWord2(line.content), readModel: null, sequence: null, autoMap: "Inherit", blocks: [], location: locationOf(line) };
+  }
+  const name = match[1];
+  let sequence = null;
+  let autoMap = "Inherit";
+  const blocks = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (isFileDirective(child)) {
+      continue;
+    }
+    const keyword = firstWord2(child.content);
+    if (keyword === "sequence") {
+      sequence = child.content.substring("sequence".length).trim();
+    } else if (keyword === "automap") {
+      autoMap = "Enabled";
+    } else if (child.content === "no automap") {
+      autoMap = "Disabled";
+    } else if (keyword === "key") {
+      skipKey(context, child);
+    } else if (keyword === "variant") {
+      blocks.push(parseVariant(context, child));
+    } else {
+      const block = parseBlock(context, child, false);
+      if (block !== void 0) {
+        blocks.push(block);
+      }
+    }
+  }
+  reportVariantConflicts(context, blocks, name);
+  if (blocks.length === 0) {
+    context.error(DiagnosticCodes.EmptyProjection, `Projection '${name}' must contain at least one directive`, locationOf(line));
+  }
+  return { kind: "ProjectionSyntax", name, readModel: match[2] ?? null, sequence, autoMap, blocks, location: locationOf(line) };
+}
+function reportVariantConflicts(context, blocks, name) {
+  const variants = blocks.filter((block) => block.kind === "ProjectionVariantSyntax");
+  const byName = /* @__PURE__ */ new Map();
+  variants.forEach((variant) => byName.set(variant.name, [...byName.get(variant.name) ?? [], variant]));
+  for (const duplicate of [...byName.values()].flatMap((group) => group.slice(1))) {
+    context.error(DiagnosticCodes.DuplicateProjectionVariant, `Duplicate variant '${duplicate.name}' - a variant name is declared once`, duplicate.location);
+  }
+  const entering = /* @__PURE__ */ new Set();
+  for (const entry of blocks.flatMap((block) => block.kind === "ProjectionVariantSyntax" ? block.entersOn : [])) {
+    if (entry.event.length > 0 && entering.has(entry.event)) {
+      context.error(DiagnosticCodes.DuplicateVariantEnteringEvent, `Entering event '${entry.event}' is claimed more than once in projection '${name}'`, entry.location);
+    }
+    entering.add(entry.event);
+  }
+}
+function parseBlock(context, line, nestedScope) {
+  const location = locationOf(line);
+  switch (firstWord2(line.content)) {
+    case "from":
+      return parseFrom(context, line);
+    case "every": {
+      let includeChildren = true;
+      const { autoMap, mappings } = parseMappingBlock(context, line, (child) => {
+        if (child.content !== "exclude children") {
+          return false;
+        }
+        includeChildren = false;
+        return true;
+      });
+      return { kind: "EverySyntax", includeChildren, autoMap, mappings, location };
+    }
+    case "all": {
+      const { autoMap, mappings } = parseMappingBlock(context, line);
+      return { kind: "AllSyntax", autoMap, mappings, location };
+    }
+    case "join":
+      return parseJoin(context, line);
+    case "children":
+      return parseChildren(context, line);
+    case "nested":
+      return parseNested(context, line);
+    case "remove":
+      return parseRemove(context, line);
+    case "clear":
+      if (!nestedScope) {
+        context.error(DiagnosticCodes.ClearWithOutsideNestedBlock, "'clear with' is only valid inside a nested block", location);
+      }
+      return parseClearWith(context, line);
+    default:
+      context.error(DiagnosticCodes.UnknownProjectionDirective, `Unexpected '${firstWord2(line.content)}' in projection body`, location);
+      context.skipBlock(line.indent);
+      return void 0;
+  }
+}
+function parseFrom(context, line) {
+  const events = [];
+  for (const spec of splitTopLevel(line.content.substring("from".length), ",")) {
+    const text = spec.trim();
+    if (text.length === 0) {
+      context.error(DiagnosticCodes.FromWithoutEvent, "Expected an event type after 'from'", locationOf(line));
+      continue;
+    }
+    const match = eventSpecPattern.exec(text);
+    if (match === null) {
+      context.error(DiagnosticCodes.InvalidEventReference, `Invalid event reference '${text}'`, locationOf(line));
+      continue;
+    }
+    events.push({ kind: "EventSpecSyntax", event: unescapeIdentifier(match[1]), location: locationOf(line) });
+  }
+  const mappings = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "key") {
+      skipKey(context, child);
+    } else if (keyword !== "parent") {
+      pushMapping(child, mappings);
+    }
+  }
+  return { kind: "FromSyntax", events, mappings, location: locationOf(line) };
+}
+function parseJoin(context, line) {
+  const match = joinPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidJoinDeclaration, `Invalid join declaration '${line.content}' - expected 'join <property> on <key>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "JoinSyntax", property: "", on: "", events: [], location: locationOf(line) };
+  }
+  const events = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const withMatch = withPattern.exec(child.content);
+    if (withMatch === null) {
+      context.error(DiagnosticCodes.JoinWithoutEvent, `Expected 'with <EventType>' in join block, got '${child.content}'`, locationOf(child));
+      context.skipBlock(child.indent);
+      continue;
+    }
+    const { autoMap, mappings } = parseMappingBlock(context, child);
+    events.push({ kind: "JoinEventSyntax", event: unescapeIdentifier(withMatch[1]), autoMap, mappings, location: locationOf(child) });
+  }
+  return { kind: "JoinSyntax", property: unescapeIdentifier(match[1]), on: unescapeIdentifier(match[2]), events, location: locationOf(line) };
+}
+function parseChildren(context, line) {
+  const match = childrenPattern2.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidChildrenDeclaration, `Invalid children declaration '${line.content}' - expected 'children <collection> identified by <key>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "ChildrenSyntax", property: "", autoMap: "Inherit", blocks: [], location: locationOf(line) };
+  }
+  const { autoMap, blocks } = parseChildBlocks(context, line);
+  return { kind: "ChildrenSyntax", property: unescapeIdentifier(match[1]), autoMap, blocks, location: locationOf(line) };
+}
+function parseNested(context, line) {
+  const match = nestedPattern2.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidNestedDeclaration, `Invalid nested declaration '${line.content}' - expected 'nested <property>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "NestedSyntax", property: "", autoMap: "Inherit", blocks: [], location: locationOf(line) };
+  }
+  const property = unescapeIdentifier(match[1]);
+  const { autoMap, blocks } = parseChildBlocks(context, line);
+  if (!blocks.some((block) => block.kind === "FromSyntax")) {
+    context.error(DiagnosticCodes.NestedBlockWithoutFrom, `Nested block '${property}' must contain at least one 'from' directive`, locationOf(line));
+  }
+  return { kind: "NestedSyntax", property, autoMap, blocks, location: locationOf(line) };
+}
+function parseChildBlocks(context, line) {
+  const blocks = [];
+  let autoMap = "Inherit";
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (child.content === "automap") {
+      autoMap = "Enabled";
+      continue;
+    }
+    if (child.content === "no automap") {
+      autoMap = "Disabled";
+      continue;
+    }
+    const block = parseBlock(context, child, true);
+    if (block !== void 0) {
+      blocks.push(block);
+    }
+  }
+  return { autoMap, blocks };
+}
+function parseRemove(context, line) {
+  const viaJoin = removeViaJoinPattern.exec(line.content);
+  if (viaJoin !== null) {
+    return { kind: "RemoveViaJoinSyntax", event: unescapeIdentifier(viaJoin[1]), location: locationOf(line) };
+  }
+  const match = removeWithPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidRemoveDeclaration, `Invalid remove declaration '${line.content}' - expected 'remove with <EventType>' or 'remove via join on <EventType>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return void 0;
+  }
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (firstWord2(child.content) !== "parent") {
+      context.error(DiagnosticCodes.UnknownRemoveDirective, `Unexpected '${child.content}' in remove block - only 'parent' is allowed`, locationOf(child));
+    }
+  }
+  return { kind: "RemoveWithSyntax", event: unescapeIdentifier(match[1]), location: locationOf(line) };
+}
+function parseClearWith(context, line) {
+  const match = clearWithPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidClearDeclaration, `Invalid clear declaration '${line.content}' - expected 'clear with <EventType>'`, locationOf(line));
+    return { kind: "ClearWithSyntax", event: "", location: locationOf(line) };
+  }
+  return { kind: "ClearWithSyntax", event: unescapeIdentifier(match[1]), location: locationOf(line) };
+}
+function parseVariant(context, line) {
+  const match = variantPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidProjectionVariantDeclaration, `Invalid variant declaration '${line.content}' - expected 'variant <Name>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "ProjectionVariantSyntax", name: firstWord2(line.content), entersOn: [], blocks: [], location: locationOf(line) };
+  }
+  const name = unescapeIdentifier(match[1]);
+  const entersOn = [];
+  const blocks = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "enters") {
+      entersOn.push(parseEntersOn(context, child));
+    } else if (keyword === "variant") {
+      context.error(DiagnosticCodes.NestedProjectionVariantNotAllowed, "A variant cannot be declared inside another variant", locationOf(child));
+      context.skipBlock(child.indent);
+    } else {
+      const block = parseBlock(context, child, false);
+      if (block !== void 0) {
+        blocks.push(block);
+      }
+    }
+  }
+  if (entersOn.length === 0) {
+    context.error(DiagnosticCodes.VariantRequiresEnteringEvent, `Variant '${name}' must declare at least one 'enters on' event`, locationOf(line));
+  }
+  return { kind: "ProjectionVariantSyntax", name, entersOn, blocks, location: locationOf(line) };
+}
+function parseEntersOn(context, line) {
+  const match = entersOnPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidEntersOnDeclaration, `Invalid 'enters on' declaration '${line.content}' - expected 'enters on <EventType> [key <expression>]'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return { kind: "ProjectionEntersOnSyntax", event: "", location: locationOf(line) };
+  }
+  return { kind: "ProjectionEntersOnSyntax", event: unescapeIdentifier(match[1]), location: locationOf(line) };
+}
+function skipKey(context, line) {
+  if (context.peekChild(line.indent) === void 0) {
+    return;
+  }
+  context.skipBlock(line.indent);
+  const closing = context.reader.peekSignificant();
+  if (closing !== void 0 && closing.indent === line.indent && closing.content === "}") {
+    context.reader.takeSignificant();
+  }
+}
+function parseMappingBlock(context, line, extra = () => false) {
+  let autoMap = "Inherit";
+  const mappings = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (child.content === "automap") {
+      autoMap = "Enabled";
+    } else if (child.content === "no automap") {
+      autoMap = "Disabled";
+    } else if (!extra(child)) {
+      pushMapping(child, mappings);
+    }
+  }
+  return { autoMap, mappings };
+}
+function pushMapping(line, mappings) {
+  const location = locationOf(line);
+  const keyword = keywordMappingPattern.exec(line.content);
+  if (keyword !== null) {
+    if (keyword[1] !== "clear" || keyword[2] !== "with") {
+      mappings.push({ kind: keywordMappings[keyword[1]], property: unescapeIdentifier(keyword[2]), location });
+    }
+    return;
+  }
+  const arithmetic = arithmeticPattern.exec(line.content);
+  if (arithmetic !== null) {
+    mappings.push({ kind: arithmetic[1] === "add" ? "AddMappingSyntax" : "SubtractMappingSyntax", property: unescapeIdentifier(arithmetic[2]), location });
+    return;
+  }
+  const assigned = setPattern.exec(line.content) ?? assignmentPattern.exec(line.content);
+  if (assigned !== null) {
+    mappings.push({ kind: "SetMappingSyntax", property: unescapeIdentifier(assigned[1]), location });
+  }
+}
+
+// ../../Compiler/dist/Parsing/QueryParser.js
+var header5 = pattern("^query\\s+([A-Za-z_]\\w*)\\s*=>\\s*(observable\\s+)?([\\w.]+(?:\\[\\])?(?:\\?|\\s+optional)?)$");
+var parameterPattern = pattern("^([a-z_]\\w*)\\s+([\\w.]+(?:\\[\\])?(?:\\?|\\s+optional)?)(?:\\s+from\\s+(.+))?$");
+var scopePattern = pattern("^scoped\\s+to\\s+([a-z_]\\w*)$");
+var opaqueDirectives2 = /* @__PURE__ */ new Set(["performer"]);
+function parseQuery(context, line) {
+  const match = header5.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidQueryDeclaration, `Invalid query declaration '${line.content}' - expected 'query <Name> => [observable] <ReadModel>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return {
+      kind: "QuerySyntax",
+      name: firstWord2(line.content),
+      returnType: parseTypeRef("", locationOf(line)),
+      by: null,
+      filters: [],
+      description: null,
+      isObservable: false,
+      scope: null,
+      authorize: null,
+      location: locationOf(line)
+    };
+  }
+  const name = match[1];
+  const returnType = parseTypeRef(match[3], { ...locationOf(line), column: line.indent + 1 + match[0].length - match[3].length });
+  if (!(match[2] === void 0 && returnType.name === "observable" && returnType.isOptional && !returnType.isCollection)) {
+    reportLegacyOptionalSuffix(context, returnType, line);
+  }
+  let by = null;
+  const filters = [];
+  let description = null;
+  let scope = null;
+  let authorize = null;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "description") {
+      description = parseDescription(context, child, description, `Query '${name}'`);
+    } else if (keyword === "by") {
+      const parameter = parseParameter(context, child, "by");
+      if (parameter !== void 0) {
+        if (by !== null) {
+          context.error(DiagnosticCodes.InvalidQueryParameter, `Query '${name}' already declares 'by' - a query can have at most one key parameter`, locationOf(child));
+        }
+        by = parameter;
+      }
+    } else if (keyword === "filter") {
+      const filter = parseParameter(context, child, "filter");
+      if (filter !== void 0) {
+        filters.push(filter);
+      }
+    } else if (keyword === "authorize") {
+      authorize = combineAuthorize(authorize, parseAuthorize(context, child));
+    } else if (keyword === "scoped") {
+      scope = parseScope(context, child, scope, name) ?? scope;
+    } else if (opaqueDirectives2.has(keyword)) {
+      context.skipOpaqueBlock(child.indent);
+    } else {
+      context.error(DiagnosticCodes.UnknownQueryDirective, `Unexpected '${child.content}' in query body - expected description, by, filter, authorize, scoped or performer`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  return {
+    kind: "QuerySyntax",
+    name,
+    returnType,
+    by,
+    filters,
+    description,
+    isObservable: match[2] !== void 0,
+    scope,
+    authorize,
+    location: locationOf(line)
+  };
+}
+function parseParameter(context, line, keyword) {
+  const match = parameterPattern.exec(line.content.substring(keyword.length).trim());
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidQueryParameter, `Invalid '${keyword}' parameter '${line.content}' - expected '${keyword} <name> <Type> [from <source>]'`, locationOf(line));
+    return void 0;
+  }
+  const nameOffset = line.content.indexOf(match[1], keyword.length);
+  const type = parseTypeRef(match[2], { ...locationOf(line), column: line.indent + 1 + line.content.indexOf(match[2], nameOffset + match[1].length) });
+  reportLegacyOptionalSuffix(context, type, line);
+  return { kind: "QueryParameterSyntax", name: match[1], type, location: locationOf(line) };
+}
+function parseScope(context, line, existing, queryName) {
+  const match = scopePattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidScopeDeclaration, `Invalid scope declaration '${line.content}' - expected 'scoped to <scope>'`, locationOf(line));
+    return void 0;
+  }
+  if (existing !== null) {
+    context.error(DiagnosticCodes.DuplicateScope, `Query '${queryName}' already declares a scope - results are narrowed one way`, locationOf(line));
+    return void 0;
+  }
+  return match[1];
+}
+
+// ../../Compiler/dist/Parsing/TriggerDataParser.js
+var typedValue = pattern("^@?[a-z_]\\w*\\s+[\\w.]+");
+function parseTriggerData(context, line) {
+  const property = parseProperty(context, line);
+  if (property !== void 0) {
+    context.triggerData.push(property);
+    return;
+  }
+  if (typedValue.test(line.content) && /\?|\boptional\b/.test(line.content)) {
+    context.error(DiagnosticCodes.InvalidTriggerData, `Invalid trigger value '${line.content}' - expected '<name>' or '<name> <Type>'`, locationOf(line));
+  }
+  context.skipOpaqueBlock(line.indent);
+}
+function parseTriggerDeclaration(context, header10) {
+  for (let line = context.peekChild(header10.indent); line !== void 0; line = context.peekChild(header10.indent)) {
+    context.reader.takeSignificant();
+    if (firstWord2(line.content) === "description") {
+      parseDescription(context, line, null, `Trigger '${header10.content}'`);
+    } else if (!isFileDirective(line)) {
+      parseTriggerData(context, line);
+    }
+  }
+}
+
+// ../../Compiler/dist/Parsing/ReactionParser.js
+var header6 = pattern("^reaction\\s+([A-Za-z_]\\w*)$");
+var whenPattern = pattern("^when\\s+([A-Za-z_]\\w*)$");
+var everyPattern = pattern("^every\\s+(\\d+)\\s+(seconds?|minutes?|hours?|days?)$");
+var atPattern = pattern("^at\\s+(\\d{2}:\\d{2})(?:\\s+on\\s+(?:(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)|day\\s+(\\d{1,2})))?$");
+var clauseKeywords2 = /* @__PURE__ */ new Set(["when", "every", "at"]);
+var invokesPattern = pattern("^invokes\\s+([A-Z]\\w*)$");
+var optionalReads2 = pattern("^reads\\s+[A-Z]\\w*\\s+optional(?:\\s|$)");
+function parseReaction(context, line) {
+  const name = header6.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidReactionDeclaration, `Invalid reaction declaration '${line.content}' - expected 'reaction <Name>'`, locationOf(line));
+  }
+  let description = null;
+  const triggers = [];
+  const sources = /* @__PURE__ */ new Set();
+  let reported = false;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "description") {
+      description = parseDescription(context, child, description, `Reaction '${name}'`);
+      continue;
+    }
+    if (keyword === "where") {
+      continue;
+    }
+    if (!clauseKeywords2.has(keyword)) {
+      context.error(DiagnosticCodes.InvalidReactionTrigger, `Expected a trigger in reaction body, got '${child.content}' - a reaction is set off by 'when <Name>', 'every <n> <unit>' or 'at <HH:mm>'`, locationOf(child));
+      context.skipBlock(child.indent);
+      reported = true;
+      continue;
+    }
+    const source = parseTriggerSource(context, child);
+    if (source === void 0) {
+      reported = true;
+      continue;
+    }
+    const key = sourceKey(source);
+    if (sources.has(key)) {
+      context.error(DiagnosticCodes.DuplicateReactionTrigger, `Reaction '${name}' already declares '${child.content}' - a second says nothing the first did not`, locationOf(child));
+      context.skipBlock(child.indent);
+      continue;
+    }
+    sources.add(key);
+    triggers.push(parseTrigger(context, child, source));
+  }
+  if (triggers.length === 0 && !reported) {
+    context.error(DiagnosticCodes.ReactionWithoutTrigger, `Reaction '${name}' must declare at least one trigger - nothing sets it off`, locationOf(line));
+  }
+  return { kind: "ReactionSyntax", name, description, triggers, location: locationOf(line) };
+}
+function parseTrigger(context, line, source) {
+  let description = null;
+  const produces = [];
+  const invokes = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "description") {
+      description = parseDescription(context, child, description, `Trigger '${child.content}'`);
+    } else if (keyword === "produces") {
+      const produced = parseProduces(context, child);
+      if (produced !== void 0) {
+        produces.push(produced);
+      }
+    } else if (keyword === "invokes") {
+      const match = invokesPattern.exec(child.content);
+      if (match === null) {
+        context.error(DiagnosticCodes.InvalidInvokesDeclaration, `Invalid invokes declaration '${child.content}' - expected 'invokes <Command>'`, locationOf(child));
+        context.skipBlock(child.indent);
+      } else {
+        invokes.push({ kind: "InvokesSyntax", command: match[1], location: locationOf(child) });
+        context.skipOpaqueBlock(child.indent);
+      }
+    } else if (keyword === "reads" || keyword === "file" || child.content === "csharp" || child.content.startsWith("```")) {
+      if (optionalReads2.test(child.content)) {
+        context.error(DiagnosticCodes.OptionalReadsNotSupported, "Optional reads are not yet supported (see #308).", locationOf(child));
+      }
+      if (child.content.startsWith("```")) {
+        context.skipFencedBody();
+      }
+      context.skipOpaqueBlock(child.indent);
+    } else {
+      parseTriggerData(context, child);
+    }
+  }
+  return { kind: "ReactionTriggerSyntax", source, description, produces, invokes, location: locationOf(line) };
+}
+function sourceKey(source) {
+  switch (source.kind) {
+    case "NamedTriggerSourceSyntax":
+      return JSON.stringify([source.kind, source.name]);
+    case "IntervalTriggerSourceSyntax":
+      return JSON.stringify([source.kind, source.amount, source.unit]);
+    case "ScheduleTriggerSourceSyntax":
+      return JSON.stringify([source.kind, source.time, source.dayOfWeek, source.dayOfMonth]);
+  }
+}
+function parseTriggerSource(context, line) {
+  const location = locationOf(line);
+  switch (firstWord2(line.content)) {
+    case "when": {
+      const match = whenPattern.exec(line.content);
+      if (match === null) {
+        context.error(DiagnosticCodes.InvalidReactionTrigger, `Invalid trigger '${line.content}' - expected 'when <Name>'`, location);
+        context.skipBlock(line.indent);
+        return void 0;
+      }
+      return { kind: "NamedTriggerSourceSyntax", name: match[1], location };
+    }
+    case "every": {
+      const match = everyPattern.exec(line.content);
+      const amount = match === null ? NaN : Number(match[1]);
+      if (match === null || !Number.isInteger(amount) || amount < 1 || amount > 2147483647) {
+        context.error(DiagnosticCodes.InvalidIntervalTrigger, `Invalid interval '${line.content}' - expected 'every <n> <seconds|minutes|hours|days>'`, location);
+        context.skipBlock(line.indent);
+        return void 0;
+      }
+      return { kind: "IntervalTriggerSourceSyntax", amount, unit: unitOf(match[2]), location };
+    }
+    default:
+      return parseSchedule(context, line);
+  }
+}
+function parseSchedule(context, line) {
+  const location = locationOf(line);
+  const match = atPattern.exec(line.content);
+  const time = match === null ? void 0 : timeOf(match[1]);
+  if (match === null || time === void 0) {
+    context.error(DiagnosticCodes.InvalidScheduleTrigger, `Invalid schedule '${line.content}' - expected 'at <HH:mm>', optionally followed by 'on <Weekday>' or 'on day <n>'`, location);
+    context.skipBlock(line.indent);
+    return void 0;
+  }
+  if (match[3] !== void 0) {
+    const day = Number(match[3]);
+    if (day < 1 || day > 31) {
+      context.error(DiagnosticCodes.InvalidScheduleTrigger, `Invalid day of month '${day}' in '${line.content}' - a day of the month is between 1 and 31`, location);
+      context.skipBlock(line.indent);
+      return void 0;
+    }
+    return { kind: "ScheduleTriggerSourceSyntax", time, dayOfWeek: null, dayOfMonth: day, location };
+  }
+  return { kind: "ScheduleTriggerSourceSyntax", time, dayOfWeek: match[2] ?? null, dayOfMonth: null, location };
+}
+function timeOf(text) {
+  const [hours, minutes] = text.split(":").map(Number);
+  if (!(hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59)) {
+    return void 0;
+  }
+  return `${text}:00.0000000`;
+}
+function unitOf(text) {
+  switch (text.replace(/s+$/, "")) {
+    case "second":
+      return "Seconds";
+    case "minute":
+      return "Minutes";
+    case "hour":
+      return "Hours";
+    default:
+      return "Days";
+  }
+}
+
+// ../../Compiler/dist/Parsing/ScreenParser.js
+var operand = `(?:"(${stringBodyPattern})"|(\\$strings\\.\\w+(?:\\.\\w+)*))`;
+var header7 = pattern("^screen\\s+([A-Za-z_]\\w*)$");
+var data = pattern("^data\\s+([\\w.]+(?:\\[\\])?)\\s+via\\s+query\\s+(\\w+(?:\\.\\w+)*)(?:\\s+by\\s+(\\w+))?$");
+var action = pattern("^action\\s+([A-Za-z_]\\w*(?:\\.\\w+)*)$");
+var label = pattern(`^label\\s+${operand}$`);
+var navigate = pattern("^navigate\\s+to\\s+(\\w+(?:\\.\\w+)*)(?:\\s+by\\s+(\\w+))?$");
+var slot = pattern("^[a-z_]\\w*$");
+var title = pattern(`^title\\s+${operand}$`);
+var column = pattern(`^column\\s+([\\w.]+)(?:\\s+label\\s+${operand})?$`);
+var rowClick = pattern("^on\\s+row-click\\s+(navigate\\s+to\\s+.+)$");
+var field = pattern(`^field\\s+([\\w.]+)\\s+label\\s+${operand}$`);
+var inlineLanguages = /* @__PURE__ */ new Set(["csharp", "typescript", "react", "html", "sql"]);
+var operandText = (match, quotedGroup) => match[quotedGroup] !== void 0 ? unescapeString(match[quotedGroup]) : match[quotedGroup + 1];
+var isInteraction = (line) => ["on", "uses"].includes(firstWord2(line.content));
+var isCodeLine = (line) => line.content.startsWith("```") || inlineLanguages.has(line.content);
+function parseScreen(context, line) {
+  const match = header7.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidScreenDeclaration, `Invalid screen declaration '${line.content}' - expected 'screen <Name>'`, locationOf(line));
+  }
+  const directives = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (!isFileDirective(child)) {
+      pushDirective(context, child, directives);
+    }
+  }
+  return { kind: "ScreenSyntax", name: match?.[1] ?? "", directives, location: locationOf(line) };
+}
+function pushDirective(context, line, directives) {
+  const directive = parseDirective(context, line);
+  if (directive !== void 0) {
+    directives.push(directive);
+  }
+}
+function parseDirectives(context, parent) {
+  const directives = [];
+  for (let child = context.peekChild(parent.indent); child !== void 0; child = context.peekChild(parent.indent)) {
+    context.reader.takeSignificant();
+    pushDirective(context, child, directives);
+  }
+  return directives;
+}
+function parseDirective(context, line) {
+  switch (firstWord2(line.content)) {
+    case "data":
+      return parseData(context, line);
+    case "action":
+      return parseAction(context, line);
+    case "template":
+      return parseTemplateReference(context, line);
+    case "section":
+      return parseSection(context, line);
+    case "title":
+      return parseTitle(context, line);
+    case "table":
+      return parseTable(context, line);
+    case "summary":
+      return parseSummary(context, line);
+    case "navigate":
+      return parseNavigate(context, line.content, line);
+    case "on":
+      context.skipOpaqueBlock(line.indent);
+      return { kind: "ScreenBehaviorSyntax", location: locationOf(line) };
+    case "uses":
+      context.skipOpaqueBlock(line.indent);
+      return { kind: "ScreenUsesBehaviorSyntax", location: locationOf(line) };
+    default:
+      if (isCodeLine(line)) {
+        return parseCode(context, line);
+      }
+      context.error(DiagnosticCodes.UnknownScreenDirective, `Unexpected '${line.content}' in screen body`, locationOf(line));
+      context.skipBlock(line.indent);
+      return void 0;
+  }
+}
+function parseData(context, line) {
+  const match = data.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidDataDirective, `Invalid data directive '${line.content}' - expected 'data <ReadModel> via query <Query> [by <param>]'`, locationOf(line));
+    return void 0;
+  }
+  return { kind: "ScreenDataSyntax", type: parseTypeRef(match[1], locationOf(line)), query: match[2], by: match[3] ?? null, location: locationOf(line) };
+}
+function parseAction(context, line) {
+  const match = action.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidActionDirective, `Invalid action directive '${line.content}' - expected 'action <Command>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return void 0;
+  }
+  let text = null;
+  let target = null;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const labelMatch = label.exec(child.content);
+    if (labelMatch !== null) {
+      text = operandText(labelMatch, 1);
+    } else if (firstWord2(child.content) === "navigate") {
+      target = parseNavigate(context, child.content, child) ?? null;
+    } else {
+      context.error(DiagnosticCodes.UnknownActionDirective, `Unexpected '${child.content}' in action - expected 'label "..."' or 'navigate to ...'`, locationOf(child));
+    }
+  }
+  return { kind: "ScreenActionSyntax", command: match[1], label: text, navigate: target, location: locationOf(line) };
+}
+function parseNavigate(context, text, line) {
+  const match = navigate.exec(text);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidNavigation, `Invalid navigation '${text}' - expected 'navigate to <Screen> [by <param>]'`, locationOf(line));
+    return void 0;
+  }
+  return { kind: "ScreenNavigateSyntax", screen: match[1], by: match[2] ?? null, location: locationOf(line) };
+}
+function parseTemplateReference(context, line) {
+  const name = line.content.substring("template".length).trim();
+  const slots = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (!slot.test(child.content)) {
+      context.error(DiagnosticCodes.InvalidScreenLayoutSlot, `Expected a slot name in template '${name}', got '${child.content}'`, locationOf(child));
+      context.skipBlock(child.indent);
+      continue;
+    }
+    slots.push({ kind: "ScreenSlotSyntax", name: child.content, directives: parseDirectives(context, child), location: locationOf(child) });
+  }
+  return { kind: "ScreenTemplateReferenceSyntax", name, slots, location: locationOf(line) };
+}
+function parseSection(context, line) {
+  const name = line.content.substring("section".length).trim();
+  return { kind: "ScreenSectionSyntax", name, directives: parseDirectives(context, line), location: locationOf(line) };
+}
+function parseTitle(context, line) {
+  const match = title.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidTitleDirective, `Invalid title directive '${line.content}' - expected 'title "..."'`, locationOf(line));
+    return { kind: "ScreenTitleSyntax", text: "", location: locationOf(line) };
+  }
+  return { kind: "ScreenTitleSyntax", text: operandText(match, 1), location: locationOf(line) };
+}
+function parseTable(context, line) {
+  const target = line.content.substring("table".length).trim();
+  const columns = [];
+  let click = null;
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const columnMatch = column.exec(child.content);
+    const clickMatch = rowClick.exec(child.content);
+    if (columnMatch !== null) {
+      const labelled = columnMatch[2] !== void 0 || columnMatch[3] !== void 0;
+      columns.push({ kind: "ScreenColumnSyntax", property: columnMatch[1], label: labelled ? operandText(columnMatch, 2) : null, location: locationOf(child) });
+    } else if (clickMatch !== null) {
+      click = parseNavigate(context, clickMatch[1], child) ?? null;
+    } else if (isInteraction(child)) {
+      context.skipOpaqueBlock(child.indent);
+    } else {
+      context.error(DiagnosticCodes.UnknownTableDirective, `Unexpected '${child.content}' in table - expected 'column ...', 'on row-click navigate to ...', 'on <trigger>' or 'uses <Behavior>'`, locationOf(child));
+    }
+  }
+  return { kind: "ScreenTableSyntax", target, columns, rowClick: click, location: locationOf(line) };
+}
+function parseSummary(context, line) {
+  const target = line.content.substring("summary".length).trim();
+  const fields = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const match = field.exec(child.content);
+    if (match === null) {
+      context.error(DiagnosticCodes.UnknownSummaryDirective, `Unexpected '${child.content}' in summary - expected 'field <property> label "..."'`, locationOf(child));
+      continue;
+    }
+    fields.push({ kind: "ScreenFieldSyntax", property: match[1], label: operandText(match, 2), location: locationOf(child) });
+  }
+  return { kind: "ScreenSummarySyntax", target, fields, location: locationOf(line) };
+}
+function parseCode(context, line) {
+  const language = line.content.startsWith("```") ? line.content.substring(3) : line.content;
+  if (!inlineLanguages.has(language)) {
+    context.error(DiagnosticCodes.ExpectedCodeFence, `Expected a registered language on the opening fence, not '${line.content}'`, locationOf(line));
+    return void 0;
+  }
+  if (!line.content.startsWith("```")) {
+    context.warning(DiagnosticCodes.LegacyInlineCodeFence, `'${language}' on its own line is deprecated - use '\`\`\`${language}' instead`, locationOf(line));
+  }
+  const code = parseFencedText(context, language, line);
+  return code === null ? void 0 : {
+    kind: "ScreenCodeSyntax",
+    code: { kind: "CodeBlockSyntax", language, code, location: locationOf(line) },
+    location: locationOf(line)
+  };
+}
+
+// ../../Compiler/dist/Parsing/SpecificationParser.js
+var header8 = pattern("^specification\\s+([A-Za-z_]\\w*)$");
+var givenPattern = pattern("^given\\s+([A-Z]\\w*)$");
+var whenAppendPattern = pattern("^when\\s+append\\s+([A-Z]\\w*)$");
+var whenPattern2 = pattern("^when\\s+([A-Z]\\w*)$");
+var thenEventPattern = pattern("^then\\s+([A-Z]\\w*)$");
+var thenQueryPrefix = pattern("^then\\s+query\\b");
+var readModelPrefix = pattern("^(?:given|then)\\s+readmodel\\b");
+var givenReadModelPattern = pattern("^given\\s+readmodel\\s+([A-Z]\\w*)$");
+var thenReadModelPattern = pattern("^then\\s+readmodel\\s+([A-Z]\\w*)(\\s+exactly)?$");
+var thenNoPrefix = pattern("^then\\s+no\\b");
+var thenErrorPattern = pattern(`^then\\s+error\\s+"(${stringBodyPattern})"$`);
+var mappingPattern2 = pattern("^([\\w.]+)\\s*=(?!=|>)\\s*(.+)$");
+var givenClockPrefix = pattern("^given\\s+clock\\b");
+var givenCapturePrefix = pattern("^given\\s+capture\\b");
+var whenClockPrefix = pattern("^when\\s+clock\\b");
+var whenTriggerPrefix = pattern("^when\\s+trigger\\b");
+var whenCapturePrefix = pattern("^when\\s+capture\\b");
+var whenQueryPrefix = pattern("^when\\s+query\\b");
+var thenResultPrefix = pattern("^then\\s+result\\b");
+var noResultPrefix = pattern("^then\\s+no\\s+result\\b");
+var clockPattern = pattern('^(given|when)\\s+clock\\s+"(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?(?:Z|[+-]\\d{2}:\\d{2}))"$');
+var whenTriggerPattern = pattern("^when\\s+trigger\\s+([A-Za-z_]\\w*)$");
+var capturePattern = pattern("^(?:given|when)\\s+capture\\s+([A-Za-z_]\\w*)$");
+var whenQueryPattern = pattern("^when\\s+query\\s+([A-Za-z_]\\w*(?:\\.\\w+)*)$");
+var thenResultPattern = pattern("^then\\s+result(\\s+exactly)?$");
+function parseSpecification(context, line) {
+  const name = header8.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidSpecificationDeclaration, `Invalid specification declaration '${line.content}' - expected 'specification <Name>'`, locationOf(line));
+  }
+  const body = {
+    given: [],
+    givenReadModels: [],
+    when: null,
+    whenAppended: null,
+    whenDeclared: false,
+    thenEvents: [],
+    thenEventsInAnyOrder: false,
+    thenReadModels: [],
+    thenErrors: [],
+    givenClock: null,
+    givenCaptures: [],
+    whenClock: null,
+    whenTrigger: null,
+    whenCapture: null,
+    whenQuery: null,
+    thenResults: [],
+    thenNoResult: null
+  };
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (isFileDirective(child)) {
+      continue;
+    }
+    const keyword = thenNoPrefix.test(child.content) ? "then" : firstWord2(child.content);
+    if (keyword === "given") {
+      parseGiven(context, child, body);
+    } else if (keyword === "when") {
+      parseWhen(context, child, body, name);
+    } else if (keyword === "then") {
+      parseThen(context, child, body);
+    } else {
+      context.error(DiagnosticCodes.UnknownSpecificationDirective, `Unexpected '${firstWord2(child.content)}' in specification body`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  const { whenDeclared: _, ...members } = body;
+  return { kind: "SpecificationSyntax", name, ...members, location: locationOf(line) };
+}
+function parseGiven(context, line, body) {
+  if (givenClockPrefix.test(line.content)) {
+    if (body.givenClock !== null) {
+      context.error(DiagnosticCodes.InvalidSpecificationClock, "A specification states its clock at most once.", locationOf(line));
+      context.skipBlock(line.indent);
+    } else {
+      body.givenClock = parseClock(context, line, "given");
+    }
+  } else if (givenCapturePrefix.test(line.content)) {
+    const capture = parseCapture2(context, line, "given");
+    if (capture !== null) {
+      body.givenCaptures.push(capture);
+    }
+  } else if (line.content.startsWith("given caller")) {
+    context.skipOpaqueBlock(line.indent);
+  } else if (readModelPrefix.test(line.content)) {
+    const readModel = parseReadModelStep(context, line, givenReadModelPattern, "given");
+    if (readModel !== void 0) {
+      body.givenReadModels.push(readModel);
+    }
+  } else {
+    const event = parseEventStep(context, line, givenPattern, "given");
+    if (event !== void 0) {
+      body.given.push(event);
+    }
+  }
+}
+function parseWhen(context, line, body, name) {
+  const appends = line.content.startsWith("when append");
+  if (body.whenDeclared) {
+    const code = body.whenAppended !== null || appends ? DiagnosticCodes.ConflictingSpecificationActions : DiagnosticCodes.DuplicateSpecificationWhen;
+    context.error(code, `Specification '${name}' already declares a 'when' - a specification can have at most one`, locationOf(line));
+    context.skipBlock(line.indent);
+    return;
+  }
+  body.whenDeclared = true;
+  if (appends) {
+    body.whenAppended = parseEventStep(context, line, whenAppendPattern, "when append") ?? null;
+    return;
+  }
+  if (whenClockPrefix.test(line.content)) {
+    body.whenClock = parseClock(context, line, "when");
+    return;
+  }
+  if (whenTriggerPrefix.test(line.content)) {
+    body.whenTrigger = parseNamedStep(context, line, whenTriggerPattern, DiagnosticCodes.InvalidSpecificationTrigger, "when trigger", "when trigger <Trigger>", (trigger, values2) => ({ kind: "SpecificationTriggerSyntax", trigger, values: values2, location: locationOf(line) }));
+    return;
+  }
+  if (whenCapturePrefix.test(line.content)) {
+    body.whenCapture = parseCapture2(context, line, "when");
+    return;
+  }
+  if (whenQueryPrefix.test(line.content)) {
+    body.whenQuery = parseNamedStep(context, line, whenQueryPattern, DiagnosticCodes.InvalidSpecificationQueryAction, "when query", "when query <Query>", (query, values2) => ({ kind: "SpecificationWhenQuerySyntax", query, arguments: values2, location: locationOf(line) }));
+    return;
+  }
+  const match = whenPattern2.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidSpecificationWhen, `Invalid 'when' declaration '${line.content}' - expected 'when <CommandType>' or 'when append <EventType>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return;
+  }
+  const values = parseValuesWithEventSource(context, line);
+  body.when = { kind: "SpecificationCommandSyntax", commandType: match[1], ...values, location: locationOf(line) };
+}
+function parseThen(context, line, body) {
+  if (line.content.startsWith("then events")) {
+    if (line.content !== "then events in any order" || body.thenEventsInAnyOrder) {
+      context.error(DiagnosticCodes.InvalidSpecificationEventOrder, "Expected one 'then events in any order' directive.", locationOf(line));
+    } else {
+      body.thenEventsInAnyOrder = true;
+    }
+    context.skipBlock(line.indent);
+    return;
+  }
+  if (thenResultPrefix.test(line.content)) {
+    parseResult(context, line, body);
+    return;
+  }
+  if (noResultPrefix.test(line.content)) {
+    if (line.content !== "then no result" || body.thenNoResult !== null) {
+      context.error(DiagnosticCodes.InvalidSpecificationQueryAction, "Expected one 'then no result' directive.", locationOf(line));
+    } else {
+      body.thenNoResult = { kind: "SpecificationNoResultSyntax", location: locationOf(line) };
+    }
+    context.skipBlock(line.indent);
+    return;
+  }
+  if (line.content.startsWith("then denied")) {
+    if (line.content !== "then denied") {
+      context.error(DiagnosticCodes.InvalidSpecificationDenied, "Expected exactly 'then denied'.", locationOf(line));
+      context.skipBlock(line.indent);
+    }
+    return;
+  }
+  if (line.content === "then error") {
+    body.thenErrors.push({ kind: "SpecificationErrorSyntax", name: null, location: locationOf(line) });
+    return;
+  }
+  const error = thenErrorPattern.exec(line.content);
+  if (error !== null) {
+    body.thenErrors.push({ kind: "SpecificationErrorSyntax", name: unescapeString(error[1]), location: locationOf(line) });
+    return;
+  }
+  if (firstWord2(line.content.substring("then".length).trim()) === "error") {
+    context.error(DiagnosticCodes.InvalidThenError, `Invalid 'then error' declaration '${line.content}' - expected 'then error' or 'then error "<reason>"'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return;
+  }
+  if (thenNoPrefix.test(line.content) || thenQueryPrefix.test(line.content)) {
+    context.skipOpaqueBlock(line.indent);
+    return;
+  }
+  if (readModelPrefix.test(line.content)) {
+    const readModel = parseReadModelStep(context, line, thenReadModelPattern, "then");
+    if (readModel !== void 0) {
+      body.thenReadModels.push(readModel);
+    }
+    return;
+  }
+  const event = parseEventStep(context, line, thenEventPattern, "then");
+  if (event !== void 0) {
+    body.thenEvents.push(event);
+  }
+}
+function parseClock(context, line, keyword) {
+  const match = clockPattern.exec(line.content);
+  context.skipBlock(line.indent);
+  if (match === null || match[1] !== keyword) {
+    context.error(DiagnosticCodes.InvalidSpecificationClock, `Invalid '${keyword} clock' - expected '${keyword} clock "<ISO 8601 instant>"', such as '${keyword} clock "2026-10-05T08:00:00Z"'`, locationOf(line));
+    return null;
+  }
+  return { kind: "SpecificationClockSyntax", instant: match[2], location: locationOf(line) };
+}
+function parseCapture2(context, line, keyword) {
+  return parseNamedStep(context, line, capturePattern, DiagnosticCodes.InvalidSpecificationCapture, `${keyword} capture`, `${keyword} capture <Capture>`, (capture, record) => ({ kind: "SpecificationCaptureSyntax", capture, record, location: locationOf(line) }));
+}
+function parseNamedStep(context, line, regex, code, keyword, expected, create) {
+  const match = regex.exec(line.content);
+  if (match === null) {
+    context.error(code, `Invalid '${keyword}' declaration '${line.content}' - expected '${expected}'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return null;
+  }
+  return create(match[1], parseValues(context, line));
+}
+function parseResult(context, line, body) {
+  const match = thenResultPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidSpecificationQueryAction, `Invalid 'then result' declaration '${line.content}' - expected 'then result [exactly]'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return;
+  }
+  body.thenResults.push({ kind: "SpecificationQueryResultSyntax", properties: parseValues(context, line), exactly: match[1] !== void 0, location: locationOf(line) });
+}
+function parseReadModelStep(context, line, regex, keyword) {
+  const match = regex.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidReadModelStep, `Invalid '${keyword} readmodel' declaration '${line.content}' - expected '${keyword} readmodel <ReadModelType>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return void 0;
+  }
+  return {
+    kind: "SpecificationReadModelSyntax",
+    name: match[1],
+    properties: parseValues(context, line),
+    exactly: keyword === "then" && match[2] !== void 0,
+    location: locationOf(line)
+  };
+}
+function parseEventStep(context, line, regex, keyword) {
+  const match = regex.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidEventStep, `Invalid '${keyword}' declaration '${line.content}' - expected '${keyword} <EventType>'`, locationOf(line));
+    context.skipBlock(line.indent);
+    return void 0;
+  }
+  return { kind: "SpecificationEventSyntax", eventType: match[1], ...parseValuesWithEventSource(context, line), location: locationOf(line) };
+}
+function parseValuesWithEventSource(context, parent) {
+  const values = [];
+  let eventSource = null;
+  for (let child = context.peekChild(parent.indent); child !== void 0; child = context.peekChild(parent.indent)) {
+    context.reader.takeSignificant();
+    const mapping = mappingPattern2.exec(child.content);
+    if (mapping !== null) {
+      values.push(mappingOf(context, child, mapping));
+    } else if (firstWord2(child.content) === "for") {
+      const source = child.content.substring("for".length).trim();
+      if (source.length === 0) {
+        context.error(DiagnosticCodes.InvalidSpecificationEventSource, "Invalid event-source assertion 'for' - expected 'for <value>'", locationOf(child));
+      } else if (eventSource !== null) {
+        context.error(DiagnosticCodes.DuplicateSpecificationEventSource, "A specification step can declare its event-source assertion only once", locationOf(child));
+      } else {
+        eventSource = parseMappingSource(source, locationOf(child), context);
+      }
+    } else {
+      context.error(DiagnosticCodes.InvalidSpecificationValue, `Invalid property mapping '${child.content}' - expected '<property> = <value>'`, locationOf(child));
+    }
+  }
+  return { values, for: eventSource };
+}
+function parseValues(context, parent) {
+  const values = [];
+  for (let child = context.peekChild(parent.indent); child !== void 0; child = context.peekChild(parent.indent)) {
+    context.reader.takeSignificant();
+    const mapping = mappingPattern2.exec(child.content);
+    if (mapping === null) {
+      context.error(DiagnosticCodes.InvalidSpecificationValue, `Invalid property mapping '${child.content}' - expected '<property> = <value>'`, locationOf(child));
+      continue;
+    }
+    values.push(mappingOf(context, child, mapping));
+  }
+  return values;
+}
+function mappingOf(context, line, match) {
+  return { kind: "PropertyMappingSyntax", property: match[1], source: parseMappingSource(match[2], locationOf(line), context), location: locationOf(line) };
+}
+
+// ../../Compiler/dist/Parsing/SliceParser.js
+var header9 = pattern("^slice\\s+([A-Za-z]\\w*)\\s+([A-Za-z_]\\w*)$");
+var opaqueMembers = /* @__PURE__ */ new Set(["reducer"]);
+function parseSlice(context, line) {
+  const match = header9.exec(line.content);
+  let type = "StateChange";
+  let name = "";
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidSliceDeclaration, `Invalid slice declaration '${line.content}' - expected 'slice <Type> <Name>'`, locationOf(line));
+  } else {
+    name = match[2];
+    if (sliceTypes2.includes(match[1])) {
+      type = match[1];
+    } else {
+      context.error(DiagnosticCodes.UnknownSliceType, `Unknown slice type '${match[1]}' - expected StateChange, StateView, Automation or Translate`, locationOf(line));
+    }
+  }
+  let description = null;
+  const events = [];
+  const commands = [];
+  const queries = [];
+  const projections = [];
+  const reactions = [];
+  const captures = [];
+  const constraints = [];
+  const specifications = [];
+  const readModels = [];
+  const screens = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (isFileDirective(child)) {
+      continue;
+    }
+    const keyword = firstWord2(child.content);
+    if (keyword === "description") {
+      description = parseDescription(context, child, description, `Slice '${name}'`);
+    } else if (keyword === "event") {
+      events.push(parseEvent(context, child));
+    } else if (keyword === "command") {
+      commands.push(parseCommand(context, child));
+    } else if (keyword === "query") {
+      queries.push(parseQuery(context, child));
+    } else if (keyword === "projection") {
+      projections.push(parseProjection(context, child));
+    } else if (keyword === "capture") {
+      captures.push(parseCapture(context, child));
+    } else if (keyword === "reaction") {
+      reactions.push(parseReaction(context, child));
+    } else if (keyword === "constraint") {
+      constraints.push(parseConstraint(context, child));
+    } else if (keyword === "specification") {
+      specifications.push(parseSpecification(context, child));
+    } else if (keyword === "readmodel") {
+      readModels.push(parseReadModel(context, child));
+    } else if (keyword === "screen") {
+      screens.push(parseScreen(context, child));
+    } else if (opaqueMembers.has(keyword)) {
+      context.skipOpaqueBlock(child.indent);
+    } else {
+      context.warning(DiagnosticCodes.UnknownSliceDirective, `Unknown construct '${keyword}' in slice '${name}'`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  return {
+    kind: "SliceSyntax",
+    type,
+    name,
+    description,
+    events,
+    commands,
+    queries,
+    projections,
+    captures,
+    reactions,
+    constraints,
+    specifications,
+    readModels,
+    screens,
+    location: locationOf(line)
+  };
+}
+
+// ../../Compiler/dist/Parsing/FeatureBody.js
+var featurePattern = pattern("^feature\\s+([A-Za-z_]\\w*)$");
+var opaqueFeatureMembers = /* @__PURE__ */ new Set(["on", "uses", "contribute"]);
+var featureBodyExpected = "description, authorize, import, feature, slice, contribute, 'on <trigger>' or 'uses <Behavior>'";
+var FeatureBody = class {
+  name;
+  #features = [];
+  #slices = [];
+  #fileImports = [];
+  #description = null;
+  #authorize = null;
+  constructor(name) {
+    this.name = name;
+  }
+  // Parses one already consumed line of the body; false when the line does not belong to a feature body,
+  // and nothing was reported.
+  tryParse(context, line) {
+    const keyword = firstWord2(line.content);
+    switch (keyword) {
+      case "description":
+        this.#description = parseDescription(context, line, this.#description, `Feature '${this.name}'`);
+        return true;
+      case "authorize":
+        this.#authorize = combineAuthorize(this.#authorize, parseAuthorize(context, line));
+        return true;
+      case "import":
+        parseFileImport(context, line, this.#fileImports);
+        return true;
+      case "feature":
+        this.#features.push(parseFeature(context, line));
+        return true;
+      case "slice":
+        this.#slices.push(parseSlice(context, line));
+        return true;
+      default:
+        if (opaqueFeatureMembers.has(keyword)) {
+          context.skipOpaqueBlock(line.indent);
+          return true;
+        }
+        return false;
+    }
+  }
+  // Builds the feature, located at its header or, when it only places an imported file, at that file.
+  build(location, isPlacement = false) {
+    return {
+      kind: "FeatureSyntax",
+      name: this.name,
+      description: this.#description,
+      authorize: this.#authorize,
+      features: this.#features,
+      slices: this.#slices,
+      fileImports: this.#fileImports,
+      isPlacement,
+      location
+    };
+  }
+};
+function parseFeature(context, line) {
+  const name = featurePattern.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidFeatureDeclaration, `Invalid feature declaration '${line.content}' - expected 'feature <Name>'`, locationOf(line));
+  }
+  const body = new FeatureBody(name);
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    if (!body.tryParse(context, child)) {
+      context.error(DiagnosticCodes.UnknownFeatureDirective, `Unexpected '${firstWord2(child.content)}' in feature body - expected ${featureBodyExpected}`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  return body.build(locationOf(line));
+}
+
+// ../../Compiler/dist/Parsing/ModuleBody.js
+var modulePattern = pattern("^module\\s+([A-Za-z_]\\w*)$");
+var opaqueModuleMembers = /* @__PURE__ */ new Set(["on", "uses", "screen", "dialog", "form", "contribute"]);
+var moduleBodyExpected = "description, authorize, import, screen template, dialog template, form, contribute, feature, 'on <trigger>' or 'uses <Behavior>'";
+var ModuleBody = class {
+  name;
+  #features = [];
+  #fileImports = [];
+  #description = null;
+  #authorize = null;
+  constructor(name) {
+    this.name = name;
+  }
+  // Parses one already consumed line of the body; false when the line does not belong to a module body,
+  // and nothing was reported.
+  tryParse(context, line) {
+    const keyword = firstWord2(line.content);
+    switch (keyword) {
+      case "description":
+        this.#description = parseDescription(context, line, this.#description, `Module '${this.name}'`);
+        return true;
+      case "authorize":
+        this.#authorize = combineAuthorize(this.#authorize, parseAuthorize(context, line));
+        return true;
+      case "import":
+        parseFileImport(context, line, this.#fileImports);
+        return true;
+      case "feature":
+        this.#features.push(parseFeature(context, line));
+        return true;
+      default:
+        if (opaqueModuleMembers.has(keyword)) {
+          context.skipOpaqueBlock(line.indent);
+          return true;
+        }
+        return false;
+    }
+  }
+  // Parses the children of a header line into this body, reporting what does not belong in a module.
+  parseChildren(context, line) {
+    for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+      context.reader.takeSignificant();
+      if (!this.tryParse(context, child)) {
+        context.error(DiagnosticCodes.UnknownModuleDirective, `Unexpected '${firstWord2(child.content)}' in module body - expected ${moduleBodyExpected}`, locationOf(child));
+        context.skipBlock(child.indent);
+      }
+    }
+  }
+  // Builds the module, located at its header or, when it only places an imported file, at that file.
+  build(location, isPlacement = false) {
+    return {
+      kind: "ModuleSyntax",
+      name: this.name,
+      description: this.#description,
+      authorize: this.#authorize,
+      features: this.#features,
+      fileImports: this.#fileImports,
+      isPlacement,
+      location
+    };
+  }
+};
+function parseModule(context, line) {
+  const name = modulePattern.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidModuleDeclaration, `Invalid module declaration '${line.content}' - expected 'module <Name>'`, locationOf(line));
+  }
+  const body = new ModuleBody(name);
+  body.parseChildren(context, line);
+  return body.build(locationOf(line));
+}
+
+// ../../Compiler/dist/Parsing/LineReader.js
+var LineReader = class {
+  lines;
+  #index = 0;
+  constructor(lines) {
+    this.lines = lines;
+  }
+  peekSignificant() {
+    while (this.#index < this.lines.length && isBlank(this.lines[this.#index])) {
+      this.#index++;
+    }
+    return this.#index < this.lines.length ? this.lines[this.#index] : void 0;
+  }
+  takeSignificant() {
+    const line = this.peekSignificant();
+    if (line === void 0) {
+      throw new Error("There is no significant line left to take");
+    }
+    this.#index++;
+    return line;
+  }
+  takeRaw() {
+    return this.#index < this.lines.length ? this.lines[this.#index++] : void 0;
+  }
+};
+
+// ../../Compiler/dist/Syntax/EventDeclarations.js
+function eventDeclarations(slice) {
+  return [...slice.events, ...slice.commands.flatMap((command) => command.produces).flatMap((produced) => produced.inlineEvent === null ? [] : [produced.inlineEvent])];
+}
+
+// ../../Compiler/dist/Syntax/ProductionDestinations.js
+function requiresExplicitDestinations(command) {
+  const identifier = command.properties.find((property) => property.isIdentifier)?.name;
+  return command.produces.some((produced) => produced.for !== null && (produced.for.kind !== "PathExpressionSyntax" || produced.for.path !== identifier)) || command.produces.some((produced) => produced.inlineEvent !== null && produced.for === null) && command.produces.some((produced) => produced.inlineEvent === null && produced.for === null);
+}
+
+// ../../Compiler/dist/Parsing/InlineEventValidator.js
+function validateInlineEvents(application, context) {
+  const slices = [];
+  const inFeature = (feature) => {
+    slices.push(...feature.slices);
+    feature.features.forEach(inFeature);
+  };
+  application.modules.forEach((module) => module.features.forEach(inFeature));
+  const eventCounts = /* @__PURE__ */ new Map();
+  for (const event of slices.flatMap(eventDeclarations))
+    eventCounts.set(event.name, (eventCounts.get(event.name) ?? 0) + 1);
+  const importedNames = new Set(application.imports.map((value) => value.qualifiedName.split(".").at(-1)));
+  for (const command of slices.flatMap((slice) => slice.commands)) {
+    const identifier = command.properties.find((property) => property.isIdentifier)?.name;
+    const mixed = requiresExplicitDestinations(command);
+    for (const production of command.produces) {
+      const inline = production.inlineEvent;
+      if (inline !== null && ((eventCounts.get(inline.name) ?? 0) > 1 || importedNames.has(inline.name))) {
+        context.error(DiagnosticCodes.InlineEventCollision, `Inline event '${inline.name}' collides with another event declaration or import`, production.location);
+      }
+      if (mixed && production.for === null) {
+        context.error(DiagnosticCodes.ExplicitProducesTargetsRequired, `Production '${production.event}' in command '${command.name}' must state 'for' explicitly - every production must state 'for' when destinations differ`, production.location);
+      }
+      const destination = production.for?.kind === "PathExpressionSyntax" ? production.for.path : production.for === null && inline !== null ? identifier : void 0;
+      if (identifier === void 0 || destination !== identifier)
+        continue;
+      for (const mapping of production.mappings.filter((mapping2) => mapping2.source.kind === "PathExpressionSyntax" && mapping2.source.path === identifier)) {
+        const message = `Event '${production.event}' copies command identifier '${identifier}' into payload property '${mapping.property}' although it already identifies the event source`;
+        if (inline === null)
+          context.information(DiagnosticCodes.EventSourceIdInPayload, message, mapping.location);
+        else
+          context.warning(DiagnosticCodes.EventSourceIdInPayload, message, mapping.location);
+      }
+    }
+  }
+}
+
+// ../../Compiler/dist/Parsing/ParserContext.js
+var ParserContext = class {
+  reader;
+  path;
+  #diagnostics = [];
+  // Authoring verification needs these committed values even though SyntaxJson omits them.
+  triggerData = [];
+  constructor(reader, path) {
+    this.reader = reader;
+    this.path = path;
+  }
+  get start() {
+    return sourceLocation(1, 1, this.path);
+  }
+  get diagnostics() {
+    return this.#diagnostics;
+  }
+  information(code, message, location) {
+    this.#diagnostics.push({ severity: "information", code, message, location });
+  }
+  error(code, message, location) {
+    this.#diagnostics.push({ severity: "error", code, message, location });
+  }
+  warning(code, message, location) {
+    this.#diagnostics.push({ severity: "warning", code, message, location });
+  }
+  // The next significant line when it is indented deeper than its parent - that is, when it belongs to
+  // the parent's body under the offside rule.
+  peekChild(parentIndent) {
+    const line = this.reader.peekSignificant();
+    return line !== void 0 && line.indent > parentIndent ? line : void 0;
+  }
+  // Skips the body of a construct, the way the C# parser does after reporting it.
+  skipBlock(parentIndent) {
+    while (this.peekChild(parentIndent) !== void 0) {
+      this.reader.takeSignificant();
+    }
+  }
+  // Skips the body of a construct this compiler deliberately does not model. Unlike skipBlock it steps
+  // over fenced code blocks whole, because a fenced line may be indented less than the block it is in -
+  // reading it as significant would end the skip early and misread the code as Screenplay.
+  skipOpaqueBlock(parentIndent) {
+    let child = this.peekChild(parentIndent);
+    while (child !== void 0) {
+      this.reader.takeSignificant();
+      if (child.content.startsWith("```")) {
+        this.skipFencedBody();
+      }
+      child = this.peekChild(parentIndent);
+    }
+  }
+  // Takes the raw lines of a fenced block up to and including its closing fence.
+  skipFencedBody() {
+    for (let line = this.reader.takeRaw(); line !== void 0; line = this.reader.takeRaw()) {
+      if (line.raw.trim() === "```") {
+        return;
+      }
+    }
+  }
+};
+
+// ../../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 enumValuePattern = pattern("^@?[a-z_]\\w*$");
+var attributeReasonPattern2 = 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/;
+var primitiveTypes2 = ["Uuid", "String", "Int", "Decimal", "Bool", "Date", "DateTime"];
+var opaqueTopLevel = /* @__PURE__ */ new Set(["policy", "authentication", "seed", "ui", "theme", "trigger", "layout", "behavior"]);
+var bodyKeywords = /* @__PURE__ */ new Set(["slice", "feature", "description", "authorize", "screen", "dialog", "form", "contribute", "on", "uses"]);
+function parseApplication(context, lines, placement = documentPlacement) {
+  warnOnTabIndentation(context, lines);
+  const moduleBody = placement.length === 1 ? new ModuleBody(placement[0]) : void 0;
+  const featureBody = placement.length > 1 ? new FeatureBody(placement[placement.length - 1]) : void 0;
+  const placedBody = moduleBody ?? featureBody;
+  let domain = null;
+  const imports = [];
+  const fileImports2 = [];
+  const concepts = [];
+  const types = [];
+  const modules = [];
+  const personas = [];
+  let sawOtherConstruct = false;
+  for (let line = context.reader.peekSignificant(); line !== void 0; line = context.reader.peekSignificant()) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(line.content);
+    if (keyword === "domain") {
+      domain = parseDomain(context, line, domain, sawOtherConstruct);
+      continue;
+    }
+    sawOtherConstruct ||= declaresConstruct(keyword, line, placement);
+    if (keyword === "import" && isFileImport(line.content)) {
+      if (placedBody !== void 0) {
+        placedBody.tryParse(context, line);
+      } else {
+        parseFileImport(context, line, fileImports2);
+      }
+    } else if (keyword === "import") {
+      const match = importPattern.exec(line.content);
+      if (match === null) {
+        context.error(DiagnosticCodes.InvalidImportDeclaration, `Invalid import '${line.content}' - expected 'import <Qualified.Name>'`, locationOf(line));
+      } else {
+        imports.push({ kind: "ImportSyntax", qualifiedName: match[1], location: locationOf(line) });
+      }
+    } else if (keyword === "concept") {
+      concepts.push(parseConcept(context, line));
+    } else if (keyword === "type") {
+      types.push(parseType(context, line));
+    } else if (keyword === "module" && !isDocumentPlacement(placement)) {
+      parseModuleInPlacedFile(context, line, placement, moduleBody);
+    } else if (keyword === "module") {
+      modules.push(parseModule(context, line));
+    } else if (keyword === "persona") {
+      personas.push(parsePersona(context, line));
+    } else if (keyword === "trigger") {
+      parseTriggerDeclaration(context, line);
+    } else if (opaqueTopLevel.has(keyword)) {
+      context.skipOpaqueBlock(line.indent);
+    } else if (placedBody?.tryParse(context, line) !== true) {
+      reportUnexpectedTopLevel(context, line, placement);
+    }
+  }
+  if (moduleBody !== void 0) {
+    modules.unshift(moduleBody.build(context.start, true));
+  } else if (featureBody !== void 0) {
+    modules.unshift(place(placement, featureBody.build(context.start, true), context.start));
+  }
+  return { kind: "ApplicationSyntax", domain, imports, concepts, types, modules, personas, fileImports: fileImports2, location: context.start };
+}
+function declaresConstruct(keyword, line, placement) {
+  if (keyword === "import") {
+    return importPattern.test(line.content);
+  }
+  if (keyword === "module") {
+    return isDocumentPlacement(placement);
+  }
+  return keyword === "concept" || keyword === "type" || keyword === "persona" || opaqueTopLevel.has(keyword);
+}
+function parseModuleInPlacedFile(context, line, placement, moduleBody) {
+  const name = modulePattern.exec(line.content)?.[1] ?? "";
+  if (moduleBody !== void 0 && name === placement[0]) {
+    moduleBody.parseChildren(context, line);
+    return;
+  }
+  context.error(DiagnosticCodes.ModuleInPlacedFile, `This file is imported into ${describePlacement(placement)}, so it cannot declare module '${name}' - import it at the top level of a document instead`, locationOf(line));
+  context.skipBlock(line.indent);
+}
+function reportUnexpectedTopLevel(context, line, placement) {
+  const word = firstWord2(line.content);
+  if (!isDocumentPlacement(placement)) {
+    const expected = placement.length === 1 ? moduleBodyExpected : featureBodyExpected;
+    context.error(DiagnosticCodes.UnexpectedInPlacedFile, `Unexpected '${word}' in a file imported into ${describePlacement(placement)} - expected an application declaration or ${expected}`, locationOf(line));
+  } else {
+    const hint = bodyKeywords.has(word) ? ` - '${word}' belongs in a module or feature; wrap it in one, or import this file from inside one` : " - expected domain, import, concept, type, policy, persona, authentication, module, seed, trigger, behavior, ui profile, theme or layout";
+    context.error(DiagnosticCodes.UnknownTopLevelConstruct, `Unexpected '${word}' at the top level${hint}`, locationOf(line));
+  }
+  context.skipBlock(line.indent);
+}
+function place(placement, innermost, start) {
+  let feature = innermost;
+  for (let index = placement.length - 2; index >= 1; index--) {
+    feature = {
+      kind: "FeatureSyntax",
+      name: placement[index],
+      description: null,
+      authorize: null,
+      features: [feature],
+      slices: [],
+      fileImports: [],
+      isPlacement: true,
+      location: start
+    };
+  }
+  return {
+    kind: "ModuleSyntax",
+    name: placement[0],
+    description: null,
+    authorize: null,
+    features: [feature],
+    fileImports: [],
+    isPlacement: true,
+    location: start
+  };
+}
+function parseDomain(context, line, existing, sawOtherConstruct) {
+  const match = domainPattern.exec(line.content);
+  if (match === null) {
+    context.error(DiagnosticCodes.InvalidDomainDeclaration, `Invalid domain declaration '${line.content}' - expected 'domain <Qualified.Name>'`, locationOf(line));
+    return existing;
+  }
+  if (existing !== null) {
+    context.error(DiagnosticCodes.DuplicateDomain, "The document already declares a domain - a document can have at most one", locationOf(line));
+    return existing;
+  }
+  if (sawOtherConstruct) {
+    context.error(DiagnosticCodes.DomainNotFirst, "'domain' must be declared before any other construct", locationOf(line));
+  }
+  return { kind: "DomainSyntax", name: match[1], location: locationOf(line) };
+}
+function warnOnTabIndentation(context, lines) {
+  let inFence = false;
+  for (const line of lines) {
+    if (line.raw.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && tabIndentPattern.test(line.raw)) {
+      context.warning(DiagnosticCodes.TabIndentation, "Screenplay is indentation based - use spaces, not tabs", startOf(line));
+    }
+  }
+}
+function parseConcept(context, line) {
+  const match = conceptPattern2.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);
+    return { kind: "ConceptSyntax", name: firstWord2(line.content), type: "", attributes: [], values: [], location: locationOf(line) };
+  }
+  const [, name, type, attributeText] = match;
+  const attributes = attributeText.split(" ").filter((attribute) => attribute.length > 0).map((attribute) => ({ kind: "ConceptAttributeSyntax", name: attribute.replace(/^@+/, ""), reason: null, location: locationOf(line) }));
+  if (type !== "Enum" && !primitiveTypes2.includes(type)) {
+    context.error(DiagnosticCodes.UnknownPrimitiveType, `Unknown primitive type '${type}' - expected ${primitiveTypes2.join(", ")} or Enum`, locationOf(line));
+  }
+  const attributeIndices = /* @__PURE__ */ new Map();
+  attributes.forEach((attribute, index) => {
+    if (!attributeIndices.has(attribute.name))
+      attributeIndices.set(attribute.name, index);
+  });
+  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);
+    if (isFileDirective(child)) {
+      continue;
+    } else if (firstWord2(child.content) === "validate") {
+      if (type === "Enum" && child.content === "validate" && context.peekChild(child.indent) === void 0) {
+        context.warning(DiagnosticCodes.ValidateReadAsEnumerationBlock, `'validate' in enumeration concept '${name}' declares an empty validate block, not a value named 'validate' - write '@validate' for the value`, locationOf(child));
+      }
+      context.skipOpaqueBlock(child.indent);
+    } else if (reason !== null) {
+      applyAttributeReason(context, child, name, attributes, attributeIndices, reason[1], unescapeString(reason[2]));
+    } else if (type === "Enum" && enumValuePattern.test(child.content)) {
+      values.push(unescapeIdentifier(child.content));
+    } else if (type === "Enum") {
+      context.error(DiagnosticCodes.InvalidEnumerationValue, `Invalid enum value '${child.content}' - expected an identifier`, locationOf(child));
+    } else {
+      context.error(DiagnosticCodes.UnknownConceptDirective, `Unexpected '${child.content}' in concept body - expected validate, 'file <path>' or '<attribute> reason "<text>"'`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  return { kind: "ConceptSyntax", name, type, attributes, values, location: locationOf(line) };
+}
+function applyAttributeReason(context, line, concept, attributes, indices, attribute, reason) {
+  const index = indices.get(attribute);
+  if (index === void 0) {
+    context.error(DiagnosticCodes.AttributeReasonWithoutAttribute, `Concept '${concept}' declares a reason for '${attribute}' without the attribute - write 'concept ${concept} : <Type> @${attribute}'`, locationOf(line));
+  } else if (attributes[index].reason !== null) {
+    context.error(DiagnosticCodes.DuplicateAttributeReason, `Concept '${concept}' already declares a reason for '${attribute}' - at most one is allowed`, locationOf(line));
+  } else {
+    attributes[index] = { ...attributes[index], reason };
+  }
+}
+function parsePersona(context, line) {
+  const name = personaPattern.exec(line.content)?.[1] ?? "";
+  if (name === "") {
+    context.error(DiagnosticCodes.InvalidPersonaDeclaration, `Invalid persona declaration '${line.content}' - expected 'persona <Name>'`, locationOf(line));
+  }
+  let description = null;
+  const policies = [];
+  for (let child = context.peekChild(line.indent); child !== void 0; child = context.peekChild(line.indent)) {
+    context.reader.takeSignificant();
+    const keyword = firstWord2(child.content);
+    if (keyword === "description") {
+      description = parseDescription(context, child, description, `Persona '${name}'`);
+    } else if (keyword === "policy") {
+      const policy = personaPolicyPattern.exec(child.content);
+      if (policy === null) {
+        context.error(DiagnosticCodes.InvalidPersonaPolicyReference, `Invalid policy reference '${child.content}' - expected 'policy <Name>'`, locationOf(child));
+      } else {
+        policies.push(policy[1]);
+      }
+    } else {
+      context.error(DiagnosticCodes.UnknownPersonaDirective, `Unexpected '${keyword}' in persona body - expected description or policy`, locationOf(child));
+      context.skipBlock(child.indent);
+    }
+  }
+  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);
+  return { value, diagnostics, success };
+}
+function parseForAuthoring(source, path, placement = documentPlacement) {
+  const lines = splitLines(source, false, path);
+  const context = new ParserContext(new LineReader(lines), path);
+  const value = parseApplication(context, lines, placement);
+  validateInlineEvents(value, context);
+  return {
+    value,
+    diagnostics: context.diagnostics,
+    triggerData: context.triggerData,
+    success: !context.diagnostics.some((diagnostic) => diagnostic.severity === "error")
+  };
+}
+
+// ../../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);
+  }
+  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]);
+    }
+    return result;
+  }
+  if (value === void 0) {
+    return null;
+  }
+  return value;
+}
+function ordinal(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// ../../Compiler/dist/Authoring/QuickFixes.js
+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 = 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 syntax = verificationShape(original);
+  const byLine = new Map(occurrences.map((occurrence) => [occurrence.diagnostic.location.line, occurrence]));
+  const verifiedOccurrences = /* @__PURE__ */ new Map();
+  let documentChecked = false;
+  let documentFix;
+  const verify = (fix, line) => {
+    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;
+  };
+  return (line) => {
+    if (!documentChecked) {
+      documentFix = verify({ diagnosticCode: DiagnosticCodes.LegacyOptionalSuffix, title: "Use 'optional' throughout this document", scope: "document", edits: occurrences.map((occurrence) => occurrence.edit) });
+      documentChecked = true;
+    }
+    const selected = line === void 0 ? void 0 : byLine.get(line);
+    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));
+      }
+      occurrenceFix = verifiedOccurrences.get(line);
+    }
+    return [occurrenceFix, documentFix].filter((fix) => fix !== void 0);
+  };
+}
+function verificationShape(parsed) {
+  return JSON.stringify([toSyntaxJson(parsed.value), parsed.triggerData.map((value) => toSyntaxJson(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("");
+}
+
+// inline-event-validation.ts
+var reserved2 = /* @__PURE__ */ new Set(["namespace", "sequence", "correlation", "causation", "causedBy", "occurred"]);
+var quotedId = /^id\s+"((?:[^"\\]|\\.)*)"$/;
+function validateInlineEvents2(lines, symbols, application) {
+  lines = eventAnalysisSource(lines);
+  const issues = [];
+  const fences = fenceMap(lines);
+  const documentationBlocks = nonemptyMarkdownBlocks(lines, fences);
+  const commandProductions = new Set(symbols.commands.flatMap((command) => command.productionHeaders ?? []));
+  const eventCounts = /* @__PURE__ */ new Map();
+  const importedNames = /* @__PURE__ */ new Set();
+  for (const document of [symbols, application]) {
+    for (const event of document.events) eventCounts.set(event.name, (eventCounts.get(event.name) ?? 0) + 1);
+    for (const imported of document.imports) importedNames.add(imported.shortName);
+  }
+  const report = (line, code, message, severity = "error") => {
+    issues.push({ line, startColumn: indentOf(lines[line]) + 1, endColumn: lines[line].length + 1, code, message, severity });
+  };
+  for (const event of symbols.events) {
+    const body = directBody(lines, fences, event.line, indentOf(lines[event.line]));
+    if (event.inline) {
+      const properties = /* @__PURE__ */ new Set();
+      for (const property of event.properties) {
+        if (properties.has(property.name)) report(property.line, diagnosticCodes.duplicateDeclaration, `Event '${event.name}' already declares property '${property.name}'.`);
+        properties.add(property.name);
+      }
+      if (!commandProductions.has(event.line)) report(event.line, diagnosticCodes.inlineEventOutsideCommand, "Inline events can only be declared inside commands.");
+      if (event.generation !== void 0) report(event.line, diagnosticCodes.inlineEventGeneration, "Inline events are generation 1; extract the event before declaring generations.");
+      if ((eventCounts.get(event.name) ?? 0) > 1 || importedNames.has(event.name)) {
+        report(event.line, diagnosticCodes.inlineEventCollision, `Inline event '${event.name}' collides with another declaration or import.`);
+      }
+    }
+    let hasId = false;
+    let hasDocumentation = false;
+    for (const index of body) {
+      const text = lines[index].trim();
+      const keyword = text.split(/\s+/)[0];
+      if (event.inline && keyword === "generation") report(index, diagnosticCodes.inlineEventGeneration, "Inline events are generation 1; extract the event before declaring generations.");
+      if (event.inline && keyword === "origin") report(index, diagnosticCodes.reservedProductionMetadata, "An inline event is local to its command and cannot declare origin.");
+      if (/^(?:id|description|documentation)\s+[\w.]+(?:\[\])?(?:\?|\s+optional)?(?:\s*=.*)?$/.test(text)) continue;
+      if (keyword === "id") {
+        const match = text.match(quotedId);
+        if (hasId || match === null || match[1].trim().length === 0) report(index, diagnosticCodes.invalidEventId, 'Expected one nonempty id "<old-name>".');
+        else if (match[1] === event.name) report(index, diagnosticCodes.redundantEventId, "This id repeats the event name; remove it.", "information");
+        hasId = true;
+      }
+      if (keyword === "documentation") {
+        let next = index + 1;
+        while (next < lines.length && lines[next].trim().length === 0) next++;
+        if (hasDocumentation || text !== "documentation" || lines[next]?.trim() !== "```markdown" || indentOf(lines[next]) <= indentOf(lines[index]) || !documentationBlocks.has(next)) {
+          report(index, diagnosticCodes.invalidEventDocumentation, "Expected one nonempty fenced markdown documentation block.");
+        }
+        hasDocumentation = true;
+      }
+    }
+  }
+  const productionIndents = [];
+  for (let index = 0; index < lines.length; index++) {
+    if (fences[index] || lines[index].trim().length === 0) continue;
+    const indent = indentOf(lines[index]);
+    while (productionIndents.length > 0 && productionIndents[productionIndents.length - 1] >= indent) productionIndents.pop();
+    const keyword = lines[index].trim().split(/\s+/)[0];
+    if (reserved2.has(keyword) && productionIndents.length > 0) {
+      report(index, diagnosticCodes.reservedProductionMetadata, `'${keyword}' is system-assigned production metadata.`);
+    }
+    if (keyword === "produces") productionIndents.push(indent);
+  }
+  for (const command of symbols.commands) {
+    const { identifier, mixed } = productionDestinations(command);
+    for (const production of command.produces ?? []) {
+      if (mixed && production.target === void 0) report(production.line, diagnosticCodes.explicitProducesTargetsRequired, `Production '${production.name}' must state for explicitly when destinations differ.`);
+      const destination = production.target ?? (production.inline ? identifier : void 0);
+      if (identifier === void 0 || destination !== identifier) continue;
+      for (const mapping of production.mappings.filter((mapping2) => mapping2.source === identifier)) {
+        report(mapping.line, diagnosticCodes.eventSourceIdInPayload, `The payload copies '${identifier}', which already identifies the event source.`, production.inline ? "warning" : "information");
+      }
+    }
+  }
+  return issues;
+}
+function nonemptyMarkdownBlocks(lines, fences) {
+  const blocks = /* @__PURE__ */ new Set();
+  let opening;
+  let content = false;
+  for (let index = 0; index < lines.length; index++) {
+    if (!fences[index]) continue;
+    const text = lines[index].trim();
+    if (opening === void 0) {
+      opening = index;
+      content = false;
+    } else if (text === "```") {
+      if (content && lines[opening].trim() === "```markdown") blocks.add(opening);
+      opening = void 0;
+    } else if (text.length > 0) {
+      content = true;
+    }
+  }
+  return blocks;
+}
+
+// validation.ts
+function issue(severity, line, startColumn, length, message, code) {
+  return { severity, message, line, startColumn, endColumn: startColumn + length, code };
+}
+function tokenIssue(severity, line, text, token, message, code) {
+  const column2 = text.indexOf(token) + 1;
+  return issue(severity, line, column2, token.length, message, code);
+}
+function validateDeclarations(lines, symbols, application) {
+  const issues = [];
+  const types = /* @__PURE__ */ new Set([...knownTypeNames(symbols, primitiveTypes), ...knownTypeNames(application, [])]);
+  const checkProperties = (properties, owner) => {
+    for (const property of properties.filter(
+      (candidate) => !types.has(propertyTypeReference(candidate).name)
+    )) {
+      const bare = propertyTypeReference(property).name;
+      issues.push(
+        tokenIssue(
+          "warning",
+          property.line,
+          lines[property.line],
+          property.type,
+          bare === "optional" ? `Unknown type 'optional' on '${property.name}' of ${owner} \u2014 did you forget the type before 'optional'?` : `Unknown type '${bare}' on '${property.name}' of ${owner} \u2014 declare it with 'concept ${bare} : <Primitive>' or 'type ${bare}'.`,
+          diagnosticCodes.unknownType
+        )
+      );
+    }
+  };
+  for (const type of symbols.types) checkProperties(type.properties, `type '${type.name}'`);
+  for (const event of symbols.events) checkProperties(event.properties, `event '${event.name}'`);
+  for (const query of symbols.queries) checkProperties(query.parameters, `query '${query.name}'`);
+  for (const command of symbols.commands) {
+    checkProperties(command.properties, `command '${command.name}'`);
+    const identifiers = command.properties.filter((property) => property.isIdentifier);
+    for (const extra of identifiers.slice(1)) {
+      issues.push(
+        tokenIssue(
+          "error",
+          extra.line,
+          lines[extra.line],
+          "identifier",
+          `Command '${command.name}' already marks '${identifiers[0].name}' as identifier \u2014 only one property can be the identifier.`,
+          diagnosticCodes.duplicateCommandIdentifier
+        )
+      );
+    }
+  }
+  const declared = /* @__PURE__ */ new Map();
+  for (const declaration of [...symbols.concepts, ...symbols.types]) {
+    const first = declared.get(declaration.name);
+    if (first === void 0) {
+      declared.set(declaration.name, declaration.line);
+      continue;
+    }
+    issues.push(
+      tokenIssue(
+        "error",
+        declaration.line,
+        lines[declaration.line],
+        declaration.name,
+        `Duplicate declaration of '${declaration.name}' \u2014 concept and type names must be unique.`,
+        diagnosticCodes.duplicateDeclaration
+      )
+    );
+  }
+  return issues;
+}
+function validateLines(lines, context = {}) {
+  const fences = fenceMap(lines);
+  const symbols = scanDocument(lines);
+  const application = context.application ?? mergeSymbols();
+  const events = /* @__PURE__ */ new Set([...knownEventNames(symbols), ...knownEventNames(application)]);
+  const policies = new Set([...symbols.policies, ...application.policies].map((policy) => policy.name));
+  const issues = validateDeclarations(lines, symbols, application);
+  issues.push(...validateProductionDestinations(lines, symbols));
+  const optionalCodes = /* @__PURE__ */ new Set([DiagnosticCodes.LegacyOptionalSuffix, DiagnosticCodes.InvalidOptionalModifierOrder, DiagnosticCodes.OptionalReadsNotSupported]);
+  for (const diagnostic of parse(lines.join("\n"), void 0, context.placement).diagnostics) {
+    if (!optionalCodes.has(diagnostic.code)) continue;
+    const line = diagnostic.location.line - 1;
+    const length = legacyOptionalTypeLength(lines[line], diagnostic) || lines[line].length - diagnostic.location.column + 1;
+    issues.push(issue(diagnostic.severity, line, diagnostic.location.column, length, diagnostic.message, diagnostic.code));
+  }
+  const checkEvent = (line, text, name) => {
+    if (!events.has(name)) {
+      issues.push(
+        tokenIssue(
+          "warning",
+          line,
+          text,
+          name,
+          `Unknown event type '${name}' \u2014 declare it in a slice or import it.`,
+          diagnosticCodes.unknownEvent
+        )
+      );
+    }
+  };
+  let authorizeIndent = -1;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (fences[index] || trimmed.length === 0) continue;
+    const leading = line.match(/^[ ]*(\t+)/);
+    if (leading) {
+      issues.push(
+        issue(
+          "warning",
+          index,
+          leading[0].length - leading[1].length + 1,
+          leading[1].length,
+          "Screenplay is indentation-based \u2014 use spaces, not tabs.",
+          diagnosticCodes.tabIndentation
+        )
+      );
+    }
+    if (authorizeIndent >= 0) {
+      if (indentOf(line) > authorizeIndent && /^(?:or\s+)?[A-Z]\w*(?:\s+or\s+[A-Z]\w*)*$/.test(trimmed)) {
+        for (const name of trimmed.split(/\s+/).filter((token) => token !== "or")) {
+          if (!policies.has(name)) {
+            issues.push(
+              tokenIssue(
+                "warning",
+                index,
+                line,
+                name,
+                `Unknown policy '${name}' \u2014 declare it with 'policy ${name}'.`,
+                diagnosticCodes.unknownPolicy
+              )
+            );
+          }
+        }
+        continue;
+      }
+      authorizeIndent = -1;
+    }
+    const fileImportIssue = validateImport(lines, fences, index);
+    if (fileImportIssue) issues.push(fileImportIssue);
+    const slice = trimmed.match(/^slice\s+(\w+)/);
+    if (slice && !sliceTypes.includes(slice[1])) {
+      issues.push(
+        tokenIssue(
+          "error",
+          index,
+          line,
+          slice[1],
+          `Unknown slice type '${slice[1]}' \u2014 expected ${sliceTypes.join(", ")}.`,
+          diagnosticCodes.unknownSliceType
+        )
+      );
+    }
+    const concept = trimmed.match(/^concept\s+\w+\s*:\s*(\w+)/);
+    if (concept && concept[1] !== "Enum" && !primitiveTypes.includes(concept[1])) {
+      issues.push(
+        tokenIssue(
+          "error",
+          index,
+          line,
+          concept[1],
+          `Unknown primitive type '${concept[1]}' \u2014 expected ${primitiveTypes.join(", ")} or Enum.`,
+          diagnosticCodes.unknownPrimitiveType
+        )
+      );
+    }
+    const authorize = trimmed.match(/^authorize\s+(.*)$/);
+    if (authorize) {
+      authorizeIndent = indentOf(line);
+      for (const name of authorize[1].split(/\s+/).filter((token) => token !== "or" && token.length > 0)) {
+        if (!policies.has(name)) {
+          issues.push(
+            tokenIssue(
+              "warning",
+              index,
+              line,
+              name,
+              `Unknown policy '${name}' \u2014 declare it with 'policy ${name}'.`,
+              diagnosticCodes.unknownPolicy
+            )
+          );
+        }
+      }
+    }
+    const reactsOn = trimmed.match(/^on\s+([A-Z]\w*)\s*$/);
+    if (reactsOn) checkEvent(index, line, reactsOn[1]);
+    const produces = trimmed.match(/^produces\s+([A-Z]\w*)\s*$/);
+    if (produces) checkEvent(index, line, produces[1]);
+    if (/^produces\s+when\b/.test(trimmed)) {
+      for (let next = index + 1; next < lines.length; next++) {
+        const candidate = lines[next];
+        if (fences[next] || candidate.trim().length === 0) continue;
+        if (indentOf(candidate) > indentOf(line)) {
+          const name = candidate.trim().match(/^([A-Z]\w*)\s*$/);
+          if (name) checkEvent(next, candidate, name[1]);
+        }
+        break;
+      }
+    }
+    const uniqueEvent = trimmed.match(/^unique\s+event\s+([A-Z]\w*)/);
+    if (uniqueEvent) checkEvent(index, line, uniqueEvent[1]);
+    const uniqueProperty = trimmed.match(/^unique\s+[a-z_]\w*\s+on\s+([A-Z]\w*)/);
+    if (uniqueProperty) checkEvent(index, line, uniqueProperty[1]);
+    for (const path of line.match(/\$context\.[\w.]+/g) ?? []) {
+      const segments = path.substring("$context.".length).split(".");
+      if (!contextRoots.includes(segments[0])) {
+        issues.push(
+          tokenIssue(
+            "warning",
+            index,
+            line,
+            path,
+            `Unknown $context path '${segments.join(".")}' \u2014 expected one of ${contextRoots.join(", ")}.`,
+            diagnosticCodes.unknownContextPath
+          )
+        );
+      } else if (segments[0] === "causedBy" && segments.length > 1 && !causedByProperties.includes(segments[1])) {
+        issues.push(
+          tokenIssue(
+            "warning",
+            index,
+            line,
+            path,
+            `Unknown $context.causedBy property '${segments[1]}' \u2014 expected ${causedByProperties.join(", ")}.`,
+            diagnosticCodes.unknownContextCausedByProperty
+          )
+        );
+      } else if (segments[0] === "identity" && segments.length > 1 && !identityProperties.includes(segments[1])) {
+        issues.push(
+          tokenIssue(
+            "warning",
+            index,
+            line,
+            path,
+            `Unknown $context.identity property '${segments[1]}' \u2014 expected ${identityProperties.join(", ")}.`,
+            diagnosticCodes.unknownContextIdentityProperty
+          )
+        );
+      }
+    }
+  }
+  issues.push(...validateEventContextPaths(lines, fences));
+  issues.push(...validateInlineEvents2(lines, symbols, application));
+  const fenceLines = lines.map((line, index) => ({ line, index })).filter(({ line }) => /^\s*```(?:[a-z]+)?\s*$/.test(line));
+  if (fenceLines.length % 2 === 1) {
+    const last = fenceLines[fenceLines.length - 1];
+    issues.push(
+      issue(
+        "error",
+        last.index,
+        1,
+        last.line.length + 1,
+        "Unclosed inline code block \u2014 expected a closing ``` line.",
+        diagnosticCodes.unclosedCodeBlock
+      )
+    );
+  }
+  return issues;
+}
+function validateProductionDestinations(lines, symbols) {
+  const issues = [];
+  lines = eventAnalysisSource(lines);
+  for (const command of symbols.commands) {
+    const identifiers = command.properties.filter((property) => property.isIdentifier && !propertyTypeReference(property).isOptional && !propertyTypeReference(property).isCollection);
+    if (identifiers.length !== 1) continue;
+    for (const production of command.produces ?? []) {
+      if (production.inline || production.conditional || production.target !== void 0) continue;
+      const line = production.line;
+      issues.push(issue(
+        "information",
+        line,
+        indentOf(lines[line]) + 1,
+        lines[line].trim().length,
+        `Plain 'produces ${production.name}' omits its destination \u2014 use 'for ${identifiers[0].name}' to explicitly select the command's identifier.`,
+        diagnosticCodes.omittedProductionDestination
+      ));
+    }
+  }
+  return issues;
+}
+function validateImport(lines, fences, index) {
+  const line = lines[index];
+  const trimmed = line.trim().replace(/\s*\/\/.*$/, "");
+  if (!/^import\b/.test(trimmed) || fileImportOn(line, index)) return void 0;
+  const indent = indentOf(line);
+  const inBody = indent > 0 && ["module", "feature"].includes(enclosingChain(lines, fences, index, indent)[0]);
+  if (!inBody && !isFileImportLine(line)) return void 0;
+  return issue(
+    "error",
+    index,
+    indent + 1,
+    trimmed.length,
+    `Invalid import '${trimmed}' \u2014 inside a module or feature, import names files: 'import "<path or glob>"'.`,
+    diagnosticCodes.invalidFileImport
+  );
+}
+var mappingTarget = /^(?:(?:increment|decrement|count|clear|add|subtract|set)\s+)?@?([$\w.]+)(?=\s|=|$)/;
+function validateEventContextPaths(lines, fences) {
+  const issues = [];
+  const names = (members) => members.map((member) => member.name).join(", ");
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (fences[index]) continue;
+    for (const match of line.matchAll(/(\.)?\$eventContext((?:\.(?:\w+(?:\(\))?)?)*)/g)) {
+      const token = match[0].substring(match[1]?.length ?? 0);
+      const written = match[2];
+      if (written.length === 0) {
+        if (match[1]) {
+          issues.push(issue("error", index, (match.index ?? 0) + 2, token.length, `'$eventContext' names no member - expected one of ${names(resolveEventContextPath("").expected)}.`, diagnosticCodes.missingEventContextPath));
+        }
+        continue;
+      }
+      const path = written.substring(1);
+      const resolution = resolveEventContextPath(path);
+      const column2 = (match.index ?? 0) + (match[1]?.length ?? 0) + 1;
+      switch (resolution.status) {
+        case "missing":
+          issues.push(issue("error", index, column2, token.length, `'$eventContext.${path}' names no member - expected one of ${names(resolution.expected)}.`, diagnosticCodes.missingEventContextPath));
+          break;
+        case "unknownMember":
+          issues.push(issue("warning", index, column2, token.length, `Unknown event context member '${resolution.segment}' in '$eventContext.${path}' - expected one of ${names(resolution.expected)}.`, diagnosticCodes.unknownEventContextMember));
+          break;
+        case "unknownSubPath": {
+          const has = resolution.expected.length === 0 ? "no members to address" : `members ${names(resolution.expected)}`;
+          issues.push(issue("warning", index, column2, token.length, `Unknown event context path '$eventContext.${path}' - '${resolution.member?.name}' (${resolution.member?.type}) has ${has}.`, diagnosticCodes.unknownEventContextPath));
+          break;
+        }
+        case "belowCollection":
+          issues.push(issue("error", index, column2, token.length, `'$eventContext.${path}' cannot resolve - '${resolution.member?.name}' is a collection (${resolution.member?.type}) and cannot be addressed below.`, diagnosticCodes.eventContextPathBelowCollection));
+          break;
+      }
+    }
+    const target = line.trim().match(mappingTarget)?.[1];
+    const source = target?.match(/\.\$(\w+)/)?.[1];
+    if (target && source && source !== "eventContext") {
+      issues.push(tokenIssue("warning", index, line, target, `Dynamic dictionary key '$${source}' in '${target}' is never resolved - only '$eventContext.<path>' is, so the literal text '$${source}' becomes the key.`, diagnosticCodes.unresolvedDynamicKeySource));
+    }
+  }
+  return issues;
+}
+
+export {
+  languageId,
+  languageExtensionPoint,
+  constructKeywords,
+  clauseKeywords,
+  codeBlockTags,
+  contextRoots,
+  causedByProperties,
+  sliceTypes,
+  primitiveTypes,
+  conceptAttributes,
+  languageConfiguration,
+  typeReferenceSymbol,
+  typeReferenceText,
+  indentOf,
+  firstWord,
+  fenceMap,
+  enclosingChain,
+  nearestEnclosingLine,
+  eventAnalysisSource,
+  propertyTypeReference,
+  directBody,
+  scanDocument,
+  mergeSymbols,
+  knownEventNames,
+  builtInTriggerNames,
+  knownTriggerNames,
+  knownTypeNames,
+  eventContextPaths,
+  namesEventContextMember,
+  eventContextMembers,
+  eventContextMembersAfter,
+  eventContextMemberAt,
+  describeEventContext,
+  describeEventContextMember,
+  productionDestinations,
+  destinationHints,
+  DiagnosticCodes,
+  prepareQuickFixes,
+  diagnosticCodes,
+  isFileImportLine,
+  fileImportOn,
+  fileImports,
+  importablePaths,
+  validateLines,
+  validateEventContextPaths
+};
+//# sourceMappingURL=chunk-7WJEZ72S.js.map