@almadar/core 10.102.0 → 10.104.0

package/dist/lolo-document/index.js

@@ -0,0 +1,615 @@
+// src/lolo-document/index.ts
+function isIdentStart(ch) {
+  return /[A-Za-z_@]/.test(ch);
+}
+function skipString(text, i) {
+  let j = i + 1;
+  while (j < text.length) {
+    const ch = text[j];
+    if (ch === "\\") {
+      j += 2;
+      continue;
+    }
+    if (ch === '"') return j + 1;
+    j++;
+  }
+  return text.length;
+}
+function skipComment(text, i) {
+  if (text.startsWith("#=", i)) {
+    const end = text.indexOf("=#", i + 2);
+    return end === -1 ? text.length : end + 2;
+  }
+  const nl = text.indexOf("\n", i);
+  return nl === -1 ? text.length : nl;
+}
+function isCommentStart(text, i) {
+  return text.startsWith(";;", i) || text[i] === "#";
+}
+function matchDelimiter(text, openIdx) {
+  const open = text[openIdx];
+  const close = open === "{" ? "}" : open === "[" ? "]" : open === "(" ? ")" : "";
+  if (close === "") return -1;
+  let depth = 0;
+  let i = openIdx;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      i = skipString(text, i);
+      continue;
+    }
+    if (isCommentStart(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function scanValueEnd(text, start, stopBefore) {
+  let i = start;
+  let depth = 0;
+  while (i < stopBefore) {
+    const ch = text[i];
+    if (ch === '"') {
+      i = skipString(text, i);
+      continue;
+    }
+    if (isCommentStart(text, i)) break;
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") {
+      if (depth === 0) break;
+      depth--;
+    } else if (ch === "\n" && depth === 0) break;
+    i++;
+  }
+  let end = i;
+  while (end > start && /\s/.test(text[end - 1])) end--;
+  return end;
+}
+function lineStart(text, idx) {
+  const nl = text.lastIndexOf("\n", idx - 1);
+  return nl === -1 ? 0 : nl + 1;
+}
+function lineEnd(text, idx) {
+  const nl = text.indexOf("\n", idx);
+  return nl === -1 ? text.length : nl;
+}
+function indentOf(text, idx) {
+  const ls = lineStart(text, idx);
+  const m = /^[ \t]*/.exec(text.slice(ls, lineEnd(text, ls)));
+  return m ? m[0] : "";
+}
+function* statementStarts(text, bodySpan) {
+  let i = bodySpan.start;
+  let depth = 0;
+  let atLineStart = true;
+  while (i < bodySpan.end) {
+    const ch = text[i];
+    if (ch === '"') {
+      i = skipString(text, i);
+      atLineStart = false;
+      continue;
+    }
+    if (isCommentStart(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    if (ch === "\n") {
+      atLineStart = true;
+      i++;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (depth === 0 && atLineStart && isIdentStart(ch)) {
+      yield i;
+    }
+    atLineStart = false;
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") depth--;
+    i++;
+  }
+}
+function aliasForBehavior(behavior) {
+  return behavior.split(/[^A-Za-z0-9]+/).filter((part) => part.length > 0).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+}
+var USES_RE = /^uses\s+([A-Za-z_][\w]*)\s+from\s+"([^"]+)"/;
+var TYPE_RE = /^type\s+([A-Za-z_][\w]*)\s*=/;
+var ENTITY_RE = /^entity\s+([A-Za-z_][\w]*)\s*(\[[^\]]*\])?\s*\{/;
+var TRAIT_REF_RE = /^trait\s+([A-Za-z_][\w]*)\s*(?:::[^=]*)?=\s*([A-Za-z_][\w]*)\.traits\.([A-Za-z_][\w]*)\s*(?:->\s*(@rebindable\s+)?([A-Za-z_][\w]*))?\s*\{/;
+var TRAIT_INLINE_RE = /^trait\s+([A-Za-z_][\w]*)\s*(?:::[^-]*)?->\s*(@rebindable\s+)?([A-Za-z_][\w]*)\s*(\[[^\]]*\])?\s*\{/;
+var PAGE_RE = /^page\s+"([^"]+)"(?:\s+as\s+([A-Za-z_][\w]*))?/;
+var FIELD_RE = /^([A-Za-z_][\w]*)\s*:\s*([^\n=]+?)(?:\s*=\s*|\s*$)/;
+function blockAt(text, openIdx) {
+  const close = matchDelimiter(text, openIdx);
+  if (close === -1) return null;
+  return { span: { start: openIdx, end: close + 1 }, bodySpan: { start: openIdx + 1, end: close } };
+}
+function parseConfigBlock(text, block) {
+  const entries = [];
+  for (const s of statementStarts(text, block.bodySpan)) {
+    if (text[s] === "@") continue;
+    const le = lineEnd(text, s);
+    const head = text.slice(s, le);
+    const m = /^([A-Za-z_][\w]*)\s*:/.exec(head);
+    if (!m) continue;
+    const key = m[1];
+    const afterColon = s + m[0].length;
+    const typed = /^(\s*)([^=\n]+?)\s*=\s*/.exec(text.slice(afterColon, le));
+    let type;
+    let valueStart;
+    if (typed && /^\s/.test(text.slice(afterColon, afterColon + 1)) && head.includes(" = ")) {
+      type = typed[2].trim();
+      valueStart = afterColon + typed[0].length;
+    } else {
+      valueStart = afterColon;
+      while (valueStart < le && /[ \t]/.test(text[valueStart])) valueStart++;
+    }
+    const valueEnd = scanValueEnd(text, valueStart, block.bodySpan.end);
+    entries.push({
+      key,
+      type,
+      valueSpan: { start: valueStart, end: valueEnd },
+      rawValue: text.slice(valueStart, valueEnd),
+      span: { start: lineStart(text, s), end: valueEnd }
+    });
+  }
+  return { ...block, entries };
+}
+function parseEventsBlock(text, block) {
+  const entries = [];
+  const body = text.slice(block.bodySpan.start, block.bodySpan.end);
+  const re = /([A-Za-z_][\w]*)\s*:\s*([A-Za-z_][\w]*)/g;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const start = block.bodySpan.start + m.index;
+    entries.push({ upstream: m[1], local: m[2], span: { start, end: start + m[0].length } });
+  }
+  return { ...block, entries };
+}
+function parseTrait(text, s) {
+  const rest = text.slice(s);
+  let decl;
+  let openOffset;
+  const ref = TRAIT_REF_RE.exec(rest);
+  if (ref) {
+    decl = {
+      name: ref[1],
+      inline: false,
+      alias: ref[2],
+      trait: ref[3],
+      entity: ref[5],
+      rebindable: ref[4] !== void 0
+    };
+    openOffset = ref[0].length - 1;
+  } else {
+    const inl = TRAIT_INLINE_RE.exec(rest);
+    if (!inl) return null;
+    decl = { name: inl[1], inline: true, entity: inl[3], rebindable: inl[2] !== void 0 };
+    openOffset = inl[0].length - 1;
+  }
+  const block = blockAt(text, s + openOffset);
+  if (!block) return null;
+  const trait = { ...decl, span: { start: s, end: block.span.end }, bodySpan: block.bodySpan, stateBlocks: [] };
+  for (const cs of statementStarts(text, block.bodySpan)) {
+    const le = lineEnd(text, cs);
+    const head = text.slice(cs, le);
+    const kw = /^(config|events|listens|state|fields|emits|ticks)\b\s*([A-Za-z_][\w]*)?[^{]*\{/.exec(head);
+    if (!kw) continue;
+    const open = cs + head.indexOf("{");
+    const sub = blockAt(text, open);
+    if (!sub) continue;
+    if (kw[1] === "config") trait.config = parseConfigBlock(text, sub);
+    else if (kw[1] === "events") trait.events = parseEventsBlock(text, sub);
+    else if (kw[1] === "listens") trait.listens = sub;
+    else if (kw[1] === "state" && kw[2]) trait.stateBlocks.push({ name: kw[2], span: { start: cs, end: sub.span.end } });
+  }
+  return trait;
+}
+function parseEntity(text, s) {
+  const m = ENTITY_RE.exec(text.slice(s));
+  if (!m) return null;
+  const block = blockAt(text, s + m[0].length - 1);
+  if (!block) return null;
+  const fields = [];
+  for (const fs of statementStarts(text, block.bodySpan)) {
+    const le = lineEnd(text, fs);
+    const fm = FIELD_RE.exec(text.slice(fs, le));
+    if (!fm) continue;
+    fields.push({ name: fm[1], type: fm[2].trim(), span: { start: lineStart(text, fs), end: le } });
+  }
+  return { name: m[1], tags: m[2] ?? "", fields, span: { start: s, end: block.span.end }, bodySpan: block.bodySpan };
+}
+function parsePage(text, s) {
+  const le = lineEnd(text, s);
+  const head = text.slice(s, le);
+  const m = PAGE_RE.exec(head);
+  if (!m) return null;
+  const bracket = head.indexOf("[", m[0].length);
+  const tail = bracket === -1 ? le : s + bracket;
+  const arrowIdx = head.indexOf("->", m[0].length);
+  const arrowAt = arrowIdx !== -1 && (bracket === -1 || arrowIdx < bracket) ? s + arrowIdx : -1;
+  let traitsStart;
+  let traitsEnd = tail;
+  if (arrowAt === -1) {
+    while (traitsEnd > s + m[0].length && /\s/.test(text[traitsEnd - 1])) traitsEnd--;
+    traitsStart = traitsEnd;
+  } else {
+    traitsStart = arrowAt + 2;
+    while (traitsStart < tail && /\s/.test(text[traitsStart])) traitsStart++;
+    while (traitsEnd > traitsStart && /\s/.test(text[traitsEnd - 1])) traitsEnd--;
+  }
+  const traits = arrowAt === -1 ? [] : text.slice(traitsStart, traitsEnd).split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  const page = { path: m[1], name: m[2], traits, traitsSpan: { start: traitsStart, end: traitsEnd }, span: { start: s, end: le } };
+  if (arrowAt !== -1) {
+    let arrowStart = arrowAt;
+    while (arrowStart > s && /\s/.test(text[arrowStart - 1])) arrowStart--;
+    page.arrowSpan = { start: arrowStart, end: arrowAt + 2 };
+  }
+  return page;
+}
+function parseLoloDocument(text) {
+  const orbitalRe = /^orbital\s+([A-Za-z_][\w]*)\s*\{/m;
+  const om = orbitalRe.exec(text);
+  if (!om || om.index === void 0) throw new Error("lolo-document: no `orbital Name {` block found");
+  const openIdx = om.index + om[0].length - 1;
+  const block = blockAt(text, openIdx);
+  if (!block) throw new Error("lolo-document: unbalanced orbital block");
+  const doc = {
+    text,
+    orbital: { name: om[1], span: { start: om.index, end: block.span.end }, bodySpan: block.bodySpan },
+    uses: [],
+    types: [],
+    entities: [],
+    traits: [],
+    pages: [],
+    indent: "  "
+  };
+  const appMatch = /^app\s+([\w.-]+)\s+(?:"([^"]+)"|(v[\w.]+))/m.exec(text);
+  if (appMatch && appMatch.index !== void 0) {
+    doc.app = { name: appMatch[1], version: appMatch[2] ?? appMatch[3] ?? "", span: { start: appMatch.index, end: lineEnd(text, appMatch.index) } };
+  }
+  let indentSeen = false;
+  for (const s of statementStarts(text, block.bodySpan)) {
+    if (!indentSeen) {
+      doc.indent = indentOf(text, s);
+      indentSeen = true;
+    }
+    const le = lineEnd(text, s);
+    const head = text.slice(s, le);
+    const u = USES_RE.exec(head);
+    if (u) {
+      doc.uses.push({ alias: u[1], from: u[2], span: { start: s, end: le } });
+      continue;
+    }
+    const t = TYPE_RE.exec(head);
+    if (t) {
+      const brace = head.indexOf("{");
+      const end = brace !== -1 ? matchDelimiter(text, s + brace) + 1 : le;
+      doc.types.push({ name: t[1], span: { start: s, end } });
+      continue;
+    }
+    if (head.startsWith("entity ")) {
+      const e = parseEntity(text, s);
+      if (e) doc.entities.push(e);
+      continue;
+    }
+    if (head.startsWith("trait ")) {
+      const tr = parseTrait(text, s);
+      if (tr) doc.traits.push(tr);
+      continue;
+    }
+    if (head.startsWith("page ")) {
+      const p = parsePage(text, s);
+      if (p) doc.pages.push(p);
+    }
+  }
+  return doc;
+}
+function applyEdits(text, edits) {
+  const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].end > sorted[i - 1].start) throw new Error("lolo-document: overlapping edits");
+  }
+  let out = text;
+  for (const e of sorted) out = out.slice(0, e.start) + e.insert + out.slice(e.end);
+  return out;
+}
+function quote(s) {
+  return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n") + '"';
+}
+function formatLoloValue(value, indent = "") {
+  if (value === null) return "null";
+  if (typeof value === "string") return quote(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const allObjects = value.every((v) => typeof v === "object" && v !== null && !Array.isArray(v));
+    if (allObjects) {
+      const inner = indent + "  ";
+      return "[\n" + value.map((v) => inner + formatLoloValue(v, inner)).join("\n") + "\n" + indent + "]";
+    }
+    return "[" + value.map((v) => formatLoloValue(v, indent)).join(" ") + "]";
+  }
+  const parts = Object.entries(value).map(([k, v]) => `${k}: ${formatLoloValue(v, indent)}`);
+  return parts.length === 0 ? "{}" : "{ " + parts.join(", ") + " }";
+}
+function inferLoloType(value) {
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "[object]";
+  return "object";
+}
+function findTrait(doc, name) {
+  const t = doc.traits.find((x) => x.name === name);
+  if (!t) throw new Error(`lolo-document: trait "${name}" not found`);
+  return t;
+}
+function insertAtBlockEnd(text, block, line, childIndent) {
+  const closeIdx = block.bodySpan.end;
+  const ls = lineStart(text, closeIdx);
+  const singleLine = !text.slice(block.bodySpan.start, block.bodySpan.end).includes("\n");
+  if (singleLine) {
+    const parentIndent = indentOf(text, block.span.start);
+    let at = block.bodySpan.end;
+    while (at > block.bodySpan.start && /\s/.test(text[at - 1])) at--;
+    return { start: at, end: block.bodySpan.end, insert: `
+${childIndent}${line}
+${parentIndent}` };
+  }
+  return { start: ls, end: ls, insert: `${childIndent}${line}
+` };
+}
+function childIndentOf(text, block, fallbackParentIndent) {
+  const openerLine = lineStart(text, block.span.start);
+  for (const s of statementStarts(text, block.bodySpan)) {
+    if (lineStart(text, s) !== openerLine) return indentOf(text, s);
+  }
+  return fallbackParentIndent + "  ";
+}
+function addUses(doc, alias, from) {
+  if (doc.uses.some((u) => u.from === from || u.alias === alias)) return [];
+  const line = `${doc.indent}uses ${alias} from ${quote(from)}
+`;
+  if (doc.uses.length > 0) {
+    const last = doc.uses[doc.uses.length - 1];
+    const at2 = lineEnd(doc.text, last.span.end) + 1;
+    return [{ start: at2, end: at2, insert: line }];
+  }
+  const at = lineEnd(doc.text, doc.orbital.bodySpan.start) + 1;
+  return [{ start: at, end: at, insert: line }];
+}
+function usesAlias(doc, from) {
+  return doc.uses.find((u) => u.from === from)?.alias;
+}
+function addTraitRef(doc, input) {
+  if (doc.traits.some((t) => t.name === input.name)) throw new Error(`lolo-document: trait "${input.name}" already exists`);
+  const ind = doc.indent;
+  const inner = ind + "  ";
+  const lines = [`${ind}trait ${input.name} = ${input.alias}.traits.${input.trait} -> ${input.entity} {`];
+  const events = Object.entries(input.events ?? {});
+  if (events.length > 0) {
+    lines.push(`${inner}events {`);
+    for (const [up, local] of events) lines.push(`${inner}  ${up}: ${local}`);
+    lines.push(`${inner}}`);
+  }
+  const cfg = Object.entries(input.config);
+  if (cfg.length > 0) {
+    lines.push(`${inner}config {`);
+    for (const [k, v] of cfg) lines.push(`${inner}  ${k}: ${formatLoloValue(v, inner + "  ")}`);
+    lines.push(`${inner}}`);
+  }
+  lines.push(`${ind}}`);
+  const block = lines.join("\n") + "\n\n";
+  const anchor = doc.pages.length > 0 ? lineStart(doc.text, doc.pages[0].span.start) : lineStart(doc.text, doc.orbital.bodySpan.end);
+  return [{ start: anchor, end: anchor, insert: block }];
+}
+function removeTrait(doc, name) {
+  const trait = findTrait(doc, name);
+  const edits = [];
+  const ls = lineStart(doc.text, trait.span.start);
+  let end = lineEnd(doc.text, trait.span.end);
+  if (doc.text[end] === "\n") end++;
+  if (doc.text[end] === "\n" && doc.text[ls - 1] === "\n" && doc.text[ls - 2] === "\n") end++;
+  edits.push({ start: ls, end, insert: "" });
+  for (const page of doc.pages) {
+    if (page.traits.includes(name)) edits.push(...removePageTrait(doc, page.path, name));
+  }
+  if (trait.alias !== void 0) {
+    const stillUsed = doc.traits.some((t) => t.name !== name && t.alias === trait.alias);
+    const pageUses = doc.text.slice(doc.orbital.bodySpan.start, doc.orbital.bodySpan.end).includes(`${trait.alias}.pages.`);
+    if (!stillUsed && !pageUses) {
+      const u = doc.uses.find((x) => x.alias === trait.alias);
+      if (u) {
+        const uls = lineStart(doc.text, u.span.start);
+        let uend = lineEnd(doc.text, u.span.end);
+        if (doc.text[uend] === "\n") uend++;
+        edits.push({ start: uls, end: uend, insert: "" });
+      }
+    }
+  }
+  return edits;
+}
+function findPage(doc, path) {
+  const p = doc.pages.find((x) => x.path === path);
+  if (!p) throw new Error(`lolo-document: page "${path}" not found`);
+  return p;
+}
+function appendPageTrait(doc, path, traitName) {
+  const page = findPage(doc, path);
+  if (page.traits.includes(traitName)) return [];
+  const insert = page.arrowSpan === void 0 ? ` -> ${traitName}` : page.traits.length === 0 ? traitName : `, ${traitName}`;
+  return [{ start: page.traitsSpan.end, end: page.traitsSpan.end, insert }];
+}
+function removePageTrait(doc, path, traitName) {
+  const page = findPage(doc, path);
+  if (!page.traits.includes(traitName)) return [];
+  const remaining = page.traits.filter((t) => t !== traitName);
+  if (remaining.length === 0 && page.arrowSpan !== void 0) {
+    return [{ start: page.arrowSpan.start, end: page.traitsSpan.end, insert: "" }];
+  }
+  return [{ start: page.traitsSpan.start, end: page.traitsSpan.end, insert: remaining.join(", ") }];
+}
+function setConfigValue(doc, traitName, key, value) {
+  const trait = findTrait(doc, traitName);
+  const text = doc.text;
+  if (trait.config) {
+    const entry = trait.config.entries.find((e) => e.key === key);
+    const childIndent = childIndentOf(text, trait.config, indentOf(text, trait.config.span.start));
+    if (entry) {
+      return [{ start: entry.valueSpan.start, end: entry.valueSpan.end, insert: formatLoloValue(value, childIndent) }];
+    }
+    const typed = trait.config.entries.some((e) => e.type !== void 0) || trait.inline;
+    const line2 = typed ? `${key} : ${inferLoloType(value)} = ${formatLoloValue(value, childIndent)}` : `${key}: ${formatLoloValue(value, childIndent)}`;
+    return [insertAtBlockEnd(text, trait.config, line2, childIndent)];
+  }
+  const inner = indentOf(text, trait.span.start) + "  ";
+  const line = trait.inline ? `${inner}config {
+${inner}  ${key} : ${inferLoloType(value)} = ${formatLoloValue(value, inner + "  ")}
+${inner}}
+` : `${inner}config {
+${inner}  ${key}: ${formatLoloValue(value, inner + "  ")}
+${inner}}
+`;
+  const ls = lineStart(text, trait.bodySpan.end);
+  return [{ start: ls, end: ls, insert: line }];
+}
+function arrayElementSpans(text, arraySpan) {
+  const spans = [];
+  const open = text.indexOf("[", arraySpan.start);
+  if (open === -1 || open >= arraySpan.end) return spans;
+  let i = open + 1;
+  const close = arraySpan.end - 1;
+  while (i < close) {
+    const ch = text[i];
+    if (/[\s,]/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (isCommentStart(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    let end;
+    if (ch === "{" || ch === "[" || ch === "(") end = matchDelimiter(text, i) + 1;
+    else if (ch === '"') end = skipString(text, i);
+    else {
+      end = i;
+      while (end < close && !/[\s,\]]/.test(text[end])) end++;
+    }
+    spans.push({ start: i, end });
+    i = end;
+  }
+  return spans;
+}
+function patchObjectLiteral(text, span, patch) {
+  const edits = [];
+  const body = { start: span.start + 1, end: span.end - 1 };
+  const remaining = new Map(Object.entries(patch));
+  let i = body.start;
+  while (i < body.end) {
+    const ch = text[i];
+    if (/[\s,]/.test(ch)) {
+      i++;
+      continue;
+    }
+    const km = /^([A-Za-z_][\w]*)\s*:\s*/.exec(text.slice(i, body.end));
+    if (!km) break;
+    const vs = i + km[0].length;
+    let ve;
+    const vc = text[vs];
+    if (vc === "{" || vc === "[" || vc === "(") ve = matchDelimiter(text, vs) + 1;
+    else if (vc === '"') ve = skipString(text, vs);
+    else {
+      ve = vs;
+      while (ve < body.end && !/[\s,}]/.test(text[ve])) ve++;
+    }
+    const key = km[1];
+    if (remaining.has(key)) {
+      const v = remaining.get(key);
+      if (v !== void 0) edits.push({ start: vs, end: ve, insert: formatLoloValue(v) });
+      remaining.delete(key);
+    }
+    i = ve;
+  }
+  if (remaining.size > 0) {
+    const tail = [...remaining.entries()].map(([k, v]) => `${k}: ${formatLoloValue(v)}`).join(", ");
+    let insertAt = body.end;
+    while (insertAt > body.start && /\s/.test(text[insertAt - 1])) insertAt--;
+    const hasFields = text.slice(body.start, body.end).trim().length > 0;
+    edits.push({ start: insertAt, end: insertAt, insert: hasFields ? `, ${tail}` : ` ${tail} ` });
+  }
+  return edits;
+}
+function setConfigArrayRow(doc, traitName, key, index, patch) {
+  const trait = findTrait(doc, traitName);
+  const entry = trait.config?.entries.find((e) => e.key === key);
+  if (!entry) throw new Error(`lolo-document: config "${key}" not found on trait "${traitName}"`);
+  const elements = arrayElementSpans(doc.text, entry.valueSpan);
+  const el = elements[index];
+  if (!el) throw new Error(`lolo-document: "${key}[${index}]" out of range (${elements.length} elements)`);
+  if (doc.text[el.start] !== "{") throw new Error(`lolo-document: "${key}[${index}]" is not an object literal`);
+  return patchObjectLiteral(doc.text, el, patch);
+}
+function renameEvent(doc, traitName, upstream, local) {
+  const trait = findTrait(doc, traitName);
+  if (trait.inline) throw new Error("lolo-document: events {} renames apply to referenced traits only");
+  const text = doc.text;
+  if (trait.events) {
+    const existing = trait.events.entries.find((e) => e.upstream === upstream);
+    const childIndent = childIndentOf(text, trait.events, indentOf(text, trait.events.span.start));
+    if (existing) {
+      return [{ start: existing.span.start, end: existing.span.end, insert: `${upstream}: ${local}` }];
+    }
+    return [insertAtBlockEnd(text, trait.events, `${upstream}: ${local}`, childIndent)];
+  }
+  const inner = indentOf(text, trait.span.start) + "  ";
+  const at = lineEnd(text, trait.span.start) + 1;
+  return [{ start: at, end: at, insert: `${inner}events {
+${inner}  ${upstream}: ${local}
+${inner}}
+` }];
+}
+function addListens(doc, traitName, route, atomRoutes = []) {
+  const trait = findTrait(doc, traitName);
+  const text = doc.text;
+  const line = `${route.source}.${route.event} -> ${route.local}`;
+  if (trait.listens) {
+    const body = text.slice(trait.listens.bodySpan.start, trait.listens.bodySpan.end);
+    if (body.includes(line)) return [];
+    const childIndent = childIndentOf(text, trait.listens, indentOf(text, trait.listens.span.start));
+    return [insertAtBlockEnd(text, trait.listens, line, childIndent)];
+  }
+  const inner = indentOf(text, trait.span.start) + "  ";
+  const routes = trait.inline ? [route] : [...atomRoutes, route];
+  const lines = routes.map((r) => `${inner}  ${r.source}.${r.event} -> ${r.local}`);
+  const ls = lineStart(text, trait.bodySpan.end);
+  return [{ start: ls, end: ls, insert: `${inner}listens {
+${lines.join("\n")}
+${inner}}
+` }];
+}
+function addEntityFields(doc, entityName, fields) {
+  const entity = doc.entities.find((e) => e.name === entityName);
+  if (!entity) throw new Error(`lolo-document: entity "${entityName}" not found`);
+  const missing = fields.filter((f) => !entity.fields.some((x) => x.name === f.name));
+  if (missing.length === 0) return [];
+  const childIndent = childIndentOf(doc.text, entity, indentOf(doc.text, entity.span.start));
+  const lines = missing.map((f) => `${childIndent}${f.name} : ${f.type}${f.default !== void 0 ? ` = ${formatLoloValue(f.default, childIndent)}` : ""}
+`);
+  const ls = lineStart(doc.text, entity.bodySpan.end);
+  return [{ start: ls, end: ls, insert: lines.join("") }];
+}
+
+export { addEntityFields, addListens, addTraitRef, addUses, aliasForBehavior, appendPageTrait, applyEdits, arrayElementSpans, findPage, formatLoloValue, lineStart, matchDelimiter, parseLoloDocument, removePageTrait, removeTrait, renameEvent, setConfigArrayRow, setConfigValue, usesAlias };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map