@wildwinter/toolkit 0.1.0 → 0.2.1

package/dist/extensions.js

@@ -0,0 +1,902 @@
+import { parseSource } from './chunk-ONEAWPDZ.js';
+import { valueFits, stagesEitherSide, qualityDeclarationProblems } from '@wildwinter/expr';
+import { defaultFor } from '@wildwinter/scoperegistry';
+
+// src/extensions/types.ts
+var MANIFEST_SCHEMA = "wildwinter/extension@0";
+var MANIFEST_FILE_SUFFIX = ".extension.json";
+var HOSTS = {
+  patter: {
+    kinds: ["scene", "block", "snippet", "line", "text", "gameEvent", "option", "project"],
+    references: ["cast", "scene", "block", "snippet", "line"],
+    claimable: ["scene", "block", "snippet", "line", "text", "gameEvent", "option"]
+  },
+  storylets: {
+    kinds: ["box", "tagGroup", "tag", "deck", "card", "outcome", "handTemplate", "hand", "project"],
+    references: ["box", "deck", "card", "outcome", "tag"],
+    claimable: ["card", "outcome"]
+  }
+};
+var SCALAR_TYPES = ["text", "multiline", "number", "boolean", "enum", "flags", "quality"];
+var VALUE_TYPES = [...SCALAR_TYPES, "reference", "record", "map", "list"];
+
+// src/extensions/path.ts
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var atKey = (base, key) => IDENTIFIER.test(key) ? base === "" ? key : `${base}.${key}` : `${base}[${JSON.stringify(key)}]`;
+var atIndex = (base, i) => `${base}[${i}]`;
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var own = (record, name) => Object.prototype.hasOwnProperty.call(record, name);
+var typeWord = (v) => Array.isArray(v) ? "a list" : v === null ? "null" : isObject(v) ? "an object" : `a ${typeof v}`;
+var where = (path) => path === "" ? "the value" : `"${path}"`;
+var err = (code, path, message, options) => ({ severity: "error", code, path, message, ...options !== void 0 ? { options } : {} });
+function valueProblems(decl, value, ctx = {}, path = "") {
+  const out = [];
+  const wrong = (expected) => {
+    out.push(err("wrong-type", path, `${where(path)} should be ${expected}, not ${typeWord(value)}`));
+  };
+  switch (decl.type) {
+    case "text":
+    case "multiline":
+      if (typeof value !== "string") wrong("text");
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") wrong("true or false");
+      break;
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        wrong("a number");
+        break;
+      }
+      if (typeof decl.min === "number" && value < decl.min) {
+        out.push(err("below-min", path, `${where(path)} is ${value}, below the least it may be, ${decl.min}`));
+      }
+      if (typeof decl.max === "number" && value > decl.max) {
+        out.push(err("above-max", path, `${where(path)} is ${value}, above the most it may be, ${decl.max}`));
+      }
+      break;
+    case "enum":
+      if (typeof value !== "string") {
+        wrong("one of its values");
+        break;
+      }
+      if (!valueFits(decl, value, { noneChosen: true })) {
+        out.push(err("not-a-value", path, `${where(path)} is "${value}", which is not one of its values`, [...decl.values ?? []]));
+      }
+      break;
+    case "flags":
+      if (!Array.isArray(value) || !value.every((f) => typeof f === "string")) {
+        wrong("a list of its flags");
+        break;
+      }
+      if (!valueFits(decl, value)) {
+        const odd = value.filter((f) => !(decl.values ?? []).includes(f));
+        out.push(err("not-a-value", path, `${where(path)} names ${odd.map((f) => `"${f}"`).join(", ")}, not among its flags`, [...decl.values ?? []]));
+      }
+      break;
+    case "quality": {
+      if (typeof value !== "string") {
+        wrong("one of its stages");
+        break;
+      }
+      if (valueFits(decl, value)) break;
+      const renamed = renamedStage(decl, value);
+      if (renamed !== void 0) {
+        out.push({
+          severity: "warning",
+          code: "renamed-stage",
+          path,
+          options: [renamed],
+          message: `${where(path)} is "${value}", a stage this extension has since renamed "${renamed}"`
+        });
+      } else {
+        out.push(err("not-a-stage", path, `${where(path)} is "${value}", which is not one of its stages`, stagesEitherSide(decl, value)));
+      }
+      break;
+    }
+    case "reference":
+      if (typeof value !== "string") {
+        wrong(`the id of a ${decl.to ?? "node"}`);
+        break;
+      }
+      if (value !== "" && ctx.exists && decl.to !== void 0 && !ctx.exists(decl.to, value)) {
+        out.push(err("no-such-node", path, `${where(path)} names ${decl.to} "${value}", which does not exist`));
+      }
+      break;
+    case "record":
+      if (!isObject(value)) {
+        wrong("an object");
+        break;
+      }
+      out.push(...fieldsProblems(decl.fields ?? [], value, ctx, path));
+      break;
+    case "map": {
+      if (!isObject(value)) {
+        wrong("an object");
+        break;
+      }
+      const key = decl.key;
+      for (const [k, v] of Object.entries(value)) {
+        const at = atKey(path, k);
+        if (key?.type === "reference" && ctx.exists && key.to !== void 0 && !ctx.exists(key.to, k)) {
+          out.push(err("no-such-node", at, `${where(at)} is keyed by ${key.to} "${k}", which does not exist`));
+        }
+        if (decl.of) out.push(...valueProblems(decl.of, v, ctx, at));
+      }
+      break;
+    }
+    case "list": {
+      if (!Array.isArray(value)) {
+        wrong("a list");
+        break;
+      }
+      const seen = /* @__PURE__ */ new Set();
+      value.forEach((item, i) => {
+        const at = atIndex(path, i);
+        if (decl.id !== void 0 && isObject(item)) {
+          const id = item[decl.id];
+          const idAt = atKey(at, decl.id);
+          if (typeof id !== "string" || id === "") {
+            out.push(err("missing-id", idAt, `${where(at)} has no "${decl.id}", which keys every item of this list`));
+          } else if (seen.has(id)) {
+            out.push(err("duplicate-id", idAt, `${where(at)} repeats the id "${id}"`));
+          } else {
+            seen.add(id);
+          }
+        }
+        if (decl.of) out.push(...valueProblems(decl.of, item, ctx, at));
+      });
+      break;
+    }
+  }
+  return out;
+}
+function fieldsProblems(fields, value, ctx, path) {
+  const out = [];
+  const named = new Map(fields.map((f) => [f.name, f]));
+  for (const f of fields) {
+    if (f.required === true && !own(value, f.name)) {
+      const at = atKey(path, f.name);
+      out.push(err("required", at, `${where(at)} is required and not set`));
+    }
+  }
+  for (const [k, v] of Object.entries(value)) {
+    const at = atKey(path, k);
+    const f = named.get(k);
+    if (f === void 0) {
+      out.push({
+        severity: "warning",
+        code: "unknown-field",
+        path: at,
+        message: `${where(at)} is not a field this extension declares; it is kept, and not compiled`
+      });
+      continue;
+    }
+    out.push(...valueProblems(f, v, ctx, at));
+  }
+  return out;
+}
+function entryProblems(target, entry, ctx = {}, path = "") {
+  if (!isObject(entry)) {
+    return [err("wrong-type", path, `${where(path)} should be an object of field values, not ${typeWord(entry)}`)];
+  }
+  return fieldsProblems(target.fields ?? [], entry, ctx, path);
+}
+function defaultOf(decl) {
+  if (decl.default !== void 0) return decl.default;
+  switch (decl.type) {
+    case "reference":
+      return "";
+    case "record":
+      return Object.fromEntries((decl.fields ?? []).map((f) => [f.name, defaultOf(f)]));
+    case "map":
+      return {};
+    case "list":
+      return [];
+    default:
+      return defaultFor({
+        type: decl.type,
+        ...decl.values !== void 0 ? { values: decl.values } : {},
+        ...decl.stages !== void 0 ? { stages: decl.stages } : {}
+      });
+  }
+}
+var EDITOR_KEYS = /* @__PURE__ */ new Set(["label", "help", "valueHelp", "group", "editorOnly", "renamedStages"]);
+function compiledDecl(decl) {
+  const out = {};
+  for (const [k, v] of Object.entries(decl)) if (!EDITOR_KEYS.has(k)) out[k] = v;
+  if (decl.fields !== void 0) out["fields"] = decl.fields.map((f) => compiledDecl(f));
+  if (decl.of !== void 0) out["of"] = compiledDecl(decl.of);
+  out["default"] = defaultOf(decl);
+  return out;
+}
+function compiledTarget(target) {
+  return (target.fields ?? []).filter((f) => f.editorOnly !== true).map((f) => stripOfDefaults(compiledDecl(f)));
+}
+function stripOfDefaults(decl) {
+  const out = { ...decl };
+  if (decl.of !== void 0) {
+    const { default: _drop, ...rest } = decl.of;
+    out["of"] = stripOfDefaults(rest);
+  }
+  if (decl.fields !== void 0) out["fields"] = decl.fields.map((f) => stripOfDefaults(f));
+  return out;
+}
+function compileEntry(target, entry) {
+  const renamed = renameStages(target, entry).entry;
+  const out = {};
+  const named = new Map((target.fields ?? []).map((f) => [f.name, f]));
+  for (const k of Object.keys(renamed).sort()) {
+    const f = named.get(k);
+    if (f === void 0 || f.editorOnly === true) continue;
+    out[k] = renamed[k];
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function renamedStage(decl, value) {
+  const map = decl.renamedStages;
+  if (map === void 0 || !own(map, value)) return void 0;
+  const to = map[value];
+  return typeof to === "string" && (decl.stages ?? []).includes(to) ? to : void 0;
+}
+function renameStages(target, entry) {
+  const renames = [];
+  const walk = (decl, value, path) => {
+    switch (decl.type) {
+      case "quality": {
+        if (typeof value !== "string" || (decl.stages ?? []).includes(value)) return value;
+        const to = renamedStage(decl, value);
+        if (to === void 0) return value;
+        renames.push({ path, from: value, to });
+        return to;
+      }
+      case "record":
+        return isObject(value) ? walkFields(decl.fields ?? [], value, path) : value;
+      case "map":
+        if (!isObject(value) || decl.of === void 0) return value;
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(decl.of, v, atKey(path, k))]));
+      case "list":
+        if (!Array.isArray(value) || decl.of === void 0) return value;
+        return value.map((v, i) => walk(decl.of, v, atIndex(path, i)));
+      default:
+        return value;
+    }
+  };
+  const walkFields = (fields, value, path) => {
+    const named = new Map(fields.map((f) => [f.name, f]));
+    const out2 = {};
+    for (const [k, v] of Object.entries(value)) {
+      const f = named.get(k);
+      out2[k] = f === void 0 ? v : walk(f, v, atKey(path, k));
+    }
+    return out2;
+  };
+  const out = walkFields(target.fields ?? [], entry, "");
+  return { entry: renames.length > 0 ? out : { ...entry }, renames };
+}
+
+// src/extensions/manifest.ts
+var ID = /^[a-z][a-z0-9-]*$/;
+var VERSION = /^\d+\.\d+\.\d+$/;
+var NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var TYPE_KEYS = ["type", "values", "stages", "renamedStages", "to", "fields", "key", "of", "id", "min", "max", "valueHelp", "default"];
+var FIELD_KEYS = /* @__PURE__ */ new Set([...TYPE_KEYS, "name", "label", "help", "required", "group", "editorOnly"]);
+var CLAIM_KEYS = /* @__PURE__ */ new Set([...TYPE_KEYS, "setting", "label", "help", "required"]);
+var BARE_KEYS = new Set(TYPE_KEYS);
+var MANIFEST_KEYS = /* @__PURE__ */ new Set(["schema", "id", "name", "version", "docs", "settings", "targets"]);
+var err2 = (code, path, message) => ({ severity: "error", code, path, message });
+function parseManifest(text) {
+  return parseSource(text);
+}
+function manifestProblems(manifest) {
+  const out = [];
+  if (!isObject(manifest)) return [err2("not-an-object", "", "a manifest is a JSON object")];
+  const m = manifest;
+  unknownKeys(m, MANIFEST_KEYS, "", out);
+  if (m["schema"] !== MANIFEST_SCHEMA) {
+    out.push(err2("schema", "schema", `the schema tag is ${JSON.stringify(m["schema"])}, not "${MANIFEST_SCHEMA}"`));
+  }
+  if (typeof m["id"] !== "string" || !ID.test(m["id"])) {
+    out.push(err2("id", "id", "the id is lower case letters, digits and hyphens, starting with a letter"));
+  }
+  if (typeof m["name"] !== "string" || m["name"].trim() === "") out.push(err2("name", "name", "the manifest has no name"));
+  if (typeof m["version"] !== "string" || !VERSION.test(m["version"])) {
+    out.push(err2("version", "version", "the version is major.minor.patch, such as 1.0.0"));
+  }
+  if (m["docs"] !== void 0 && typeof m["docs"] !== "string") out.push(err2("docs", "docs", "docs is a link, as text"));
+  const settings = settingsProblems(m["settings"], out);
+  const targets = m["targets"];
+  if (!isObject(targets) || Object.keys(targets).length === 0) {
+    out.push(err2("no-targets", "targets", "the manifest targets no host"));
+    return out;
+  }
+  for (const [host, kinds] of Object.entries(targets)) {
+    const hostPath = atKey("targets", host);
+    const spec = own(HOSTS, host) ? HOSTS[host] : void 0;
+    if (spec === void 0) {
+      out.push(err2("unknown-host", hostPath, `"${host}" is not a host; a manifest targets "patter" or "storylets"`));
+      continue;
+    }
+    if (!isObject(kinds)) {
+      out.push(err2("not-an-object", hostPath, "a host's targets are an object, by node kind"));
+      continue;
+    }
+    for (const [kind, target] of Object.entries(kinds)) {
+      const kindPath = atKey(hostPath, kind);
+      if (!spec.kinds.includes(kind)) {
+        out.push(err2("unknown-kind", kindPath, `"${kind}" is not a node kind of ${host}; it has ${spec.kinds.join(", ")}`));
+        continue;
+      }
+      targetProblems(host, kind, target, kindPath, settings, out);
+    }
+  }
+  return out;
+}
+function unknownKeys(obj, known, path, out) {
+  for (const k of Object.keys(obj)) {
+    if (!known.has(k)) {
+      out.push({ severity: "warning", code: "unknown-key", path: atKey(path, k), message: `"${k}" means nothing here; it is ignored` });
+    }
+  }
+}
+function settingsProblems(settings, out) {
+  const names = /* @__PURE__ */ new Set();
+  if (settings === void 0) return names;
+  if (!Array.isArray(settings)) {
+    out.push(err2("not-a-list", "settings", "settings are a list"));
+    return names;
+  }
+  settings.forEach((s, i) => {
+    const at = atIndex("settings", i);
+    if (!isObject(s)) {
+      out.push(err2("not-an-object", at, "a setting is an object"));
+      return;
+    }
+    const name = s["name"];
+    if (typeof name !== "string" || !NAME.test(name)) {
+      out.push(err2("setting-name", atKey(at, "name"), "a setting's name is an identifier"));
+    } else if (names.has(name)) {
+      out.push(err2("setting-duplicate", atKey(at, "name"), `setting "${name}" is declared twice`));
+    } else {
+      names.add(name);
+    }
+    const dflt = s.default;
+    if (typeof dflt !== "string" || !NAME.test(dflt)) {
+      out.push(err2("setting-default", atKey(at, "default"), "a setting names a host field by default, so its default is a field name"));
+    }
+  });
+  return names;
+}
+function targetProblems(host, kind, target, path, settings, out) {
+  if (!isObject(target)) {
+    out.push(err2("not-an-object", path, "a target is an object"));
+    return;
+  }
+  unknownKeys(target, /* @__PURE__ */ new Set(["fields", "claims"]), path, out);
+  const t = target;
+  if (t.fields !== void 0) fieldListProblems(host, t.fields, atKey(path, "fields"), true, out);
+  if (t.claims === void 0) return;
+  if (!Array.isArray(t.claims)) {
+    out.push(err2("not-a-list", atKey(path, "claims"), "claims are a list"));
+    return;
+  }
+  const claimable = HOSTS[host].claimable.includes(kind);
+  const claimed = /* @__PURE__ */ new Set();
+  t.claims.forEach((c, i) => {
+    const at = atIndex(atKey(path, "claims"), i);
+    if (!claimable) {
+      out.push(err2("claim-kind", at, `a ${kind} has no host fields to claim; ${host} has them on ${HOSTS[host].claimable.join(", ")}`));
+      return;
+    }
+    if (!isObject(c)) {
+      out.push(err2("not-an-object", at, "a claim is an object"));
+      return;
+    }
+    const claim = c;
+    unknownKeys(c, CLAIM_KEYS, at, out);
+    if (!SCALAR_TYPES.includes(claim.type)) {
+      out.push(err2("claim-type", atKey(at, "type"), "a claim presents a host field, which is a scalar"));
+    } else {
+      typeProblems(host, claim, at, false, out, true);
+    }
+    if (typeof claim.setting !== "string" || !settings.has(claim.setting)) {
+      out.push(err2("claim-setting", atKey(at, "setting"), `a claim names its field through a setting, and "${String(claim.setting)}" is not one of the manifest's settings`));
+    } else if (claimed.has(claim.setting)) {
+      out.push(err2("claim-duplicate", atKey(at, "setting"), `setting "${claim.setting}" is claimed twice for one kind`));
+    } else {
+      claimed.add(claim.setting);
+    }
+  });
+}
+function fieldListProblems(host, fields, path, topLevel, out) {
+  if (!Array.isArray(fields)) {
+    out.push(err2("not-a-list", path, "fields are a list"));
+    return;
+  }
+  const names = /* @__PURE__ */ new Set();
+  fields.forEach((f, i) => {
+    const at = atIndex(path, i);
+    if (!isObject(f)) {
+      out.push(err2("not-an-object", at, "a field is an object"));
+      return;
+    }
+    const field = f;
+    unknownKeys(f, FIELD_KEYS, at, out);
+    if (typeof field.name !== "string" || !NAME.test(field.name)) {
+      out.push(err2("field-name", atKey(at, "name"), "a field's name is an identifier: letters, digits and underscores, not starting with a digit"));
+    } else if (names.has(field.name)) {
+      out.push(err2("duplicate-field", atKey(at, "name"), `field "${field.name}" is declared twice`));
+    } else {
+      names.add(field.name);
+    }
+    typeProblems(host, field, at, true, out);
+    if (field.editorOnly !== void 0 && !topLevel) {
+      out.push(err2("editor-only-nested", atKey(at, "editorOnly"), "only a target's own fields can be editor-only, not a record's"));
+    }
+    for (const flag of ["required", "editorOnly"]) {
+      if (field[flag] !== void 0 && typeof field[flag] !== "boolean") {
+        out.push(err2("not-a-boolean", atKey(at, flag), `${flag} is true or false`));
+      }
+    }
+  });
+}
+function typeProblems(host, decl, path, named, out, claim = false) {
+  const typeAt = atKey(path, "type");
+  if (decl.type === "string") {
+    out.push(err2("string-type", typeAt, 'the text type is spelled "text"'));
+    return;
+  }
+  if (typeof decl.type !== "string" || !VALUE_TYPES.includes(decl.type)) {
+    out.push(err2("unknown-type", typeAt, `${JSON.stringify(decl.type)} is not a type; the types are ${VALUE_TYPES.join(", ")}`));
+    return;
+  }
+  const at = (k) => atKey(path, k);
+  let sound = true;
+  switch (decl.type) {
+    case "enum":
+    case "flags": {
+      const values = decl.values;
+      if (claim && values === void 0) break;
+      if (!Array.isArray(values) || values.length === 0) {
+        out.push(err2("values-empty", at("values"), `an ${decl.type === "enum" ? "enum" : "flags field"} lists its values`));
+        sound = false;
+        break;
+      }
+      const seen = /* @__PURE__ */ new Set();
+      values.forEach((v, i) => {
+        if (typeof v !== "string" || v.trim() === "") {
+          out.push(err2("value-empty", atIndex(at("values"), i), "a value has a name"));
+          sound = false;
+        } else if (seen.has(v)) {
+          out.push(err2("value-duplicate", atIndex(at("values"), i), `"${v}" is listed twice`));
+          sound = false;
+        } else seen.add(v);
+      });
+      break;
+    }
+    case "quality": {
+      if (claim && decl.stages === void 0) break;
+      for (const p of qualityDeclarationProblems(decl.stages)) {
+        out.push(err2(
+          `quality-${p.kind === "default-not-a-stage" ? "default" : p.kind}`,
+          at("stages"),
+          p.kind === "too-few-stages" ? "a quality's ladder has at least two stages" : p.kind === "empty-stage" ? `stage ${p.index + 1} has no name` : p.kind === "duplicate-stage" ? `stage "${p.stage}" is listed twice` : "the default is not a stage"
+        ));
+        sound = false;
+      }
+      break;
+    }
+    case "reference":
+      if (typeof decl.to !== "string" || !HOSTS[host].references.includes(decl.to)) {
+        out.push(err2("reference-to", at("to"), `a reference names the kind it points at, one of ${HOSTS[host].references.join(", ")}`));
+        sound = false;
+      }
+      break;
+    case "record":
+      if (!Array.isArray(decl.fields) || decl.fields.length === 0) {
+        out.push(err2("record-empty", at("fields"), "a record declares its fields"));
+        sound = false;
+      } else {
+        const before = out.length;
+        fieldListProblems(host, decl.fields, at("fields"), false, out);
+        if (out.slice(before).some((p) => p.severity === "error")) sound = false;
+      }
+      break;
+    case "map": {
+      const key = decl.key;
+      const keyOk = isObject(key) && (key["type"] === "text" || key["type"] === "reference" && typeof key["to"] === "string" && HOSTS[host].references.includes(key["to"]));
+      if (!keyOk) {
+        out.push(err2("map-key", at("key"), `a map is keyed by { type: "text" } or a reference, { type: "reference", to: "${HOSTS[host].references[0]}" }`));
+        sound = false;
+      }
+      if (!ofProblems(host, decl, at, out)) sound = false;
+      break;
+    }
+    case "list": {
+      if (decl.id !== void 0) {
+        const of = decl.of;
+        const idField = isObject(of) && of["type"] === "record" && Array.isArray(of["fields"]) ? of["fields"].find((f) => isObject(f) && f["name"] === decl.id) : void 0;
+        if (typeof decl.id !== "string" || idField === void 0 || idField.type !== "text") {
+          out.push(err2("list-id", at("id"), "a list with ids holds records, and its id names a text field of them"));
+          sound = false;
+        }
+      }
+      if (!ofProblems(host, decl, at, out)) sound = false;
+      break;
+    }
+  }
+  if (decl.min !== void 0 || decl.max !== void 0) {
+    const which = decl.max !== void 0 ? "max" : "min";
+    if (decl.type !== "number") {
+      out.push(err2("range", at(which), "a range applies to a number"));
+    } else if (typeof decl.min === "number" && typeof decl.max === "number" && decl.min > decl.max) {
+      out.push(err2("range", at("max"), `the range runs from ${decl.min} down to ${decl.max}`));
+      sound = false;
+    }
+  }
+  if (decl.renamedStages !== void 0) renamedStagesProblems(decl, at("renamedStages"), out);
+  if (decl.valueHelp !== void 0 && claim) {
+    if (!isObject(decl.valueHelp) || !["enum", "flags", "quality"].includes(decl.type)) {
+      out.push(err2("value-help", at("valueHelp"), "value help describes the values of an enum or flags field, or a quality's stages"));
+    }
+  } else if (decl.valueHelp !== void 0) {
+    const vocabulary = decl.type === "quality" ? decl.stages : decl.type === "enum" || decl.type === "flags" ? decl.values : void 0;
+    if (vocabulary === void 0 || !isObject(decl.valueHelp)) {
+      out.push(err2("value-help", at("valueHelp"), "value help describes the values of an enum or flags field, or a quality's stages"));
+    } else {
+      for (const k of Object.keys(decl.valueHelp)) {
+        if (!vocabulary.includes(k)) out.push(err2("value-help", atKey(at("valueHelp"), k), `"${k}" is not one of its values`));
+      }
+    }
+  }
+  if (named && decl.default !== void 0 && sound) {
+    const misfit = valueProblems(decl, decl.default).filter((p) => p.severity === "error");
+    if (misfit.length > 0) out.push(err2("default-misfit", at("default"), `the default does not fit: ${misfit[0].message}`));
+  }
+}
+function ofProblems(host, decl, at, out) {
+  if (!isObject(decl.of)) {
+    out.push(err2("missing-of", at("of"), `a ${decl.type} says what it holds, in "of"`));
+    return false;
+  }
+  const before = out.length;
+  unknownKeys(decl.of, BARE_KEYS, at("of"), out);
+  typeProblems(host, decl.of, at("of"), false, out);
+  return !out.slice(before).some((p) => p.severity === "error");
+}
+function renamedStagesProblems(decl, path, out) {
+  if (decl.type !== "quality" || !isObject(decl.renamedStages)) {
+    out.push(err2("renamed-stages", path, 'renamed stages belong to a quality, as { "old": "new" }'));
+    return;
+  }
+  const stages = decl.stages ?? [];
+  for (const [from, to] of Object.entries(decl.renamedStages)) {
+    if (stages.includes(from)) {
+      out.push(err2("renamed-stages", atKey(path, from), `"${from}" is still a stage, so it cannot also be an old name`));
+    } else if (typeof to !== "string" || !stages.includes(to)) {
+      out.push(err2("renamed-stages", atKey(path, from), `"${from}" is renamed to ${JSON.stringify(to)}, which is not a stage`));
+    }
+  }
+}
+function settingValues(manifest, chosen) {
+  const out = {};
+  for (const s of manifest.settings ?? []) {
+    const v = chosen !== void 0 && own(chosen, s.name) ? chosen[s.name] : void 0;
+    out[s.name] = typeof v === "string" && v !== "" ? v : s.default;
+  }
+  return out;
+}
+function resolvedClaims(manifest, host, chosen) {
+  const settings = settingValues(manifest, chosen);
+  const out = [];
+  for (const [kind, target] of Object.entries(manifest.targets[host] ?? {})) {
+    for (const claim of target.claims ?? []) {
+      const field = settings[claim.setting];
+      if (field !== void 0) out.push({ extension: manifest.id, host, kind, field, claim });
+    }
+  }
+  return out;
+}
+function claimClashes(claims) {
+  const out = [];
+  const first = /* @__PURE__ */ new Map();
+  for (const c of claims) {
+    const key = `${c.host}\0${c.kind}\0${c.field}`;
+    const prior = first.get(key);
+    if (prior === void 0) {
+      first.set(key, c);
+      continue;
+    }
+    if (prior.extension === c.extension) continue;
+    out.push(err2(
+      "claim-clash",
+      `${c.kind}.${c.field}`,
+      `extensions "${prior.extension}" and "${c.extension}" both claim the ${c.kind} field "${c.field}"`
+    ));
+  }
+  return out;
+}
+function targetOf(manifest, host, kind) {
+  const kinds = manifest?.targets[host];
+  return kinds !== void 0 && own(kinds, kind) ? kinds[kind] : void 0;
+}
+function effectiveClaim(claim, hostDecl) {
+  return {
+    ...claim,
+    ...claim.values === void 0 && hostDecl.values !== void 0 ? { values: hostDecl.values } : {},
+    ...claim.stages === void 0 && hostDecl.stages !== void 0 ? { stages: hostDecl.stages } : {},
+    ...claim.default === void 0 && hostDecl.default !== void 0 ? { default: hostDecl.default } : {}
+  };
+}
+
+// src/extensions/merge.ts
+var ATOMIC = { kind: "atomic" };
+var SET = { kind: "set" };
+var mapOf = (of) => ({ kind: "map", of });
+var keyedBy = (key, of, opts) => ({
+  kind: "keyed",
+  key,
+  of,
+  ...opts?.order !== void 0 ? { order: opts.order } : {},
+  ...opts?.renameWarning !== void 0 ? { renameWarning: opts.renameWarning } : {}
+});
+var objectOf = (fields, other) => ({ kind: "object", fields, ...other !== void 0 ? { other } : {} });
+function stableStringify(value) {
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return `[${value.map((v) => v === void 0 ? "null" : stableStringify(v)).join(",")}]`;
+  if (isObject(value)) {
+    const keys = Object.keys(value).filter((k) => value[k] !== void 0).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+var defaultEqual = (a, b) => stableStringify(a) === stableStringify(b);
+var asArr = (v) => Array.isArray(v) ? v : [];
+function mergeTree(strategy, base, ours, theirs, opts) {
+  const ctx = { eq: opts?.equal ?? defaultEqual, conflicts: [], warnings: [] };
+  const merged = mergeValue(strategy, base, ours, theirs, "", "", ctx);
+  return { merged, conflicts: ctx.conflicts, warnings: ctx.warnings };
+}
+function deletedKind(base, ours, theirs) {
+  if (base !== void 0 && (ours === void 0 || theirs === void 0)) return "delete-vs-edit";
+  return base === void 0 ? "added-both" : "both-changed";
+}
+function merge3(b, o, t, id, path, ctx) {
+  if (ctx.eq(o, t)) return o;
+  if (ctx.eq(b, o)) return t;
+  if (ctx.eq(b, t)) return o;
+  ctx.conflicts.push({ id, path, base: b, ours: o, theirs: t, kind: deletedKind(b, o, t) });
+  return o;
+}
+function hasShape(spec, v) {
+  switch (spec.kind) {
+    case "atomic":
+      return true;
+    case "set":
+    case "keyed":
+      return Array.isArray(v);
+    case "map":
+    case "object":
+      return isObject(v);
+  }
+}
+function mergeValue(spec, b, o, t, id, path, ctx) {
+  if (spec.kind === "atomic" || o === void 0 || t === void 0 || !hasShape(spec, o) || !hasShape(spec, t)) {
+    return merge3(b, o, t, id, path, ctx);
+  }
+  switch (spec.kind) {
+    case "set": {
+      const strings = (v) => new Set(asArr(v).filter((x) => typeof x === "string"));
+      const B = strings(b), O = strings(o), T = strings(t);
+      const out = /* @__PURE__ */ new Set();
+      for (const x of [...O, ...T]) if (O.has(x) && T.has(x) || !B.has(x)) out.add(x);
+      return [...out].sort();
+    }
+    case "map": {
+      const B = isObject(b) ? b : {}, O = o, T = t;
+      const out = {};
+      for (const k of Object.keys({ ...B, ...O, ...T }).sort()) {
+        const v = mergeValue(spec.of, B[k], O[k], T[k], id || k, `${path}.${k}`, ctx);
+        if (v !== void 0) out[k] = v;
+      }
+      return out;
+    }
+    case "object": {
+      const B = isObject(b) ? b : {}, O = o, T = t;
+      const out = {};
+      for (const k of Object.keys({ ...B, ...O, ...T }).sort()) {
+        const field = Object.prototype.hasOwnProperty.call(spec.fields, k) ? spec.fields[k] : spec.other ?? ATOMIC;
+        const v = mergeValue(field, B[k], O[k], T[k], id, path ? `${path}.${k}` : k, ctx);
+        if (v !== void 0) out[k] = v;
+      }
+      return out;
+    }
+    case "keyed":
+      return mergeKeyed(spec, asArr(b), o, t, path, ctx);
+  }
+}
+function mergeKeyed(spec, B, O, T, path, ctx) {
+  const keyOf = (v) => isObject(v) && typeof v[spec.key] === "string" ? v[spec.key] : void 0;
+  const keysOf = (arr) => arr.map(keyOf).filter((k) => k !== void 0);
+  const toMap = (arr) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const v of arr) {
+      const k = keyOf(v);
+      if (k !== void 0) m.set(k, v);
+    }
+    return m;
+  };
+  const Bm = toMap(B), Om = toMap(O), Tm = toMap(T);
+  const out = /* @__PURE__ */ new Map();
+  const here = (k) => `${path}[${k}]`;
+  for (const k of /* @__PURE__ */ new Set([...Bm.keys(), ...Om.keys(), ...Tm.keys()])) {
+    const b = Bm.get(k), o = Om.get(k), t = Tm.get(k);
+    const inB = Bm.has(k), inO = Om.has(k), inT = Tm.has(k);
+    if (inO && inT) {
+      if (!inB && !ctx.eq(o, t)) {
+        ctx.conflicts.push({ id: k, path: here(k), base: void 0, ours: o, theirs: t, kind: "added-both" });
+        out.set(k, o);
+      } else {
+        out.set(k, mergeValue(spec.of, b, o, t, k, here(k), ctx));
+      }
+    } else if (inO && !inT) {
+      if (inB && !ctx.eq(o, b)) {
+        ctx.conflicts.push({ id: k, path: here(k), base: b, ours: o, theirs: void 0, kind: "delete-vs-edit" });
+        out.set(k, o);
+      } else if (!inB) {
+        out.set(k, o);
+      }
+    } else if (!inO && inT) {
+      if (inB && !ctx.eq(t, b)) {
+        ctx.conflicts.push({ id: k, path: here(k), base: b, ours: void 0, theirs: t, kind: "delete-vs-edit" });
+      } else if (!inB) {
+        out.set(k, t);
+      }
+    }
+  }
+  if (spec.renameWarning !== void 0) {
+    for (const [k, v] of out) {
+      const b = Bm.get(k);
+      if (isObject(b) && isObject(v) && typeof b["gameId"] === "string" && typeof v["gameId"] === "string" && b["gameId"] !== v["gameId"]) {
+        ctx.warnings.push({ id: k, path: here(k), message: `${spec.renameWarning} ("${b["gameId"]}" -> "${v["gameId"]}")` });
+      }
+    }
+  }
+  if (spec.order !== "preserve") return [...out.keys()].sort().map((k) => out.get(k));
+  return preservedOrder(keysOf(B), keysOf(O), keysOf(T), out, path, ctx).map((k) => out.get(k));
+}
+function preservedOrder(B, O, T, survivors, path, ctx) {
+  const inAll = new Set(B.filter((k) => O.includes(k) && T.includes(k) && survivors.has(k)));
+  const common = (seq) => seq.filter((k) => inAll.has(k));
+  const same = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+  const oMoved = !same(common(O), common(B)), tMoved = !same(common(T), common(B));
+  if (oMoved && tMoved && !same(common(O), common(T))) {
+    ctx.conflicts.push({ id: "", path: `${path}:order`, base: common(B), ours: common(O), theirs: common(T), kind: "both-changed" });
+  }
+  const [skeleton, other] = tMoved && !oMoved ? [T, O] : [O, T];
+  const result = skeleton.filter((k) => survivors.has(k));
+  for (let i = 0; i < other.length; i++) {
+    const k = other[i];
+    if (!survivors.has(k) || result.includes(k)) continue;
+    let at = 0;
+    for (let j = i - 1; j >= 0; j--) {
+      const p = result.indexOf(other[j]);
+      if (p >= 0) {
+        at = p + 1;
+        break;
+      }
+    }
+    result.splice(at, 0, k);
+  }
+  for (const k of [...survivors.keys()].sort()) if (!result.includes(k)) result.push(k);
+  return result;
+}
+function strategyForType(decl) {
+  switch (decl.type) {
+    case "flags":
+      return SET;
+    case "record":
+      return strategyForFields(decl.fields ?? []);
+    case "map":
+      return mapOf(decl.of !== void 0 ? strategyForType(decl.of) : ATOMIC);
+    case "list":
+      return decl.id !== void 0 ? keyedBy(decl.id, decl.of !== void 0 ? strategyForType(decl.of) : ATOMIC, { order: "preserve" }) : ATOMIC;
+    default:
+      return ATOMIC;
+  }
+}
+function strategyForFields(fields) {
+  return objectOf(Object.fromEntries(fields.map((f) => [f.name, strategyForType(f)])));
+}
+function strategyForTarget(target) {
+  return strategyForFields(target.fields ?? []);
+}
+function extensionDataStrategy(manifest, host) {
+  const perNode = mapOf(ATOMIC);
+  const kinds = {};
+  for (const kind of Object.keys(manifest?.targets[host] ?? {})) {
+    const target = targetOf(manifest, host, kind);
+    if (target !== void 0) kinds[kind] = mapOf(strategyForTarget(target));
+  }
+  return objectOf({ entries: objectOf(kinds, perNode) });
+}
+var UNRESOLVED_KEY = "unresolved";
+function unresolvedOf(shard) {
+  if (!isObject(shard) || !Object.prototype.hasOwnProperty.call(shard, UNRESOLVED_KEY)) return void 0;
+  const mark = shard[UNRESOLVED_KEY];
+  return Array.isArray(mark) ? mark : [];
+}
+function withoutMark(shard) {
+  if (!isObject(shard) || !Object.prototype.hasOwnProperty.call(shard, UNRESOLVED_KEY)) return shard;
+  const { [UNRESOLVED_KEY]: _mark, ...rest } = shard;
+  return rest;
+}
+var entryOf = (c) => ({
+  path: c.path,
+  kind: c.kind,
+  ...c.base !== void 0 ? { base: c.base } : {},
+  ...c.ours !== void 0 ? { ours: c.ours } : {},
+  ...c.theirs !== void 0 ? { theirs: c.theirs } : {}
+});
+function markUnresolved(merged, conflicts, sides) {
+  const byPath = (mark) => new Map((mark ?? []).filter((e) => isObject(e) && typeof e.path === "string").map((e) => [e.path, e]));
+  const B = byPath(unresolvedOf(sides?.base)), O = byPath(unresolvedOf(sides?.ours)), T = byPath(unresolvedOf(sides?.theirs));
+  const out = /* @__PURE__ */ new Map();
+  for (const [p, e] of [...O, ...T]) {
+    const kept = O.has(p) && T.has(p) || !B.has(p);
+    if (kept && !out.has(p)) out.set(p, e);
+  }
+  for (const c of conflicts) out.set(c.path, entryOf(c));
+  const result = withoutMark(merged);
+  if (out.size === 0) return result;
+  return { ...result, [UNRESOLVED_KEY]: [...out.keys()].sort().map((p) => out.get(p)) };
+}
+function unresolvedProblems(shard) {
+  const mark = unresolvedOf(shard);
+  if (mark === void 0) return [];
+  const message = 'unresolved merge: this shard holds our side of a clash; resolve it, then remove the entry from "unresolved"';
+  if (mark.length === 0) return [{ severity: "error", code: "unresolved", path: UNRESOLVED_KEY, message }];
+  return mark.map((e) => ({
+    severity: "error",
+    code: "unresolved",
+    path: isObject(e) && typeof e.path === "string" ? e.path : UNRESOLVED_KEY,
+    message: `${message} (${isObject(e) && typeof e.kind === "string" ? e.kind : "clash"})`
+  }));
+}
+function mergeExtensionData(base, ours, theirs, opts) {
+  const strategy = extensionDataStrategy(opts.manifest, opts.host);
+  const { merged, conflicts, warnings } = mergeTree(
+    strategy,
+    withoutMark(base),
+    withoutMark(ours),
+    withoutMark(theirs),
+    opts.equal !== void 0 ? { equal: opts.equal } : void 0
+  );
+  return {
+    merged: markUnresolved(merged, conflicts, { base, ours, theirs }),
+    conflicts,
+    warnings
+  };
+}
+function orphanedEntries(data, exists) {
+  const out = [];
+  const entries = isObject(data) ? data["entries"] : void 0;
+  if (!isObject(entries)) return out;
+  for (const [kind, nodes] of Object.entries(entries)) {
+    if (!isObject(nodes)) continue;
+    for (const id of Object.keys(nodes)) {
+      if (!exists(kind, id)) {
+        out.push({
+          severity: "warning",
+          code: "orphan",
+          path: `entries.${kind}.${id}`,
+          message: `an entry for ${kind} "${id}", which no longer exists; it is kept, and not compiled`
+        });
+      }
+    }
+  }
+  return out;
+}
+
+export { ATOMIC, HOSTS, MANIFEST_FILE_SUFFIX, MANIFEST_SCHEMA, SCALAR_TYPES, SET, UNRESOLVED_KEY, VALUE_TYPES, atIndex, atKey, claimClashes, compileEntry, compiledTarget, defaultOf, effectiveClaim, entryProblems, extensionDataStrategy, keyedBy, manifestProblems, mapOf, markUnresolved, mergeExtensionData, mergeTree, objectOf, orphanedEntries, parseManifest, renameStages, resolvedClaims, settingValues, stableStringify, strategyForTarget, strategyForType, targetOf, unresolvedOf, unresolvedProblems, valueProblems, withoutMark };
+//# sourceMappingURL=extensions.js.map
+//# sourceMappingURL=extensions.js.map