@riebeckite/plugin-bases 0.0.27 → 0.0.29

package/dist/index.js

@@ -4,9 +4,403 @@ import {
   definePlugin
 } from "@riebeckite/core";
 
-// src/remark.ts
-import { visit } from "unist-util-visit";
-import { matter } from "vfile-matter";
+// src/page.ts
+import {
+  escapeHtml as escapeHtml3,
+  readContentSourceEntry
+} from "@riebeckite/core";
+
+// src/dependencies.ts
+function analyzeBasesDependencies(spec) {
+  const properties = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  let unknown = false;
+  const analyzeFormula = (name) => {
+    if (active.has(name)) {
+      unknown = true;
+      return;
+    }
+    const formula = spec.formulas[name];
+    if (!formula) {
+      unknown = true;
+      return;
+    }
+    active.add(name);
+    analyzeExpression(formula, properties, analyzeFormula, () => {
+      unknown = true;
+    });
+    active.delete(name);
+  };
+  analyzeCondition(spec.filter, properties, analyzeFormula, () => {
+    unknown = true;
+  });
+  for (const view of spec.views) {
+    analyzeCondition(view.filter, properties, analyzeFormula, () => {
+      unknown = true;
+    });
+    for (const property of [
+      ...view.columns,
+      ...view.sort?.map((item) => item.property) ?? [],
+      ...view.groupBy ? [view.groupBy.property] : [],
+      ...Object.keys(view.summaries ?? {})
+    ]) {
+      analyzeProperty(property, properties, analyzeFormula, () => {
+        unknown = true;
+      });
+    }
+  }
+  return {
+    type: "content-query",
+    properties: [...properties].sort(),
+    ...unknown ? { unknown: true } : {}
+  };
+}
+function analyzeCondition(condition, properties, formula, markUnknown) {
+  if (!condition) return;
+  switch (condition.kind) {
+    case "and":
+    case "or":
+      for (const child of condition.conditions)
+        analyzeCondition(child, properties, formula, markUnknown);
+      return;
+    case "not":
+      analyzeCondition(condition.condition, properties, formula, markUnknown);
+      return;
+    case "hasTag":
+      properties.add("file.tags");
+      return;
+    case "inFolder":
+      properties.add("file.folder");
+      return;
+    case "hasLink":
+      properties.add("file.links");
+      return;
+    case "compare":
+      properties.add(
+        condition.left.source === "builtin" ? condition.left.name : condition.left.key
+      );
+      return;
+    case "expression":
+      analyzeExpression(condition.expression, properties, formula, markUnknown);
+      return;
+  }
+}
+function analyzeProperty(property, properties, formula, markUnknown) {
+  if (property.startsWith("formula.")) {
+    formula(property.slice(8));
+    return;
+  }
+  if (property === "file" || property === "note") {
+    markUnknown();
+    return;
+  }
+  if (property.startsWith("note.")) properties.add(property.slice(5));
+  else if (property.startsWith("file.frontmatter."))
+    properties.add(property.slice(17));
+  else properties.add(property);
+}
+function analyzeExpression(expression, properties, formula, markUnknown) {
+  switch (expression.kind) {
+    case "literal":
+      return;
+    case "reference":
+      analyzeReference(expression.path, properties, formula, markUnknown);
+      return;
+    case "array":
+      for (const value of expression.values)
+        analyzeExpression(value, properties, formula, markUnknown);
+      return;
+    case "unary":
+      analyzeExpression(expression.value, properties, formula, markUnknown);
+      return;
+    case "binary":
+      analyzeExpression(expression.left, properties, formula, markUnknown);
+      analyzeExpression(expression.right, properties, formula, markUnknown);
+      return;
+    case "call":
+      if (isFilePredicate(expression.callee, "hasTag")) {
+        properties.add("file.tags");
+      } else if (isFilePredicate(expression.callee, "hasLink")) {
+        properties.add("file.links");
+      } else if (isFilePredicate(expression.callee, "inFolder")) {
+        properties.add("file.folder");
+      } else if (isFilePredicate(expression.callee, "hasProperty")) {
+        const property = literalString(expression.arguments[0]);
+        if (property === void 0) markUnknown();
+        else properties.add(property);
+      } else if (expression.callee.kind === "member")
+        analyzeExpression(
+          expression.callee.object,
+          properties,
+          formula,
+          markUnknown
+        );
+      else
+        analyzeExpression(expression.callee, properties, formula, markUnknown);
+      for (const argument of expression.arguments)
+        analyzeExpression(argument, properties, formula, markUnknown);
+      return;
+    case "member":
+      analyzeMember(expression, properties, formula, markUnknown);
+      return;
+    case "index":
+      analyzeExpression(expression.object, properties, formula, markUnknown);
+      analyzeExpression(expression.index, properties, formula, markUnknown);
+      markUnknown();
+      return;
+  }
+}
+function literalString(expression) {
+  return expression?.kind === "literal" && typeof expression.value === "string" ? expression.value : void 0;
+}
+function isFilePredicate(expression, predicate) {
+  const path = expressionPath(expression);
+  return path?.length === 2 && path[0] === "file" && path[1] === predicate;
+}
+function analyzeMember(expression, properties, formula, markUnknown) {
+  const path = expressionPath(expression);
+  if (path) {
+    analyzeReference(path, properties, formula, markUnknown);
+    return;
+  }
+  analyzeExpression(expression.object, properties, formula, markUnknown);
+}
+function expressionPath(expression) {
+  if (expression.kind === "reference") return expression.path;
+  if (expression.kind !== "member") return void 0;
+  const parent = expressionPath(expression.object);
+  return parent ? [...parent, expression.property] : void 0;
+}
+function analyzeReference(path, properties, formula, markUnknown) {
+  const [first, ...rest] = path;
+  if (!first || first === "value" || first === "index" || first === "acc")
+    return;
+  if (first === "formula") {
+    if (rest.length !== 1) markUnknown();
+    else formula(rest[0] ?? "");
+    return;
+  }
+  if (first === "file") {
+    if (rest.length === 0) markUnknown();
+    else if (rest[0] === "frontmatter") {
+      if (rest.length === 1) markUnknown();
+      else properties.add(rest.slice(1).join("."));
+    } else properties.add(`file.${rest.join(".")}`);
+    return;
+  }
+  if (first === "note") {
+    if (rest.length === 0) markUnknown();
+    else properties.add(rest.join("."));
+    return;
+  }
+  properties.add(path.join("."));
+}
+
+// src/expression.ts
+function parseBasesExpression(source) {
+  try {
+    const parser = new Parser(tokenize(source));
+    const value = parser.expression();
+    if (parser.current.kind !== "eof")
+      throw new Error(`Unexpected token \`${parser.current.text}\`.`);
+    return { ok: true, value };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  index = 0;
+  get current() {
+    return this.tokens[this.index] ?? { kind: "eof", text: "" };
+  }
+  expression(minimum = 0) {
+    let left = this.prefix();
+    while (true) {
+      if (this.current.text === ".") {
+        this.next();
+        left = {
+          kind: "member",
+          object: left,
+          property: this.expect("identifier").text
+        };
+        continue;
+      }
+      if (this.current.text === "[") {
+        this.next();
+        const index = this.expression();
+        this.expectText("]");
+        left = { kind: "index", object: left, index };
+        continue;
+      }
+      if (this.current.text === "(") {
+        left = { kind: "call", callee: left, arguments: this.arguments() };
+        continue;
+      }
+      const precedence = precedenceOf(this.current.text);
+      if (precedence < minimum) break;
+      const operator = this.current.text;
+      this.next();
+      left = {
+        kind: "binary",
+        operator,
+        left,
+        right: this.expression(precedence + 1)
+      };
+    }
+    return left;
+  }
+  prefix() {
+    if (this.current.text === "!" || this.current.text === "-") {
+      const operator = this.current.text;
+      this.next();
+      return { kind: "unary", operator, value: this.expression(8) };
+    }
+    if (this.current.text === "(") {
+      this.next();
+      const value = this.expression();
+      this.expectText(")");
+      return value;
+    }
+    if (this.current.text === "[") {
+      this.next();
+      const values = this.list("]");
+      return { kind: "array", values };
+    }
+    if (this.current.kind === "number") {
+      const value = Number(this.current.text);
+      this.next();
+      return { kind: "literal", value };
+    }
+    if (this.current.kind === "string") {
+      const value = this.current.text;
+      this.next();
+      return { kind: "literal", value };
+    }
+    if (this.current.kind === "identifier") {
+      const text = this.current.text;
+      this.next();
+      if (text === "true" || text === "false" || text === "null")
+        return {
+          kind: "literal",
+          value: text === "null" ? null : text === "true"
+        };
+      return { kind: "reference", path: [text] };
+    }
+    throw new Error(
+      `Expected an expression, found \`${this.current.text || "end of input"}\`.`
+    );
+  }
+  arguments() {
+    this.expectText("(");
+    return this.list(")");
+  }
+  list(end) {
+    const values = [];
+    if (this.current.text === end) {
+      this.next();
+      return values;
+    }
+    while (true) {
+      values.push(this.expression());
+      if (this.current.text === end) {
+        this.next();
+        return values;
+      }
+      this.expectText(",");
+    }
+  }
+  expect(kind) {
+    if (this.current.kind !== kind)
+      throw new Error(
+        `Expected ${kind}, found \`${this.current.text || "end of input"}\`.`
+      );
+    const value = this.current;
+    this.next();
+    return value;
+  }
+  expectText(text) {
+    if (this.current.text !== text)
+      throw new Error(
+        `Expected \`${text}\`, found \`${this.current.text || "end of input"}\`.`
+      );
+    this.next();
+  }
+  next() {
+    this.index += 1;
+  }
+};
+function precedenceOf(operator) {
+  return {
+    "||": 1,
+    "&&": 2,
+    "==": 3,
+    "!=": 3,
+    ">": 4,
+    "<": 4,
+    ">=": 4,
+    "<=": 4,
+    "+": 5,
+    "-": 5,
+    "*": 6,
+    "/": 6,
+    "%": 6
+  }[operator] ?? -1;
+}
+function tokenize(source) {
+  const tokens = [];
+  let index = 0;
+  while (index < source.length) {
+    const rest = source.slice(index);
+    const whitespace = rest.match(/^\s+/);
+    if (whitespace) {
+      index += whitespace[0].length;
+      continue;
+    }
+    const string = rest.match(/^(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)')/);
+    if (string) {
+      tokens.push({
+        kind: "string",
+        text: JSON.parse(
+          `"${(string[1] ?? string[2] ?? "").replace(/\\"/g, '\\"')}"`
+        )
+      });
+      index += string[0].length;
+      continue;
+    }
+    const number = rest.match(/^\d+(?:\.\d+)?/);
+    if (number) {
+      tokens.push({ kind: "number", text: number[0] });
+      index += number[0].length;
+      continue;
+    }
+    const identifier = rest.match(/^[A-Za-z_$][\w$]*/);
+    if (identifier) {
+      tokens.push({ kind: "identifier", text: identifier[0] });
+      index += identifier[0].length;
+      continue;
+    }
+    const operator = rest.match(/^(?:&&|\|\||==|!=|>=|<=|[+\-*/%><!])/);
+    if (operator) {
+      tokens.push({ kind: "operator", text: operator[0] });
+      index += operator[0].length;
+      continue;
+    }
+    if ("().,[]".includes(rest[0] ?? "")) {
+      tokens.push({ kind: "punctuation", text: rest[0] ?? "" });
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unexpected character \`${rest[0]}\`.`);
+  }
+  return [...tokens, { kind: "eof", text: "" }];
+}
 
 // src/parse.ts
 var DEFAULT_COLUMNS = ["file.name", "file.tags"];
@@ -22,13 +416,14 @@ var BUILTIN_ALIASES = {
   "file.permalink": "file.permalink",
   "file.url": "file.link",
   "file.tags": "file.tags",
-  "file.mtime": "date",
-  "file.ctime": "date",
-  "file.date": "date"
+  "file.ext": "file.ext",
+  "file.size": "file.size",
+  "file.mtime": "file.mtime",
+  "file.ctime": "file.ctime"
 };
 function parseBases(document) {
   if (document === null || document === void 0) {
-    return ok({ properties: {}, views: [] });
+    return ok({ properties: {}, formulas: {}, summaries: {}, views: [] });
   }
   if (typeof document !== "object" || Array.isArray(document)) {
     return fail("Base definition must be a YAML mapping.");
@@ -38,11 +433,17 @@ function parseBases(document) {
   if (filter.ok === false) return filter;
   const properties = parseProperties(root.properties);
   if (properties.ok === false) return properties;
+  const formulas = parseFormulas(root.formulas);
+  if (formulas.ok === false) return formulas;
+  const summaries = parseFormulas(root.summaries);
+  if (summaries.ok === false) return summaries;
   const views = parseViews(root.views, properties.value);
   if (views.ok === false) return views;
   return ok({
     ...filter.value === void 0 ? {} : { filter: filter.value },
     properties: properties.value,
+    formulas: formulas.value,
+    summaries: summaries.value,
     views: views.value
   });
 }
@@ -137,6 +538,9 @@ function toList(value) {
   return Array.isArray(value) ? value : [value];
 }
 function parseExpression(raw, path) {
+  const expression = parseBasesExpression(raw);
+  if (expression.ok)
+    return ok({ kind: "expression", expression: expression.value });
   let text = raw.trim();
   while (text.startsWith("(") && text.endsWith(")") && isBalanced(text.slice(1, -1))) {
     text = text.slice(1, -1).trim();
@@ -189,7 +593,6 @@ function parseValueRef(raw) {
   const lower = key.toLowerCase();
   const alias = BUILTIN_ALIASES[lower];
   if (alias !== void 0) {
-    if (alias === "date") return { source: "frontmatter", key: "date" };
     return { source: "builtin", name: alias };
   }
   if (lower.startsWith("note.")) {
@@ -253,6 +656,23 @@ function parseProperties(value) {
   }
   return ok(labels);
 }
+function parseFormulas(value) {
+  if (value === void 0 || value === null) return ok({});
+  if (typeof value !== "object" || Array.isArray(value))
+    return fail("`formulas` must be a YAML mapping.");
+  const formulas = {};
+  for (const [name, source] of Object.entries(
+    value
+  )) {
+    if (typeof source !== "string")
+      return fail(`formulas.${name} must be a string expression.`);
+    const expression = parseBasesExpression(source);
+    if (expression.ok === false)
+      return fail(`formulas.${name} is invalid (${expression.message}).`);
+    formulas[name] = expression.value;
+  }
+  return ok(formulas);
+}
 function propertyLabel(key, raw) {
   if (typeof raw === "string" && raw.trim() !== "") return raw;
   if (raw && typeof raw === "object" && !Array.isArray(raw)) {
@@ -286,6 +706,12 @@ function parseView(value, properties, path) {
   const columns = parseColumns(object, properties);
   const sort = parseSort(object.sort, `${path}.sort`);
   if (sort.ok === false) return sort;
+  const groupBy = parseGroupBy(object.groupBy, `${path}.groupBy`);
+  if (groupBy.ok === false) return groupBy;
+  const groupOrder = parseGroupOrder(object.groupOrder, `${path}.groupOrder`);
+  if (groupOrder.ok === false) return groupOrder;
+  const summaries = parseViewSummaries(object.summaries, `${path}.summaries`);
+  if (summaries.ok === false) return summaries;
   const limit = parseLimit(object.limit, `${path}.limit`);
   if (limit.ok === false) return limit;
   const name = typeof object.name === "string" && object.name.trim() !== "" ? object.name : void 0;
@@ -295,6 +721,9 @@ function parseView(value, properties, path) {
     columns,
     ...filter.value === void 0 ? {} : { filter: filter.value },
     ...sort.value === void 0 ? {} : { sort: sort.value },
+    ...groupBy.value === void 0 ? {} : { groupBy: groupBy.value },
+    ...groupOrder.value === void 0 ? {} : { groupOrder: groupOrder.value },
+    ...summaries.value === void 0 ? {} : { summaries: summaries.value },
     ...limit.value === void 0 ? {} : { limit: limit.value }
   });
 }
@@ -330,8 +759,8 @@ function parseSort(value, path) {
       if (text === "") continue;
       const descending = text.startsWith("-");
       sorts.push({
-        field: mapSortField(descending ? text.slice(1) : text),
-        order: descending ? "desc" : "asc"
+        property: descending ? text.slice(1) : text,
+        direction: descending ? "desc" : "asc"
       });
       continue;
     }
@@ -342,10 +771,13 @@ function parseSort(value, path) {
         return fail(`${path}[${index}] must name a \`property\` or \`field\`.`);
       }
       const direction = record.direction ?? record.order;
-      const descending = typeof direction === "string" && direction.trim().toLowerCase() === "desc";
+      const normalizedDirection = direction === void 0 ? "asc" : typeof direction === "string" ? direction.trim().toLowerCase() : "";
+      if (normalizedDirection !== "asc" && normalizedDirection !== "desc") {
+        return fail(`${path}[${index}].direction must be "ASC" or "DESC".`);
+      }
       sorts.push({
-        field: mapSortField(property),
-        order: descending ? "desc" : "asc"
+        property,
+        direction: normalizedDirection
       });
       continue;
     }
@@ -353,26 +785,51 @@ function parseSort(value, path) {
   }
   return ok(sorts.length === 0 ? void 0 : sorts);
 }
-function mapSortField(property) {
-  const ref = parseValueRef(property);
-  if (ref.source === "frontmatter") return ref.key;
-  switch (ref.name) {
-    case "file.name":
-    case "file.title":
-      return "title";
-    case "file.path":
-    case "file.slug":
-      return "slug";
-    case "file.link":
-    case "file.permalink":
-      return "permalink";
-    case "file.tags":
-      return "tags";
-    case "file.folder":
-      return "slug";
-    default:
-      return property;
+function parseGroupBy(value, path) {
+  if (value === void 0 || value === null) return ok(void 0);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fail(`${path} must be a mapping.`);
+  }
+  const record = value;
+  if (typeof record.property !== "string" || record.property.trim() === "") {
+    return fail(`${path}.property must be a non-empty property name.`);
+  }
+  const direction = String(record.direction ?? "asc").trim().toLowerCase();
+  if (direction !== "asc" && direction !== "desc") {
+    return fail(`${path}.direction must be "ASC" or "DESC".`);
+  }
+  return ok({ property: record.property, direction });
+}
+function parseGroupOrder(value, path) {
+  if (value === void 0) return ok(void 0);
+  if (!Array.isArray(value)) return fail(`${path} must be a list.`);
+  const values = [];
+  for (const item of value) {
+    if (item === null || typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+      values.push(item);
+    } else {
+      return fail(
+        `${path} values must be strings, numbers, booleans, or null.`
+      );
+    }
+  }
+  return ok(values);
+}
+function parseViewSummaries(value, path) {
+  if (value === void 0 || value === null) return ok(void 0);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fail(`${path} must be a mapping.`);
   }
+  const summaries = {};
+  for (const [property, summary] of Object.entries(
+    value
+  )) {
+    if (typeof summary !== "string" || summary.trim() === "") {
+      return fail(`${path}.${property} must name a summary.`);
+    }
+    summaries[property] = summary;
+  }
+  return ok(summaries);
 }
 function parseLimit(value, path) {
   if (value === void 0 || value === null) return ok(void 0);
@@ -382,97 +839,22 @@ function parseLimit(value, path) {
   return ok(Math.floor(value));
 }
 
-// src/placeholder.ts
-var BASES_ATTRIBUTE = "data-rr-bases";
-function encodeBasesPayload(payload) {
-  return encodeURIComponent(JSON.stringify(payload));
-}
-function decodeBasesPayload(encoded) {
-  try {
-    const parsed = JSON.parse(decodeURIComponent(encoded));
-    if (!parsed || typeof parsed !== "object") return null;
-    const candidate = parsed;
-    if (typeof candidate.source !== "string" || !candidate.spec) return null;
-    return candidate;
-  } catch {
-    return null;
-  }
-}
-function createBasesPlaceholder(payload) {
-  return `<div ${BASES_ATTRIBUTE}="${encodeBasesPayload(payload)}"></div>`;
-}
-function createBasesPlaceholderPattern() {
-  return new RegExp(
-    `<div\\b[^>]*\\b${BASES_ATTRIBUTE}="([^"]*)"[^>]*>\\s*</div>`,
-    "g"
-  );
-}
-
-// src/remark.ts
-function remarkBases(options = {}) {
-  const language = options.language ?? "base";
-  return (tree, file) => {
-    visit(tree, "code", (node, index, parent) => {
-      if (node.lang !== language) return;
-      if (!parent || index === void 0) return;
-      const parsed = parseYaml(node.value);
-      if (parsed.ok === false) {
-        reportDiagnostic(file, parsed.message, node);
-        return;
-      }
-      const spec = parseBases(parsed.value);
-      if (spec.ok === false) {
-        reportDiagnostic(file, spec.message, node);
-        return;
-      }
-      const html = {
-        type: "html",
-        value: createBasesPlaceholder({ spec: spec.value, source: node.value })
-      };
-      parent.children.splice(index, 1, html);
-    });
-  };
-}
-function parseYaml(source) {
-  try {
-    const document = `---
-${source}
----
-`;
-    const file = {
-      value: document,
-      data: {},
-      toString: () => document
-    };
-    matter(file);
-    return { ok: true, value: file.data.matter };
-  } catch (error) {
-    return {
-      ok: false,
-      message: `Base block is not valid YAML (${formatError(error)}).`
-    };
-  }
-}
-function reportDiagnostic(file, message, node) {
-  const reporter = file?.message;
-  if (typeof reporter !== "function") return;
-  const diagnostic2 = reporter.call(file, message, node);
-  if (diagnostic2 && typeof diagnostic2 === "object") {
-    Object.assign(diagnostic2, { source: "@riebeckite/plugin-bases" });
-  }
-}
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/render.ts
 import {
-  escapeHtml,
-  escapeHtmlAttribute,
-  queryContentEntries
+  escapeHtml as escapeHtml2,
+  escapeHtmlAttribute
 } from "@riebeckite/core";
 
 // src/evaluate.ts
+var MAX_EVALUATION_STEPS = 1e4;
+var MAX_EVALUATION_DEPTH = 128;
+var EVALUATION_BUDGET = /* @__PURE__ */ Symbol("bases-evaluation-budget");
+var BasesEvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BasesEvaluationError";
+  }
+};
 function matchesCondition(condition, entry) {
   switch (condition.kind) {
     case "and":
@@ -497,21 +879,607 @@ function matchesCondition(condition, entry) {
         condition.operator,
         condition.right
       );
+    case "expression":
+      return Boolean(evaluateBasesExpression(condition.expression, entry));
     default:
       return false;
   }
 }
+function evaluateBasesExpression(expression, entry, formulas = {}, scope = {}, active = /* @__PURE__ */ new Set()) {
+  const budget = evaluationBudget(scope);
+  if (budget.remaining <= 0) {
+    throw new BasesEvaluationError(
+      `Formula evaluation exceeded ${MAX_EVALUATION_STEPS} steps.`
+    );
+  }
+  if (budget.depth >= MAX_EVALUATION_DEPTH) {
+    throw new BasesEvaluationError(
+      `Formula evaluation exceeded ${MAX_EVALUATION_DEPTH} nested expressions.`
+    );
+  }
+  budget.remaining -= 1;
+  budget.depth += 1;
+  try {
+    switch (expression.kind) {
+      case "literal":
+        return expression.value;
+      case "array":
+        return expression.values.map(
+          (value) => evaluateBasesExpression(value, entry, formulas, scope, active)
+        );
+      case "reference":
+        return resolvePath(expression.path, entry, formulas, scope, active);
+      case "member":
+        return readMember(
+          evaluateBasesExpression(
+            expression.object,
+            entry,
+            formulas,
+            scope,
+            active
+          ),
+          expression.property
+        );
+      case "index":
+        return readMember(
+          evaluateBasesExpression(
+            expression.object,
+            entry,
+            formulas,
+            scope,
+            active
+          ),
+          String(
+            evaluateBasesExpression(
+              expression.index,
+              entry,
+              formulas,
+              scope,
+              active
+            )
+          )
+        );
+      case "unary": {
+        const value = evaluateBasesExpression(
+          expression.value,
+          entry,
+          formulas,
+          scope,
+          active
+        );
+        return expression.operator === "!" ? !value : typeof value === "number" ? -value : Number.NaN;
+      }
+      case "binary":
+        return evaluateBinary(expression, entry, formulas, scope, active);
+      case "call":
+        return evaluateCall(expression, entry, formulas, scope, active);
+    }
+  } finally {
+    budget.depth -= 1;
+  }
+}
+function evaluationBudget(scope) {
+  const values = scope;
+  const existing = values[EVALUATION_BUDGET];
+  if (existing && typeof existing === "object") {
+    return existing;
+  }
+  const budget = {
+    remaining: MAX_EVALUATION_STEPS,
+    depth: 0
+  };
+  values[EVALUATION_BUDGET] = budget;
+  return budget;
+}
+function resolvePath(path, entry, formulas, scope, active) {
+  const [first] = path;
+  if (!first) return void 0;
+  if (Object.hasOwn(scope, first)) return scope[first];
+  if (first === "file") return fileValue(entry);
+  if (first === "note") return entry.frontmatter;
+  if (first === "formula")
+    return new Proxy(
+      {},
+      {
+        get: (_target, property) => resolveFormula(String(property), entry, formulas, scope, active),
+        getOwnPropertyDescriptor: (_target, property) => ({
+          configurable: true,
+          enumerable: true,
+          value: resolveFormula(
+            String(property),
+            entry,
+            formulas,
+            scope,
+            active
+          )
+        })
+      }
+    );
+  return Object.hasOwn(entry.frontmatter, first) ? entry.frontmatter[first] : void 0;
+}
+function resolveFormula(name, entry, formulas, scope, active) {
+  const expression = formulas[name];
+  if (!expression || active.has(name)) return void 0;
+  return evaluateBasesExpression(
+    expression,
+    entry,
+    formulas,
+    scope,
+    /* @__PURE__ */ new Set([...active, name])
+  );
+}
+function fileValue(entry) {
+  const path = `${entry.slug}.md`;
+  const name = path.split("/").at(-1) ?? path;
+  return {
+    name,
+    basename: name.replace(/\.md$/i, ""),
+    path,
+    folder: folderOf(entry.slug),
+    ext: "md",
+    size: entry.file?.size,
+    ctime: entry.file?.ctime,
+    mtime: entry.file?.mtime,
+    tags: entry.tags,
+    links: entry.links.map((link) => link.slug ?? link.raw),
+    properties: entry.frontmatter,
+    link: entry.permalink
+  };
+}
+function readMember(value, property) {
+  if (value === null || value === void 0) return void 0;
+  if (property === "__proto__" || property === "prototype" || property === "constructor")
+    return void 0;
+  if (value instanceof Date) return dateMember(value, property);
+  if (property === "length" && (typeof value === "string" || Array.isArray(value)))
+    return value.length;
+  if (typeof value === "object" && Object.hasOwn(value, property))
+    return value[property];
+  return void 0;
+}
+function evaluateBinary(expression, entry, formulas, scope, active) {
+  const left = evaluateBasesExpression(
+    expression.left,
+    entry,
+    formulas,
+    scope,
+    active
+  );
+  if (expression.operator === "&&")
+    return left && evaluateBasesExpression(expression.right, entry, formulas, scope, active);
+  if (expression.operator === "||")
+    return left || evaluateBasesExpression(expression.right, entry, formulas, scope, active);
+  const right = evaluateBasesExpression(
+    expression.right,
+    entry,
+    formulas,
+    scope,
+    active
+  );
+  if (["==", "!=", ">", "<", ">=", "<="].includes(expression.operator))
+    return compare(
+      left,
+      expression.operator,
+      right
+    );
+  const dateArithmetic = evaluateDateArithmetic(
+    left,
+    expression.operator,
+    right
+  );
+  if (dateArithmetic !== void 0) return dateArithmetic;
+  if (expression.operator === "+")
+    return typeof left === "string" || typeof right === "string" ? `${left ?? ""}${right ?? ""}` : Number(left) + Number(right);
+  if (expression.operator === "-") return Number(left) - Number(right);
+  if (expression.operator === "*") return Number(left) * Number(right);
+  if (expression.operator === "/")
+    return Number(right) === 0 ? Number.NaN : Number(left) / Number(right);
+  return Number(left) % Number(right);
+}
+function evaluateDateArithmetic(left, operator, right) {
+  if (!(left instanceof Date) || Number.isNaN(left.getTime())) return void 0;
+  if (operator === "-" && right instanceof Date) {
+    return left.getTime() - right.getTime();
+  }
+  if (typeof right !== "string" || operator !== "+" && operator !== "-") {
+    return void 0;
+  }
+  const duration2 = parseDuration(right);
+  if (!duration2) return void 0;
+  return offsetDate(left, duration2, operator === "+" ? 1 : -1);
+}
+function parseDuration(value) {
+  const match = /^\s*(-?\d+(?:\.\d+)?)\s*(y|year|years|M|month|months|d|day|days|w|week|weeks|h|hour|hours|m|minute|minutes|s|second|seconds)\s*$/.exec(
+    value
+  );
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  return Number.isFinite(amount) && unit ? { amount, unit } : void 0;
+}
+function offsetDate(source, duration2, direction) {
+  const date = new Date(source.getTime());
+  const amount = duration2.amount * direction;
+  switch (duration2.unit) {
+    case "y":
+    case "year":
+    case "years":
+      date.setUTCFullYear(date.getUTCFullYear() + amount);
+      return date;
+    case "M":
+    case "month":
+    case "months":
+      date.setUTCMonth(date.getUTCMonth() + amount);
+      return date;
+    case "w":
+    case "week":
+    case "weeks":
+      date.setTime(date.getTime() + amount * 7 * 864e5);
+      return date;
+    case "d":
+    case "day":
+    case "days":
+      date.setTime(date.getTime() + amount * 864e5);
+      return date;
+    case "h":
+    case "hour":
+    case "hours":
+      date.setTime(date.getTime() + amount * 36e5);
+      return date;
+    case "m":
+    case "minute":
+    case "minutes":
+      date.setTime(date.getTime() + amount * 6e4);
+      return date;
+    default:
+      date.setTime(date.getTime() + amount * 1e3);
+      return date;
+  }
+}
+function evaluateCall(expression, entry, formulas, scope, active) {
+  if (expression.callee.kind === "member") {
+    const target2 = evaluateBasesExpression(
+      expression.callee.object,
+      entry,
+      formulas,
+      scope,
+      active
+    );
+    const higherOrder = evaluateHigherOrderCall(
+      target2,
+      expression.callee.property,
+      expression.arguments,
+      entry,
+      formulas,
+      scope,
+      active
+    );
+    if (higherOrder.handled) return higherOrder.value;
+  }
+  const args = expression.arguments.map(
+    (argument) => evaluateBasesExpression(argument, entry, formulas, scope, active)
+  );
+  if (expression.callee.kind === "reference")
+    return globalCall(expression.callee.path[0] ?? "", args);
+  if (expression.callee.kind !== "member") return void 0;
+  const target = evaluateBasesExpression(
+    expression.callee.object,
+    entry,
+    formulas,
+    scope,
+    active
+  );
+  return memberCall(target, expression.callee.property, args);
+}
+function globalCall(name, args) {
+  if (name === "if") return args[0] ? args[1] : args[2] ?? null;
+  if (name === "list")
+    return args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  if (name === "number") return Number(args[0]);
+  if (name === "length")
+    return Array.isArray(args[0]) || typeof args[0] === "string" ? args[0].length : 0;
+  if (name === "min") return Math.min(...args.map(Number));
+  if (name === "max") return Math.max(...args.map(Number));
+  if (name === "date") return parseDate(args[0]);
+  if (name === "duration") return duration(args[0], args[1]);
+  if (name === "isTruthy") return Boolean(args[0]);
+  if (name === "isType") return isType(args[0], args[1]);
+  if (name === "toString") return stringValue(args[0]);
+  if (name === "escapeHTML") return escapeHtml(String(args[0] ?? ""));
+  return void 0;
+}
+function memberCall(target, name, args) {
+  if (name === "hasTag" && target && typeof target === "object" && "tags" in target)
+    return args.some(
+      (value) => hasTag(target.tags, String(value))
+    );
+  if (name === "hasLink" && target && typeof target === "object" && "links" in target)
+    return hasLink(
+      target.links,
+      String(args[0])
+    );
+  if (name === "inFolder" && target && typeof target === "object" && "folder" in target)
+    return inFolder(
+      String(target.folder),
+      String(args[0])
+    );
+  if (name === "hasProperty" && target && typeof target === "object" && "properties" in target) {
+    const properties = target.properties;
+    return properties !== null && typeof properties === "object" && Object.hasOwn(properties, String(args[0] ?? ""));
+  }
+  if (target instanceof Date) {
+    return dateMethod(target, name, args) ?? objectMethod(target, name);
+  }
+  if (typeof target === "string") return stringMethod(target, name, args);
+  if (Array.isArray(target)) {
+    return arrayMethod(target, name, args) ?? objectMethod(target, name);
+  }
+  if (typeof target === "number") return numberMethod(target, name, args);
+  if (target !== null && typeof target === "object") {
+    return objectMethod(target, name);
+  }
+  return void 0;
+}
+function dateMethod(date, name, args) {
+  if (name === "format") return formatDate(date, String(args[0] ?? ""));
+  if (name === "date") return startOfUtcDate(date);
+  if (name === "time") return date.getTime();
+  return void 0;
+}
+function stringMethod(target, name, args) {
+  if (name === "lower") return target.toLowerCase();
+  if (name === "upper") return target.toUpperCase();
+  if (name === "contains") return target.includes(String(args[0]));
+  if (name === "containsAll")
+    return args.every((value) => target.includes(String(value)));
+  if (name === "containsAny")
+    return args.some((value) => target.includes(String(value)));
+  if (name === "startsWith") return target.startsWith(String(args[0]));
+  if (name === "endsWith") return target.endsWith(String(args[0]));
+  if (name === "trim") return target.trim();
+  if (name === "reverse") return [...target].reverse().join("");
+  if (name === "repeat")
+    return target.repeat(Math.max(0, Number(args[0] ?? 0)));
+  if (name === "slice")
+    return target.slice(
+      Number(args[0] ?? 0),
+      args[1] === void 0 ? void 0 : Number(args[1])
+    );
+  if (name === "isEmpty") return target.length === 0;
+  if (name === "split") return target.split(String(args[0]));
+  if (name === "replace")
+    return target.split(String(args[0])).join(String(args[1] ?? ""));
+  if (name === "title") return titleCase(target);
+  return void 0;
+}
+function arrayMethod(target, name, args) {
+  if (name === "contains")
+    return target.some((value) => scalarEquals(value, args[0]));
+  if (name === "join") return target.join(String(args[0] ?? ","));
+  if (name === "containsAll")
+    return args.every(
+      (value) => target.some((item) => scalarEquals(item, value))
+    );
+  if (name === "containsAny")
+    return args.some(
+      (value) => target.some((item) => scalarEquals(item, value))
+    );
+  if (name === "unique") return [...new Set(target)];
+  if (name === "flat") return target.flat();
+  if (name === "sort") return [...target].sort();
+  if (name === "reverse") return [...target].reverse();
+  if (name === "slice")
+    return target.slice(
+      Number(args[0] ?? 0),
+      args[1] === void 0 ? void 0 : Number(args[1])
+    );
+  if (name === "isEmpty") return target.length === 0;
+  if (name === "mean") return mean(target);
+  if (name === "sum")
+    return target.reduce((total, value) => total + Number(value), 0);
+  if (name === "min") return Math.min(...target.map(Number));
+  if (name === "max") return Math.max(...target.map(Number));
+  return void 0;
+}
+function numberMethod(target, name, args) {
+  if (name === "round") {
+    const digits = Number(args[0] ?? 0);
+    const factor = 10 ** digits;
+    return Math.round(target * factor) / factor;
+  }
+  if (name === "floor") return Math.floor(target);
+  if (name === "ceil") return Math.ceil(target);
+  if (name === "abs") return Math.abs(target);
+  if (name === "toFixed") return target.toFixed(Number(args[0] ?? 0));
+  return void 0;
+}
+function objectMethod(target, name) {
+  if (name === "isEmpty") return Object.keys(target).length === 0;
+  if (name === "keys") return Object.keys(target);
+  if (name === "values") return Object.values(target);
+  return void 0;
+}
+function dateMember(date, property) {
+  if (Number.isNaN(date.getTime())) return void 0;
+  if (property === "year") return date.getUTCFullYear();
+  if (property === "month") return date.getUTCMonth() + 1;
+  if (property === "day") return date.getUTCDate();
+  if (property === "hour") return date.getUTCHours();
+  if (property === "minute") return date.getUTCMinutes();
+  if (property === "second") return date.getUTCSeconds();
+  if (property === "millisecond") return date.getUTCMilliseconds();
+  if (property === "time") return date.getTime();
+  if (property === "date") return startOfUtcDate(date);
+  return void 0;
+}
+function parseDate(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  if (typeof value === "number" && Number.isFinite(value))
+    return new Date(value);
+  if (typeof value !== "string") return void 0;
+  const source = value.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(source)) {
+    const [year, month, day] = source.split("-").map(Number);
+    const date2 = new Date(Date.UTC(year, (month ?? 1) - 1, day));
+    return date2.getUTCFullYear() === year && date2.getUTCMonth() === (month ?? 1) - 1 && date2.getUTCDate() === day ? date2 : void 0;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z$/.test(source))
+    return void 0;
+  const date = new Date(source);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function duration(amount, unit) {
+  if (typeof amount !== "number" || !Number.isFinite(amount)) return void 0;
+  const normalized = String(unit ?? "").trim().toLowerCase();
+  const units = {
+    year: "years",
+    years: "years",
+    month: "months",
+    months: "months",
+    week: "weeks",
+    weeks: "weeks",
+    day: "days",
+    days: "days",
+    hour: "hours",
+    hours: "hours",
+    minute: "minutes",
+    minutes: "minutes",
+    second: "seconds",
+    seconds: "seconds"
+  };
+  const suffix = units[normalized];
+  return suffix ? `${amount} ${suffix}` : void 0;
+}
+function isType(value, expected) {
+  const type = String(expected ?? "").toLowerCase();
+  if (type === "null") return value === null;
+  if (type === "array" || type === "list") return Array.isArray(value);
+  if (type === "date")
+    return value instanceof Date && !Number.isNaN(value.getTime());
+  if (type === "object")
+    return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+  return typeof value === type;
+}
+function stringValue(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(stringValue).join(", ");
+  return value === null || value === void 0 ? "" : String(value);
+}
+function escapeHtml(value) {
+  return value.replace(
+    /[&<>"']/g,
+    (character) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    })[character] ?? character
+  );
+}
+function startOfUtcDate(value) {
+  return new Date(
+    Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate())
+  );
+}
+function formatDate(value, pattern) {
+  if (Number.isNaN(value.getTime())) return void 0;
+  const fields = {
+    yyyy: String(value.getUTCFullYear()).padStart(4, "0"),
+    MM: String(value.getUTCMonth() + 1).padStart(2, "0"),
+    dd: String(value.getUTCDate()).padStart(2, "0"),
+    HH: String(value.getUTCHours()).padStart(2, "0"),
+    mm: String(value.getUTCMinutes()).padStart(2, "0"),
+    ss: String(value.getUTCSeconds()).padStart(2, "0")
+  };
+  return pattern.replace(
+    /yyyy|MM|dd|HH|mm|ss/g,
+    (token) => fields[token] ?? token
+  );
+}
+function titleCase(value) {
+  return value.replace(
+    /(^|[\s_-])(\p{L})/gu,
+    (_match, prefix, letter) => `${prefix}${letter.toLocaleUpperCase()}`
+  );
+}
+function mean(values) {
+  const numbers = values.map(Number).filter(Number.isFinite);
+  return numbers.length === 0 ? Number.NaN : numbers.reduce((total, value) => total + value, 0) / numbers.length;
+}
+function evaluateHigherOrderCall(target, name, arguments_, entry, formulas, scope, active) {
+  if (!Array.isArray(target) || !["map", "filter", "reduce"].includes(name)) {
+    return { handled: false, value: void 0 };
+  }
+  const expression = arguments_[0];
+  if (!expression) return { handled: true, value: void 0 };
+  if (name === "map") {
+    return {
+      handled: true,
+      value: target.map(
+        (value, index) => evaluateBasesExpression(
+          expression,
+          entry,
+          formulas,
+          { ...scope, value, index },
+          active
+        )
+      )
+    };
+  }
+  if (name === "filter") {
+    return {
+      handled: true,
+      value: target.filter(
+        (value, index) => Boolean(
+          evaluateBasesExpression(
+            expression,
+            entry,
+            formulas,
+            { ...scope, value, index },
+            active
+          )
+        )
+      )
+    };
+  }
+  let accumulator = arguments_[1] ? evaluateBasesExpression(arguments_[1], entry, formulas, scope, active) : target[0];
+  const start = arguments_[1] ? 0 : 1;
+  for (let index = start; index < target.length; index += 1) {
+    accumulator = evaluateBasesExpression(
+      expression,
+      entry,
+      formulas,
+      {
+        ...scope,
+        acc: accumulator,
+        value: target[index],
+        index
+      },
+      active
+    );
+  }
+  return { handled: true, value: accumulator };
+}
 function resolveValueRef(reference, entry) {
   if (reference.source === "frontmatter") {
-    return entry.frontmatter[reference.key];
+    return readFrontmatter(entry.frontmatter, reference.key);
   }
   return resolveBuiltin(reference.name, entry);
 }
+function readFrontmatter(frontmatter, key) {
+  if (Object.hasOwn(frontmatter, key)) return frontmatter[key];
+  return key.split(".").reduce((value, part) => {
+    if (!value || typeof value !== "object") return void 0;
+    return Object.hasOwn(value, part) ? value[part] : void 0;
+  }, frontmatter);
+}
 function resolveBuiltin(name, entry) {
   switch (name) {
     case "file.name":
-      return entry.title;
+      return `${entry.slug.split("/").at(-1) ?? entry.slug}.md`;
     case "file.path":
+      return `${entry.slug}.md`;
     case "file.slug":
       return entry.slug;
     case "file.folder":
@@ -523,6 +1491,14 @@ function resolveBuiltin(name, entry) {
       return entry.permalink;
     case "file.tags":
       return entry.tags;
+    case "file.ext":
+      return "md";
+    case "file.size":
+      return entry.file?.size;
+    case "file.mtime":
+      return entry.file?.mtime;
+    case "file.ctime":
+      return entry.file?.ctime;
     default:
       return void 0;
   }
@@ -640,6 +1616,158 @@ function toComparableNumber(value) {
   return null;
 }
 
+// src/transform.ts
+function resolveBasesProperty(entry, property, spec) {
+  if (property.toLowerCase().startsWith("formula.")) {
+    const expression = spec.formulas[property.slice("formula.".length)];
+    return expression ? evaluateBasesExpression(expression, entry, spec.formulas) : void 0;
+  }
+  return resolveValueRef(parseValueRef(property), entry);
+}
+function sortBasesEntries(entries, view, spec) {
+  const indexed = entries.map((entry, index) => ({ entry, index }));
+  return indexed.sort((left, right) => {
+    for (const sort of view.sort ?? []) {
+      const result = compareValues(
+        resolveBasesProperty(left.entry, sort.property, spec),
+        resolveBasesProperty(right.entry, sort.property, spec)
+      );
+      if (result !== 0) return sort.direction === "desc" ? -result : result;
+    }
+    return left.index - right.index;
+  }).map(({ entry }) => entry);
+}
+function groupBasesEntries(entries, view, spec) {
+  if (!view.groupBy) return [{ key: null, entries }];
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const value = resolveBasesProperty(entry, view.groupBy.property, spec);
+    for (const key of groupKeys(value)) {
+      const identity = groupIdentity(key);
+      const group = groups.get(identity);
+      if (group) group.entries.push(entry);
+      else groups.set(identity, { key, entries: [entry] });
+    }
+  }
+  const all = [...groups.values()];
+  const ordered = view.groupOrder ? view.groupOrder.map(
+    (key) => groups.get(groupIdentity(key)) ?? {
+      key,
+      entries: []
+    }
+  ) : all.sort((left, right) => {
+    const result = compareValues(left.key, right.key);
+    return view.groupBy?.direction === "desc" ? -result : result;
+  });
+  return ordered.map((group) => ({ key: group.key, entries: group.entries }));
+}
+function summarizeBasesValues(values, name, spec) {
+  const custom = spec.summaries[name];
+  if (custom) {
+    const entry = emptyEntry;
+    return evaluateBasesExpression(custom, entry, spec.formulas, { values });
+  }
+  const normalized = name.trim().toLowerCase();
+  const present = values.filter((value) => !isEmpty(value));
+  const numbers = present.filter(isFiniteNumber);
+  const dates = present.map(toDate).filter((value) => value !== null);
+  if (normalized === "empty") return values.length - present.length;
+  if (normalized === "filled") return present.length;
+  if (normalized === "unique") return new Set(present.map(valueIdentity)).size;
+  if (normalized === "checked")
+    return present.filter((value) => value === true).length;
+  if (normalized === "unchecked")
+    return present.filter((value) => value === false).length;
+  if (normalized === "earliest")
+    return dates.length ? new Date(Math.min(...dates.map((value) => value.getTime()))) : null;
+  if (normalized === "latest")
+    return dates.length ? new Date(Math.max(...dates.map((value) => value.getTime()))) : null;
+  if (normalized === "range" && dates.length)
+    return Math.max(...dates.map((value) => value.getTime())) - Math.min(...dates.map((value) => value.getTime()));
+  if (!numbers.length) return null;
+  if (normalized === "sum")
+    return numbers.reduce((sum, value) => sum + value, 0);
+  if (normalized === "average")
+    return numbers.reduce((sum, value) => sum + value, 0) / numbers.length;
+  if (normalized === "min") return Math.min(...numbers);
+  if (normalized === "max") return Math.max(...numbers);
+  if (normalized === "range")
+    return Math.max(...numbers) - Math.min(...numbers);
+  if (normalized === "median") {
+    const ordered = [...numbers].sort((left, right) => left - right);
+    const middle = Math.floor(ordered.length / 2);
+    return ordered.length % 2 ? ordered[middle] : ((ordered[middle - 1] ?? 0) + (ordered[middle] ?? 0)) / 2;
+  }
+  if (normalized === "stddev") {
+    const mean2 = numbers.reduce((sum, value) => sum + value, 0) / numbers.length;
+    return Math.sqrt(
+      numbers.reduce((sum, value) => sum + (value - mean2) ** 2, 0) / numbers.length
+    );
+  }
+  return null;
+}
+function groupKeys(value) {
+  if (Array.isArray(value))
+    return value.length ? value.flatMap(groupKeys) : [null];
+  return isGroupKey(value) ? [value] : [null];
+}
+function isGroupKey(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date && Number.isFinite(value.getTime());
+}
+function compareValues(left, right) {
+  const leftEmpty = isEmpty(left);
+  const rightEmpty = isEmpty(right);
+  if (leftEmpty && rightEmpty) return 0;
+  if (leftEmpty) return 1;
+  if (rightEmpty) return -1;
+  const leftDate = toDate(left);
+  const rightDate = toDate(right);
+  if (leftDate && rightDate) return leftDate.getTime() - rightDate.getTime();
+  if (typeof left === "number" && typeof right === "number")
+    return left - right;
+  if (typeof left === "boolean" && typeof right === "boolean")
+    return Number(left) - Number(right);
+  const typeOrder = valueTypeOrder(left) - valueTypeOrder(right);
+  if (typeOrder !== 0) return typeOrder;
+  return String(left).localeCompare(String(right), "en");
+}
+function valueTypeOrder(value) {
+  if (typeof value === "number") return 0;
+  if (toDate(value)) return 1;
+  if (typeof value === "boolean") return 2;
+  return 3;
+}
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function toDate(value) {
+  if (value instanceof Date && Number.isFinite(value.getTime())) return value;
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}(?:T|\s|$)/.test(value.trim()))
+    return null;
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? null : new Date(time);
+}
+function valueIdentity(value) {
+  if (value instanceof Date) return `date:${value.getTime()}`;
+  return `${typeof value}:${String(value)}`;
+}
+function groupIdentity(value) {
+  if (value === null) return "null";
+  if (value instanceof Date) return `date:${value.getTime()}`;
+  return `${typeof value}:${String(value)}`;
+}
+var emptyEntry = {
+  slug: "",
+  permalink: "",
+  title: "",
+  tags: [],
+  links: [],
+  frontmatter: {}
+};
+
 // src/render.ts
 var TITLE_PROPERTIES = /* @__PURE__ */ new Set(["file.name", "file.title", "title", "name"]);
 var LINK_PROPERTIES = /* @__PURE__ */ new Set([
@@ -665,14 +1793,16 @@ function renderBases(spec, options, entries, source) {
   const className = options.className ?? "rb-bases";
   const views = selectViews(spec, options.view);
   const limit = resolveLimit(options.limit);
-  const sections = views.map((view) => renderView(view, spec, className, entries, limit)).join("");
+  const sections = views.map(
+    (view, index) => renderView(view, spec, className, entries, limit, index)
+  ).join("");
   const fallback = options.showFallback === false ? "" : renderFallback(className, source);
   const firstType = views[0]?.type ?? "table";
   return `<div class="${escapeHtmlAttribute(className)}" data-bases data-bases-view="${firstType}">${sections}${fallback}</div>`;
 }
 function renderBasesError(message, options) {
   const className = options.className ?? "rb-bases";
-  return `<div class="${escapeHtmlAttribute(className)} ${escapeHtmlAttribute(className)}--error" role="status">${escapeHtml(message)}</div>`;
+  return `<div class="${escapeHtmlAttribute(className)} ${escapeHtmlAttribute(className)}--error" role="status">${escapeHtml2(message)}</div>`;
 }
 function selectViews(spec, requested) {
   const configured = spec.views;
@@ -698,76 +1828,105 @@ function resolveLimit(limit) {
   }
   return 100;
 }
-function renderView(view, spec, className, entries, limit) {
+function renderView(view, spec, className, entries, limit, index) {
   const pool = entries.filter(
-    (entry) => view.filter === void 0 || matchesCondition(view.filter, entry)
+    (entry) => (spec.filter === void 0 || matchesCondition(spec.filter, entry)) && (view.filter === void 0 || matchesCondition(view.filter, entry))
   );
   const effectiveLimit = Math.min(view.limit ?? limit, limit);
-  const selected = queryContentEntries(pool, {
-    ...view.sort === void 0 ? {} : { sort: view.sort },
-    limit: effectiveLimit
-  });
-  const name = view.name ? `<h3 class="${escapeHtmlAttribute(className)}__view-name">${escapeHtml(view.name)}</h3>` : "";
-  const body = view.type === "cards" ? renderCards(view, selected, spec, className) : renderTable(view, selected, spec, className);
-  return `<section class="${escapeHtmlAttribute(className)}__view" data-bases-view="${view.type}">${name}${body}</section>`;
-}
-function renderTable(view, entries, spec, className) {
-  if (entries.length === 0) return renderEmpty(className);
+  const selected = sortBasesEntries(pool, view, spec).slice(0, effectiveLimit);
+  const groups = groupBasesEntries(selected, view, spec);
+  const name = view.name ? `<h3 class="${escapeHtmlAttribute(className)}__view-name">${escapeHtml2(view.name)}</h3>` : "";
+  const count = `<p class="${escapeHtmlAttribute(className)}__count">${selected.length} matching ${selected.length === 1 ? "note" : "notes"}</p>`;
+  const body = view.type === "cards" ? renderCards(view, groups, spec, className, index) : renderTable(view, groups, spec, className);
+  return `<section class="${escapeHtmlAttribute(className)}__view" data-bases-view="${view.type}" aria-label="${escapeHtmlAttribute(view.name ?? `${view.type} view ${index + 1}`)}">${name}${count}${body}</section>`;
+}
+function renderTable(view, groups, spec, className) {
+  const entries = groups.flatMap((group) => group.entries);
+  if (groups.length === 0) return renderEmpty(className);
   const head = view.columns.map(
-    (property) => `<th class="${escapeHtmlAttribute(className)}__heading" scope="col">${escapeHtml(columnLabel(property, spec))}</th>`
+    (property) => `<th class="${escapeHtmlAttribute(className)}__heading" scope="col">${escapeHtml2(columnLabel(property, spec))}</th>`
   ).join("");
-  const rows = entries.map((entry) => {
-    const cells = view.columns.map(
-      (property) => `<td class="${escapeHtmlAttribute(className)}__cell">${renderCell(entry, property, className)}</td>`
-    ).join("");
-    return `<tr class="${escapeHtmlAttribute(className)}__row">${cells}</tr>`;
+  const rows = groups.map((group) => {
+    const heading = view.groupBy ? `<tr class="${escapeHtmlAttribute(className)}__group"><th colspan="${view.columns.length}" scope="rowgroup">${escapeHtml2(formatValue(group.key) || "No value")} <span class="${escapeHtmlAttribute(className)}__group-count">(${group.entries.length})</span></th></tr>${renderSummaryRow(view, group.entries, spec, className, "group")}` : "";
+    const values = group.entries.map((entry) => {
+      const cells = view.columns.map(
+        (property) => `<td class="${escapeHtmlAttribute(className)}__cell">${renderCell(entry, property, className, spec)}</td>`
+      ).join("");
+      return `<tr class="${escapeHtmlAttribute(className)}__row">${cells}</tr>`;
+    }).join("");
+    const empty = group.entries.length === 0 ? `<tr class="${escapeHtmlAttribute(className)}__empty-row"><td colspan="${view.columns.length}">${escapeHtml2("No matching notes in this group.")}</td></tr>` : "";
+    return `<tbody>${heading}${values}${empty}</tbody>`;
   }).join("");
-  return [
+  const footer = renderSummaryRow(view, entries, spec, className, "overall");
+  const table = [
     `<table class="${escapeHtmlAttribute(className)}__table">`,
+    `<caption class="${escapeHtmlAttribute(className)}__sr-only">${entries.length} matching ${entries.length === 1 ? "note" : "notes"}</caption>`,
     `<thead><tr>${head}</tr></thead>`,
-    `<tbody>${rows}</tbody>`,
+    rows,
+    footer ? `<tfoot>${footer}</tfoot>` : "",
     "</table>"
   ].join("");
+  return `<div class="${escapeHtmlAttribute(className)}__table-scroll" role="region" aria-label="${escapeHtmlAttribute(view.name ?? "Table view")}" tabindex="0">${table}</div>`;
 }
-function renderCards(view, entries, spec, className) {
-  if (entries.length === 0) return renderEmpty(className);
+function renderCards(view, groups, spec, className, viewIndex) {
+  if (groups.length === 0) return renderEmpty(className);
   const titleProperty = view.columns.find(
     (property) => TITLE_PROPERTIES.has(property.toLowerCase())
   );
   const fields = view.columns.filter((property) => property !== titleProperty);
-  const items = entries.map((entry) => {
-    const title = `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a>`;
-    const fieldHtml = fields.map((property) => {
-      const label = escapeHtml(columnLabel(property, spec));
-      const value = renderCell(entry, property, className);
-      return `<div class="${escapeHtmlAttribute(className)}__field"><dt class="${escapeHtmlAttribute(className)}__field-label">${label}</dt><dd class="${escapeHtmlAttribute(className)}__field-value">${value}</dd></div>`;
+  const cards = groups.map((group, index) => {
+    const groupId = `rb-bases-group-${viewIndex}-${index}`;
+    const heading = view.groupBy ? `<h4 class="${escapeHtmlAttribute(className)}__group-title" id="${escapeHtmlAttribute(groupId)}">${escapeHtml2(formatValue(group.key) || "No value")} <span class="${escapeHtmlAttribute(className)}__group-count">(${group.entries.length})</span></h4>` : "";
+    const items = group.entries.map((entry) => {
+      const title = `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml2(entry.title)}</a>`;
+      const fieldHtml = fields.map((property) => {
+        const label = escapeHtml2(columnLabel(property, spec));
+        const value = renderCell(entry, property, className, spec);
+        return `<div class="${escapeHtmlAttribute(className)}__field"><dt class="${escapeHtmlAttribute(className)}__field-label">${label}</dt><dd class="${escapeHtmlAttribute(className)}__field-value">${value}</dd></div>`;
+      }).join("");
+      const fieldsBlock = fieldHtml ? `<dl class="${escapeHtmlAttribute(className)}__fields">${fieldHtml}</dl>` : "";
+      return `<li class="${escapeHtmlAttribute(className)}__card"><div class="${escapeHtmlAttribute(className)}__card-title">${title}</div>${fieldsBlock}</li>`;
     }).join("");
-    const fieldsBlock = fieldHtml ? `<dl class="${escapeHtmlAttribute(className)}__fields">${fieldHtml}</dl>` : "";
-    return `<li class="${escapeHtmlAttribute(className)}__card"><div class="${escapeHtmlAttribute(className)}__card-title">${title}</div>${fieldsBlock}</li>`;
+    const empty = group.entries.length === 0 ? `<li class="${escapeHtmlAttribute(className)}__card-empty">No matching notes in this group.</li>` : "";
+    const labelledBy = view.groupBy ? ` aria-labelledby="${escapeHtmlAttribute(groupId)}"` : ' aria-label="Cards"';
+    return `<section class="${escapeHtmlAttribute(className)}__card-group">${heading}<ul class="${escapeHtmlAttribute(className)}__cards"${labelledBy}>${items}${empty}</ul></section>`;
   }).join("");
-  return `<ul class="${escapeHtmlAttribute(className)}__cards">${items}</ul>`;
+  return cards;
 }
 function renderEmpty(className) {
   return `<p class="${escapeHtmlAttribute(className)}__empty">No matching notes.</p>`;
 }
 function renderFallback(className, source) {
-  return `<details class="${escapeHtmlAttribute(className)}__fallback"><summary>Base definition</summary><pre><code>${escapeHtml(source)}</code></pre></details>`;
+  return `<details class="${escapeHtmlAttribute(className)}__fallback"><summary>Base definition</summary><pre><code>${escapeHtml2(source)}</code></pre></details>`;
 }
-function renderCell(entry, property, className) {
+function renderCell(entry, property, className, spec) {
   const key = property.toLowerCase();
   if (TITLE_PROPERTIES.has(key)) {
-    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a>`;
+    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml2(entry.title)}</a>`;
   }
   if (LINK_PROPERTIES.has(key)) {
-    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.permalink)}</a>`;
+    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml2(entry.permalink)}</a>`;
   }
   if (TAG_PROPERTIES.has(key)) {
     return entry.tags.length === 0 ? "" : `<span class="${escapeHtmlAttribute(className)}__tags">${entry.tags.map(
-      (tag) => `<span class="${escapeHtmlAttribute(className)}__tag">#${escapeHtml(tag)}</span>`
+      (tag) => `<span class="${escapeHtmlAttribute(className)}__tag">#${escapeHtml2(tag)}</span>`
     ).join(" ")}</span>`;
   }
-  const value = resolveValueRef(parseValueRef(property), entry);
-  return escapeHtml(formatValue(value));
+  const value = resolveBasesProperty(entry, property, spec);
+  return escapeHtml2(formatValue(value));
+}
+function renderSummaryRow(view, entries, spec, className, kind) {
+  if (!view.summaries) return "";
+  const cells = view.columns.map((property) => {
+    const summary = view.summaries?.[property];
+    if (!summary)
+      return `<td class="${escapeHtmlAttribute(className)}__summary"></td>`;
+    const values = entries.map(
+      (entry) => resolveBasesProperty(entry, property, spec)
+    );
+    return `<td class="${escapeHtmlAttribute(className)}__summary">${escapeHtml2(formatValue(summarizeBasesValues(values, summary, spec)))}<span class="${escapeHtmlAttribute(className)}__sr-only"> ${escapeHtml2(`${columnLabel(property, spec)} summary`)}</span></td>`;
+  }).join("");
+  return `<tr class="${escapeHtmlAttribute(className)}__summary-row ${escapeHtmlAttribute(className)}__summary-row--${kind}">${cells}</tr>`;
 }
 function columnLabel(property, spec) {
   const configured = spec.properties[property];
@@ -780,7 +1939,7 @@ function columnLabel(property, spec) {
 }
 function formatValue(value) {
   if (value === void 0 || value === null) return "";
-  if (value instanceof Date) return formatDate(value);
+  if (value instanceof Date) return formatDate2(value);
   if (Array.isArray(value))
     return value.map((item) => formatValue(item)).join(", ");
   if (typeof value === "string") {
@@ -788,45 +1947,272 @@ function formatValue(value) {
   }
   return String(value);
 }
-function formatDate(value) {
+function formatDate2(value) {
   const time = value.getTime();
   if (!Number.isFinite(time)) return "";
   return value.toISOString().slice(0, 10);
 }
 
+// src/yaml.ts
+import { matter } from "vfile-matter";
+function parseBasesYaml(source) {
+  try {
+    const document = `---
+${source}
+---
+`;
+    const file = {
+      value: document,
+      data: {},
+      toString: () => document
+    };
+    matter(file);
+    return { ok: true, value: file.data.matter };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Base definition is not valid YAML (${error instanceof Error ? error.message : String(error)}).`
+    };
+  }
+}
+
+// src/page.ts
+var BASE_SUFFIX = /\.base$/i;
+async function listBaseDocuments(input) {
+  if (!input.contentSource) return [];
+  const documents = [];
+  for (const slug of publicBaseSlugs(input.manifest)) {
+    const pathname = basePath(slug);
+    if (!pathname || input.manifest.byRoutablePermalink.has(pathname) || input.manifest.publicRedirects.has(pathname)) {
+      if (pathname)
+        input.diagnostics.push(
+          diagnostic(
+            slug,
+            `Base page \`${pathname}\` conflicts with an existing public route.`
+          )
+        );
+      continue;
+    }
+    const source = await readBase(input.contentSource, slug);
+    if (!source) {
+      input.diagnostics.push(
+        diagnostic(
+          slug,
+          `Base \`${slug}\` is not a valid Bases YAML document.`
+        )
+      );
+      continue;
+    }
+    const parsed = parseBase(source);
+    if (parsed.ok === false) {
+      input.diagnostics.push(
+        diagnostic(
+          slug,
+          `Base \`${slug}\` is not a valid Bases YAML document.`
+        )
+      );
+      continue;
+    }
+    documents.push({
+      pathname,
+      dependencies: [
+        { type: "file", path: slug },
+        analyzeBasesDependencies(parsed.value)
+      ]
+    });
+  }
+  return documents;
+}
+async function resolveBaseDocument(input, options) {
+  if (!input.contentSource) return null;
+  const slug = publicBaseSlugs(input.manifest).find(
+    (candidate) => basePath(candidate) === input.pathname
+  );
+  if (!slug || input.manifest.byRoutablePermalink.has(input.pathname) || input.manifest.publicRedirects.has(input.pathname))
+    return null;
+  const source = await readBase(input.contentSource, slug);
+  if (!source) return null;
+  const parsed = parseBase(source);
+  if (parsed.ok === false) {
+    input.diagnostics.push(diagnostic(slug, parsed.message));
+    return null;
+  }
+  const title = slug.split("/").at(-1)?.replace(BASE_SUFFIX, "") ?? slug;
+  let body;
+  try {
+    body = renderBases(
+      parsed.value,
+      options,
+      input.manifest.discoverableEntries,
+      source
+    );
+  } catch (error) {
+    const message = `Base \`${slug}\` failed to render (${formatError(error)}).`;
+    input.diagnostics.push(diagnostic(slug, message));
+    body = renderBasesError(message, options);
+  }
+  return {
+    type: "bases-document",
+    pathname: input.pathname,
+    title,
+    body: `<main class="rb-bases-page"><h1 class="rb-bases-page__title">${escapeHtml3(title)}</h1>${body}</main>`
+  };
+}
+function publicBaseSlugs(manifest) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const entry of manifest.publicEntries)
+    for (const link of entry.links)
+      if (link.kind === "attachment" && link.slug && BASE_SUFFIX.test(link.slug))
+        slugs.add(link.slug);
+  return [...slugs].sort();
+}
+function basePath(slug) {
+  const pathname = `/${slug.replace(BASE_SUFFIX, "")}`.replace(/\/+/g, "/");
+  return pathname === "/" ? null : pathname;
+}
+async function readBase(source, slug) {
+  try {
+    const raw = await readContentSourceEntry(source, slug);
+    return raw === null ? null : typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+  } catch {
+    return null;
+  }
+}
+function parseBase(source) {
+  const yaml = parseBasesYaml(source);
+  if (yaml.ok === false) return yaml;
+  return parseBases(yaml.value);
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function diagnostic(slug, message) {
+  return {
+    code: "bases-invalid",
+    severity: "warning",
+    pluginName: "bases",
+    target: slug,
+    message
+  };
+}
+
+// src/remark.ts
+import { visit } from "unist-util-visit";
+
+// src/placeholder.ts
+var BASES_ATTRIBUTE = "data-rr-bases";
+function encodeBasesPayload(payload) {
+  return encodeURIComponent(JSON.stringify(payload));
+}
+function decodeBasesPayload(encoded) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(encoded));
+    if (!parsed || typeof parsed !== "object") return null;
+    const candidate = parsed;
+    if (typeof candidate.source !== "string" || !candidate.spec) return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function createBasesPlaceholder(payload) {
+  return `<div ${BASES_ATTRIBUTE}="${encodeBasesPayload(payload)}"></div>`;
+}
+function createBasesPlaceholderPattern() {
+  return new RegExp(
+    `<div\\b[^>]*\\b${BASES_ATTRIBUTE}="([^"]*)"[^>]*>\\s*</div>`,
+    "g"
+  );
+}
+
+// src/remark.ts
+function remarkBases(options = {}) {
+  const language = options.language ?? "base";
+  return (tree, file) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (node.lang !== language) return;
+      if (!parent || index === void 0) return;
+      const parsed = parseBasesYaml(node.value);
+      if (parsed.ok === false) {
+        reportDiagnostic(file, parsed.message, node);
+        return;
+      }
+      const spec = parseBases(parsed.value);
+      if (spec.ok === false) {
+        reportDiagnostic(file, spec.message, node);
+        return;
+      }
+      const html = {
+        type: "html",
+        value: createBasesPlaceholder({ spec: spec.value, source: node.value })
+      };
+      parent.children.splice(index, 1, html);
+    });
+  };
+}
+function reportDiagnostic(file, message, node) {
+  const reporter = file?.message;
+  if (typeof reporter !== "function") return;
+  const diagnostic3 = reporter.call(file, message, node);
+  if (diagnostic3 && typeof diagnostic3 === "object") {
+    Object.assign(diagnostic3, { source: "@riebeckite/plugin-bases" });
+  }
+}
+
 // src/runtime.ts
 function createBasesRuntime(options) {
+  const dependencies = /* @__PURE__ */ new Map();
+  let documentDependencies = /* @__PURE__ */ new Map();
   return {
     resolve(manifest, diagnostics, _config) {
       const entries = manifest.discoverableEntries;
       for (const entry of manifest.publicEntries) {
         if (!entry.html.includes(BASES_ATTRIBUTE)) continue;
-        const html = replacePlaceholders(entry, entries, options, diagnostics);
+        const resolved = replacePlaceholders(
+          entry,
+          entries,
+          options,
+          diagnostics
+        );
+        dependencies.set(entry.slug, resolved.dependencies);
+        const html = resolved.html;
         if (html === entry.html) continue;
         entry.html = html;
       }
+    },
+    dependenciesFor(slug) {
+      return dependencies.get(slug) ?? [];
+    },
+    dependenciesForPage(pathname) {
+      return documentDependencies.get(pathname) ?? [{ type: "unknown" }];
+    },
+    setDocumentDependencies(nextDependencies) {
+      documentDependencies = new Map(nextDependencies);
     }
   };
 }
 function replacePlaceholders(entry, entries, options, diagnostics) {
   const pattern = createBasesPlaceholderPattern();
-  return entry.html.replace(pattern, (_match, encoded) => {
+  const dependencies = [];
+  const html = entry.html.replace(pattern, (_match, encoded) => {
     const payload = decodeBasesPayload(encoded);
     if (!payload) {
       const message = `Base block in \`${entry.slug}\` could not be decoded.`;
-      diagnostics.push(diagnostic(entry, message));
+      diagnostics.push(diagnostic2(entry, message));
       return renderBasesError(message, options);
     }
     try {
+      dependencies.push(analyzeBasesDependencies(payload.spec));
       return renderBases(payload.spec, options, entries, payload.source);
     } catch (error) {
       const message = `Base block in \`${entry.slug}\` failed to render (${formatError2(error)}).`;
-      diagnostics.push(diagnostic(entry, message));
+      diagnostics.push(diagnostic2(entry, message));
       return renderBasesError(message, options);
     }
   });
+  return { html, dependencies };
 }
-function diagnostic(entry, message) {
+function diagnostic2(entry, message) {
   return {
     code: "bases-invalid",
     severity: "error",
@@ -845,9 +2231,10 @@ function bases(options = {}) {
   const runtime = createBasesRuntime(options);
   return definePlugin({
     name: "bases",
-    contentOutputDependencies: [{ type: "global" }],
+    contentFileMetadata: true,
+    resolveContentOutputDependencies: ({ entry }) => runtime.dependenciesFor(entry.slug),
     processedContentCache: {
-      version: "bases-v1",
+      version: "bases-v3",
       dependencyMode: "none"
     },
     options,
@@ -859,6 +2246,29 @@ function bases(options = {}) {
     onManifestCreated: (context) => {
       runtime.resolve(context.manifest, context.diagnostics, context.config);
     },
+    pageTypes: [
+      {
+        id: "bases-document",
+        paths: async ({ manifest, contentSource, diagnostics }) => {
+          const documents = await listBaseDocuments({
+            manifest,
+            contentSource,
+            diagnostics
+          });
+          runtime.setDocumentDependencies(
+            new Map(
+              documents.map((document) => [
+                document.pathname,
+                document.dependencies
+              ])
+            )
+          );
+          return documents.map((document) => document.pathname);
+        },
+        outputDependencies: ({ pathname }) => runtime.dependenciesForPage(pathname),
+        resolve: (context) => resolveBaseDocument(context, options)
+      }
+    ],
     assets: [createStyleAsset("bases", "@riebeckite/plugin-bases/style.css")]
   });
 }
@@ -887,10 +2297,18 @@ function validateBasesOptions(options) {
   return issues;
 }
 export {
+  BasesEvaluationError,
+  analyzeBasesDependencies,
   bases,
   basesPlugin,
+  evaluateBasesExpression,
+  groupBasesEntries,
   matchesCondition,
   parseBases,
+  parseBasesExpression,
   remarkBases,
-  resolveValueRef
+  resolveBasesProperty,
+  resolveValueRef,
+  sortBasesEntries,
+  summarizeBasesValues
 };