@bitcobblers/wod-wiki-wql 0.44.2159 → 0.45.2166

package/dist/index.cjs

@@ -31,7 +31,7 @@ var WQL_TAG_KEYS = [
   "result",
   "tags"
 ];
-var WQL_CONTENT_ONLY_KEYS = ["type", "text", "has", "source", "catalog", "notebook"];
+var WQL_CONTENT_ONLY_KEYS = ["type", "text", "source", "notebook", "contributes"];
 var WQL_EFFORT_FILTER_KEYS = ["effort", "discipline", "intensity", "origin", "text"];
 var WQL_VIRTUAL_DIMS = ["day", "week", "session", "round"];
 var WQL_CALC_TARGETS = [
@@ -59,8 +59,8 @@ var WQL_CALC_TARGETS = [
 ];
 var WQL_INTENSITY_TIERS = ["low", "moderate", "high"];
 var WQL_GRAINS = ["summary", "event"];
-var WQL_FIND_TARGETS = ["note", "block", "effort", "session", "segment", "event"];
-var WQL_SOURCE_VALUES = ["journal", "feeds", "guides", "playground", "dashboards", "efforts", "equipment"];
+var WQL_FIND_TARGETS = ["note", "block", "effort", "session", "segment", "event", "notebook", "page", "tag", "equipment"];
+var WQL_SOURCE_VALUES = ["journal", "notebooks", "guides", "playground", "dashboards", "efforts", "equipment"];
 var WQL_SOURCE_HEADS = [
   "note",
   "notes",
@@ -72,23 +72,18 @@ var WQL_SOURCE_HEADS = [
   "journal",
   "notebook",
   "notebooks",
-  "feed",
-  "feeds",
-  "catalog",
-  "catalogs",
   "playground",
+  "page",
+  "tag",
+  "equipment",
   "dashboard"
 ];
 var WQL_SOURCE_HEAD_SCOPES = {
   journal: "journal",
-  notebook: "feeds",
-  notebooks: "feeds",
-  feed: "feeds",
-  feeds: "feeds",
-  catalog: "feeds",
-  catalogs: "feeds",
+  notebooks: "notebooks",
   playground: "playground"
 };
+var WQL_NOTE_HEAD_ALIASES = ["notes"];
 var WQL_TYPE_HEADS = {
   dashboard: "dashboard"
 };
@@ -97,8 +92,8 @@ var WQL_FUNCTION_HEADS = WQL_AGGREGATORS;
 var WQL_CHART_HEADS = ["timeseries", "bar", "table", "donut", "toplist", "value"];
 var WQL_STANDARD_DATASETS = ["@session", "@today"];
 var WQL_RESULT_PLANES = wodWikiCore.KNOWN_OUTPUT_TYPES;
-var WQL_CONTENT_FILTER_KEYS = ["type", "text", "has", "source", "catalog", "notebook", ...WQL_TAG_KEYS];
-var WQL_SOURCES = ["note", "block", "effort", "session", "segment", "event"];
+var WQL_CONTENT_FILTER_KEYS = ["type", "text", "source", "notebook", "page", "contributes", ...WQL_TAG_KEYS];
+var WQL_SOURCES = WQL_FIND_TARGETS;
 var WQL_ROLLUP_PERIODS = ["2w", "4w"];
 var WQL_DISPLAY_UNITS = ["kg", "lb"];
 var WQL_KEYWORDS = [
@@ -134,12 +129,25 @@ var AGGREGATE_TYPES = /* @__PURE__ */ new Set([
   "metric"
 ]);
 var TARGET_TYPES = {
-  note: /* @__PURE__ */ new Set(["text", "catalog", "notebook", "tag", "effort", ...WQL_TYPED_TAG_KEYS, "type", "page", "source", "note", "time", "groupby", "where"]),
-  block: /* @__PURE__ */ new Set(["text", "catalog", "notebook", "tag", "effort", "type", "source", "note", "time", "groupby", "where"]),
+  // The notebook plane IS the note plane (its executor delegates), so both
+  // advertise the same member-criteria keys — container criteria (tags:,
+  // effort:, typed tags, text:) narrow notebook results, never ignored.
+  notebook: /* @__PURE__ */ new Set(["text", "notebook", "tag", "effort", ...WQL_TYPED_TAG_KEYS, "type", "page", "source", "note", "time", "groupby", "where"]),
+  note: /* @__PURE__ */ new Set(["text", "notebook", "tag", "effort", ...WQL_TYPED_TAG_KEYS, "type", "page", "source", "note", "time", "groupby", "where"]),
+  block: /* @__PURE__ */ new Set(["text", "notebook", "tag", "effort", "type", "source", "note", "time", "groupby", "where"]),
   effort: /* @__PURE__ */ new Set([...WQL_EFFORT_FILTER_KEYS, "groupby"]),
   session: /* @__PURE__ */ new Set(["result", "block", "note", "plane", "time", "groupby"]),
   segment: /* @__PURE__ */ new Set([...TABLE_KEYS, "time", "groupby", "unit"]),
-  event: /* @__PURE__ */ new Set([...TABLE_KEYS, "time", "groupby", "unit"])
+  event: /* @__PURE__ */ new Set([...TABLE_KEYS, "time", "groupby", "unit"]),
+  // Container planes (ticket 08). `:notebook{}` delegates to the note plane
+  // (see the notebook entry above); `:page{}` lists the page placements;
+  // `:tag{}` the tags (results are notes); `:equipment{}` the equipment
+  // notes. The tag plane's `contributes:` filter matches what a tag
+  // contributes — never offered as a `tags:` label filter. These executors
+  // return flat rows (no `by {}` grouping), so groupby stays unadvertised.
+  page: /* @__PURE__ */ new Set(["page", "notebook", "text", "note", "time"]),
+  tag: /* @__PURE__ */ new Set(["tag", "type", "text", "contributes", "time"]),
+  equipment: /* @__PURE__ */ new Set(["equipment", "tags", "text", "notebook", "time"])
 };
 var EMPTY_TYPES = /* @__PURE__ */ new Set();
 var AGGREGATE_KEYS = WQL_TAG_KEYS;
@@ -654,18 +662,24 @@ function validateSourceFilter(filters) {
     for (const v of f.values) {
       const val = v.value;
       if (val === "page" || val === "pages") {
-        return `source:${val} is retired \u2014 page-ness is handled by type: (e.g. type:feed or source:guides).`;
+        return `source:${val} is retired \u2014 page-ness is handled by type:page or source:guides.`;
       }
       if (val === "all") {
         return `source:all is retired \u2014 omit the source: filter to query all sources.`;
       }
-      if (val === "collection" || val === "collections") {
-        return `source:${val} is retired \u2014 collections were renamed to feeds; use source:feeds or :feed{}.`;
+      if (val === "notebook") {
+        return `source:notebook is retired \u2014 :notebook{} is the notebook plane (every notebook); narrow it with the notebook: filter, e.g. :notebook{notebook:journal}.`;
+      }
+      if (val === "feed" || val === "feeds" || val.startsWith("feed:")) {
+        return `source:${val} is retired \u2014 the feed corpus is the notebook plane; use source:notebooks or notebook:<slug>.`;
+      }
+      if (val === "collection" || val === "collections" || val.startsWith("collection:")) {
+        return `source:${val} is retired \u2014 collections are notebooks; use source:notebooks or notebook:<slug>.`;
       }
-      if (WQL_SOURCE_VALUES.includes(val) || val === "feed" || val === "notebook" || val === "notebooks" || val.startsWith("collection:") || val.startsWith("feed:") || val.startsWith("notebook:") || val.startsWith("notebook/")) {
+      if (WQL_SOURCE_VALUES.includes(val) || val.startsWith("notebook:") || val.startsWith("notebook/")) {
         continue;
       }
-      return `Unknown source "${val}". Try: ${WQL_SOURCE_VALUES.join(", ")} (or collection:<id>, feed:<id>)`;
+      return `Unknown source "${val}". Try: ${WQL_SOURCE_VALUES.join(", ")} (or notebook:<slug>)`;
     }
   }
   return void 0;
@@ -948,11 +962,7 @@ function parseFindQuery(raw, opts) {
   if (scope || typeScope) {
     result.target = "note";
   } else {
-    result.target = headName === "notes" ? "note" : headName;
-    if (result.target === "page") {
-      result.error = "find:page is retired \u2014 page-ness is handled by type: (e.g. :note{source:guides} or type:feed).";
-      return result;
-    }
+    result.target = WQL_NOTE_HEAD_ALIASES.includes(headName) ? "note" : headName;
     if (!WQL_FIND_TARGETS.includes(result.target)) {
       result.error = `Unknown find target "${result.target}". Try: ${WQL_FIND_TARGETS.join(", ")}`;
       return result;
@@ -972,13 +982,6 @@ function parseFindQuery(raw, opts) {
       negate: false,
       values: [{ value: scope, wildcard: false }]
     });
-    if (headName === "catalog" || headName === "catalogs" || headName === "notebook" || headName === "notebooks") {
-      result.filters.push({
-        key: "type",
-        negate: false,
-        values: [{ value: "feed", wildcard: false }]
-      });
-    }
   }
   const inScope = opts?.colon && result.displayUnit && result.displayUnit !== "kg" && result.displayUnit !== "lb" ? result.displayUnit : legacyScope;
   if (opts?.colon && inScope) {
@@ -1487,10 +1490,12 @@ function chained(list, suffix) {
     ...c,
     apply: (view, _c, from, to) => {
       const text = typeof c.apply === "string" ? c.apply : c.label;
+      const selfTerminated = /\W$/.test(text);
       const present = view.state.sliceDoc(to, to + suffix.length) === suffix;
+      const insert = selfTerminated || present ? text : text + suffix;
       view.dispatch({
-        changes: { from, to, insert: present ? text : text + suffix },
-        selection: { anchor: from + text.length + suffix.length },
+        changes: { from, to: to + (selfTerminated && present ? suffix.length : 0), insert },
+        selection: { anchor: from + insert.length },
         userEvent: "input.complete"
       });
       autocomplete.startCompletion(view);
@@ -1508,7 +1513,7 @@ function headApply(o, colonTyped) {
   return { ...o, apply: `${colonTyped ? "" : ":"}${o.label}{` };
 }
 var LEGACY_HEAD_OPTIONS = WQL_AGGREGATORS.map((label) => ({ label, type: "keyword" }));
-var NOTE_COLUMNS = ["title", "date", "createdAt", "type", "sourceId", "catalog", "notebookId"];
+var NOTE_COLUMNS = ["title", "date", "createdAt", "type", "sourceId", "notebookId"];
 var BLOCK_COLUMNS = ["noteTitle", "dataType", "position", "createdAt", "noteId", "sourceId"];
 var EFFORT_COLUMNS = ["slug", "label", "registrySource"];
 var SESSION_COLUMNS = ["duration", "startTime", "origin"];
@@ -1536,7 +1541,7 @@ function resolveColonHead(name) {
   if (WQL_FUNCTION_HEADS.includes(n)) return { family: "aggregate" };
   if (WQL_CHART_HEADS.includes(n)) return { family: "find" };
   const headTarget = (head) => {
-    if (head === "notes") return "note";
+    if (WQL_NOTE_HEAD_ALIASES.includes(head)) return "note";
     const scoped = WQL_SOURCE_HEAD_SCOPES[head] || WQL_TYPE_HEADS[head];
     return scoped ? "note" : head;
   };
@@ -1705,12 +1710,17 @@ function wqlCompletionSource(options_ = {}) {
     if (/\s+to\s+$/i.test(tail)) {
       return finish(context, context.pos, [{ label: "2026-03-31", detail: "end date (YYYY-MM-DD)", type: "constant" }], "");
     }
+    const hasBy = /\bby\s*\{[^{}]*\}/.test(tail);
+    const hasRollup = /\.rollup\([^()]*\)/.test(tail);
+    const hasWindow = /\s+last\s+\d+[dw]\b/i.test(tail) || /\s+from\s+\d{4}-\d{2}-\d{2}(?:\s+to\s+\d{4}-\d{2}-\d{2})?\b/i.test(tail);
     const dims = wqlGroupingDimensions(head.target ?? "", head.family);
     const keywords = [
-      { label: "by {}", apply: "by ", detail: dims.length ? "group by dimensions" : `advisory: no grouping dimensions for find:${head.target}`, type: "keyword" },
-      ...head.family === "aggregate" ? [{ label: ".rollup()", apply: ".rollup(", detail: "bucket period", type: "keyword" }] : [],
-      { label: "last", apply: "last ", detail: "relative window: last <n>d|w", type: "keyword" },
-      { label: "from", apply: "from ", detail: "date range: from YYYY-MM-DD [to YYYY-MM-DD]", type: "keyword" },
+      ...hasBy ? [] : [{ label: "by {}", apply: "by ", detail: dims.length ? "group by dimensions" : `advisory: no grouping dimensions for find:${head.target}`, type: "keyword" }],
+      ...head.family === "aggregate" && !hasRollup ? [{ label: ".rollup()", apply: ".rollup(", detail: "bucket period", type: "keyword" }] : [],
+      ...hasWindow ? [] : [
+        { label: "last", apply: "last ", detail: "relative window: last <n>d|w", type: "keyword" },
+        { label: "from", apply: "from ", detail: "date range: from YYYY-MM-DD [to YYYY-MM-DD]", type: "keyword" }
+      ],
       ...head.family === "find" ? [{ label: "|", apply: "| ", detail: "presentation pipes: order by / select / limit", type: "keyword" }] : []
     ];
     return finish(context, from, chained(keywords, " "), typed);
@@ -2276,6 +2286,7 @@ var QueryDocumentRunner = class {
             ...findRun.blocks ? { blocks: findRun.blocks } : {},
             ...findRun.efforts ? { efforts: findRun.efforts } : {},
             ...findRun.containers ? { containers: findRun.containers } : {},
+            ...findRun.placements ? { placements: findRun.placements } : {},
             ...findRun.runs ? { runs: findRun.runs } : {},
             ...findRun.table ? { table: findRun.table } : {},
             ...findRun.unit ? { unit: findRun.unit } : {},
@@ -2306,6 +2317,7 @@ var QueryDocumentRunner = class {
             ...pipelineRun.blocks ? { blocks: pipelineRun.blocks } : {},
             ...pipelineRun.efforts ? { efforts: pipelineRun.efforts } : {},
             ...pipelineRun.containers ? { containers: pipelineRun.containers } : {},
+            ...pipelineRun.placements ? { placements: pipelineRun.placements } : {},
             ...pipelineRun.runs ? { runs: pipelineRun.runs } : {},
             ...pipelineRun.unit ? { unit: pipelineRun.unit } : {},
             ...pipelineRun.chart ? { chart: pipelineRun.chart } : {},
@@ -2912,16 +2924,18 @@ function dedupeById(facts) {
   }
   return out;
 }
+
+// src/QueryService.ts
 var NOTE_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function catalogOfItem(item) {
-  if (item.catalog) return item.catalog;
-  const isCollectionOrFeed = !!item.sourceId && /^(collection|feed):/.test(item.sourceId);
-  const raw = isCollectionOrFeed ? item.sourceId.replace(/^(collection|feed):/, "") : item.noteId || item.id || "";
-  if (!raw) return void 0;
-  if (NOTE_UUID_RE.test(raw)) return void 0;
-  const clean = raw.startsWith("feeds/") ? raw.slice("feeds/".length) : raw;
-  if (!isCollectionOrFeed && !clean.includes("/")) return void 0;
-  return clean.split("/")[0];
+function notebookSlugOfSourceId(sourceId) {
+  if (!sourceId?.startsWith("notebook:")) return void 0;
+  const rest = sourceId.slice("notebook:".length);
+  if (!rest || rest === "_root") return void 0;
+  return rest.split("/")[0];
+}
+function feedOfItem(item) {
+  const id = item.feedSourceId;
+  return typeof id === "string" && id.trim() ? id : void 0;
 }
 function notebookOfItem(item) {
   if (item.notebookId && item.notebookId.trim()) {
@@ -2930,46 +2944,75 @@ function notebookOfItem(item) {
   if (item.tags) {
     for (const tag of item.tags) {
       if (tag.startsWith("notebook:") || tag.startsWith("notebook/")) {
-        const slug = wodWikiCore.notebookSlugFromId(tag);
-        if (slug) return wodWikiCore.toNotebookId(slug);
+        const slug2 = wodWikiCore.notebookSlugFromId(tag);
+        if (slug2) return wodWikiCore.toNotebookId(slug2);
       }
     }
   }
+  const corpus = /^markdown\/(notebooks|canvas|efforts|dashboards|equipment)\/(.+)$/.exec(item.sourcePath ?? "");
+  if (corpus) {
+    const [, family, rest] = corpus;
+    if (family === "canvas") return "notebook/guides";
+    if (family !== "notebooks") return wodWikiCore.toNotebookId(family);
+    const segs = rest.split("/");
+    if (segs.length > 1) return wodWikiCore.toNotebookId(segs[0]);
+  }
   if (sourceMatches(item, "playground")) return "notebook/playground";
   if (sourceMatches(item, "guides")) return "notebook/guides";
-  const cat = catalogOfItem(item);
-  if (cat) return wodWikiCore.toNotebookId(cat);
-  if (sourceMatches(item, "journal")) return "notebook/journal";
+  if (item.sourceId === "efforts") return "notebook/efforts";
+  if (item.sourceId === "equipment") return "notebook/equipment";
+  if (item.sourceId === "dashboards" || item.type === "dashboard") return "notebook/dashboards";
+  const slug = notebookSlugOfSourceId(item.sourceId);
+  if (slug) return wodWikiCore.toNotebookId(slug);
+  if (isJournalRow(item)) return "notebook/journal";
   return void 0;
 }
+function notebookOriginOfItem(item) {
+  const notebook = notebookOfItem(item);
+  if (!notebook) return void 0;
+  if (item.notebookId?.trim()) return "user";
+  if (item.tags?.some((t2) => t2.startsWith("notebook:") || t2.startsWith("notebook/"))) return "user";
+  if (notebook === "notebook/journal" || notebook === "notebook/playground") return "default";
+  return "feed";
+}
+function isJournalRow(item) {
+  const sourceId = item.sourceId;
+  if (item.type === "playground" || item.id?.startsWith("playground/") || item.noteId?.startsWith("playground/")) return false;
+  if (sourceId && sourceId !== "journal" && !NOTE_UUID_RE.test(sourceId) && !/^journal\/\d{4}-\d{2}-\d{2}$/.test(sourceId)) return false;
+  return item.type !== "dashboard" && item.type !== "effort" && item.type !== "equipment" && item.seedOrigin !== "seed" && item.feedOrigin !== "feed" && item.seedChunkId === void 0 && !(!!item.sourcePath && item.sourcePath.startsWith("markdown/"));
+}
+var SOURCE_ID_SHAPES = {
+  notebooks: { prefixes: ["notebook:"] },
+  pages: { exact: ["page"], prefixes: ["page:", "guides:"] },
+  guides: { prefixes: ["guides:"] },
+  playground: { exact: ["playground"], legacyType: "playground" },
+  efforts: { exact: ["efforts"] },
+  equipment: { exact: ["equipment"] },
+  dashboards: { exact: ["dashboards"] }
+};
+var SOURCE_SHAPE_ALIASES = {
+  page: "pages",
+  guide: "guides"
+};
+function sourceShape(kind) {
+  return SOURCE_ID_SHAPES[SOURCE_SHAPE_ALIASES[kind] ?? kind];
+}
 function sourceMatches(item, kind) {
   const sourceId = item.sourceId;
   if (kind === "all") return !sourceId || WQL_SOURCE_VALUES.some((k) => sourceMatches(item, k));
   if (kind === "journal") {
-    if (item.type === "playground" || item.id?.startsWith("playground/") || item.noteId?.startsWith("playground/")) return false;
-    if (sourceId && sourceId !== "journal" && !NOTE_UUID_RE.test(sourceId) && !/^journal\/\d{4}-\d{2}-\d{2}$/.test(sourceId)) return false;
-    return item.type !== "dashboard" && item.type !== "effort" && item.type !== "equipment" && item.seedOrigin !== "seed" && item.seedChunkId === void 0 && !item.catalog && !(!!item.sourcePath && item.sourcePath.startsWith("markdown/"));
+    return notebookOfItem(item) === "notebook/journal";
   }
-  if (kind === "feed" || kind === "feeds" || kind === "notebook" || kind === "notebooks") {
-    return !!sourceId && (sourceId.startsWith("collection:") || sourceId.startsWith("page:collection:"));
-  }
-  if (kind === "page" || kind === "pages") {
-    return !!sourceId && (sourceId === "page" || sourceId.startsWith("page:") || sourceId.startsWith("guides:"));
-  }
-  if (kind === "guide" || kind === "guides") {
-    return !!sourceId && sourceId.startsWith("guides:");
-  }
-  if (kind === "playground") {
-    return sourceId === "playground" || item.type === "playground";
-  }
-  if (kind.startsWith("feed:")) {
-    const rest = kind.slice("feed:".length).replace(/^feeds\//, "");
-    if (!rest || !sourceId?.startsWith("feed:")) return false;
-    const idRest = sourceId.slice("feed:".length).replace(/^feeds\//, "");
-    return idRest === rest || idRest.startsWith(`${rest}/`);
+  const shape = sourceShape(kind);
+  if (shape) {
+    const idHit = !!sourceId && (shape.exact?.includes(sourceId) || shape.prefixes?.some((p) => sourceId.startsWith(p)) === true);
+    return idHit || !!shape.legacyType && item.type === shape.legacyType;
   }
   if (kind.startsWith("notebook:") || kind.startsWith("notebook/")) {
-    return notebookOfItem(item) === wodWikiCore.toNotebookId(kind);
+    const rest = wodWikiCore.notebookSlugFromId(kind);
+    const idRest = sourceId?.startsWith("notebook:") ? sourceId.slice("notebook:".length) : void 0;
+    if (!idRest) return notebookOfItem(item) === wodWikiCore.toNotebookId(kind);
+    return idRest === rest || idRest.startsWith(`${rest}/`);
   }
   return sourceId === kind;
 }
@@ -2998,8 +3041,7 @@ function applyNotebookFilter(items, filters) {
   return items;
 }
 var DOMAIN_SOURCE_KINDS = {
-  feed: true,
-  feeds: true,
+  notebooks: true,
   page: true,
   pages: true,
   guide: true,
@@ -3025,6 +3067,10 @@ function compileContentRead(filters, plane, sourceScope) {
       residual = true;
       continue;
     }
+    if (plane === "note" && WQL_TYPED_TAG_KEYS.includes(filter.key) && literal) {
+      compiled.push({ field: "typedTag", tagType: filter.key, values });
+      continue;
+    }
     if (filter.key === "text" && literal) {
       compiled.push({ field: "text", value: values.join(" ") });
       continue;
@@ -3687,9 +3733,17 @@ var QueryService = class {
     if (parsed.target === "segment" || parsed.target === "event") {
       return this.runFindTable(parsed, options2);
     }
-    const isCatalogHead = parsed.target === "note" && parsed.filters.some((f) => f.key === "type" && !f.negate && f.values.some((v) => v.value === "feed")) && (parsed.filters.some((f) => f.key === "source" && !f.negate && f.values.some((v) => v.value === "feed" || v.value === "feeds" || v.value === "notebook" || v.value === "notebooks")) || parsed.sourceScope?.includes("feeds") || parsed.sourceScope?.includes("notebooks"));
-    if (isCatalogHead) {
-      return this.runFindCatalog(parsed, options2, await this.noteStore.getAllNotes());
+    if (parsed.target === "notebook") {
+      return this.runFindNotebook(parsed, options2);
+    }
+    if (parsed.target === "page") {
+      return this.runFindPage(parsed, options2);
+    }
+    if (parsed.target === "tag") {
+      return this.runFindTag(parsed, options2);
+    }
+    if (parsed.target === "equipment") {
+      return this.runFindEquipment(parsed, options2);
     }
     const read = compileContentRead(parsed.filters, "note", parsed.sourceScope);
     const paging = domainPaging(parsed, options2, read.residual);
@@ -3709,14 +3763,14 @@ var QueryService = class {
     const selectedCount = selectedFromDomain ?? notes.length;
     const ctx = runContext(options2);
     for (const filter of parsed.filters) {
-      if (filter.key === "tags" && !filter.negate) {
+      if (isTagLabelKey(filter.key) && !filter.negate) {
         const matchingIds = /* @__PURE__ */ new Set();
         for (const v of filter.values) {
           const ids = await this.noteStore.getNoteIdsForTag(v.value);
           ids.forEach((id) => matchingIds.add(id));
         }
         notes = notes.filter((n) => matchingIds.has(n.id));
-      } else if (filter.key === "tags" && filter.negate) {
+      } else if (isTagLabelKey(filter.key) && filter.negate) {
         for (const v of filter.values) {
           const ids = await this.noteStore.getNoteIdsForTag(v.value);
           notes = notes.filter((n) => !ids.has(n.id));
@@ -3759,17 +3813,6 @@ var QueryService = class {
         notes = notes.filter((n) => wantsPage ? n.type === "page" : n.type !== "page");
       }
     }
-    for (const filter of parsed.filters) {
-      if (filter.key === "catalog") {
-        const wanted = new Set(filter.values.map((v) => v.value));
-        notes = notes.filter((n) => {
-          const cat = catalogOfItem(n);
-          if (!cat) return filter.negate;
-          const hit = wanted.has(cat);
-          return filter.negate ? !hit : hit;
-        });
-      }
-    }
     notes = applyNotebookFilter(notes, parsed.filters);
     for (const filter of parsed.filters) {
       if (filter.key === "note") {
@@ -3800,46 +3843,56 @@ var QueryService = class {
       const offset = pipes.offset ?? 0;
       notes = pipes.limit !== void 0 ? notes.slice(offset, offset + pipes.limit) : notes.slice(offset);
     }
+    const relations = notes.length && (this.pageStore || this.relationStore) ? await this.containersAndPlacements(notes) : void 0;
     return {
       parsed,
       notes,
       blocks: [],
-      ...notes.length && (this.pageStore || this.relationStore) ? { containers: await this.containersForNotes(notes) } : {},
+      ...relations ? { containers: relations.containers, placements: relations.placements } : {},
       stages: { selected: selectedCount, matched: notes.length }
     };
   }
-  /** Highest container per note id: the parent Page from the canonical
-   *  page_notes junction (first link by position) wins; a note with no page
-   *  link stays a standalone Note container. Batched when a relationStore
-   *  is injected — one bundle read per run instead of a link/page read per
-   *  matched note. */
-  async containersForNotes(notes) {
+  /** The container projection and the full placement set per note id.
+   *
+   *  The container is the parent Page from the canonical page_notes junction
+   *  (the primary placement wins); a note with no page link stays a
+   *  standalone Note container. Batched when a relationStore is injected —
+   *  one bundle read per run instead of a link/page read per matched note.
+   *
+   *  The same read resolves EVERY page the note is placed on: the junction
+   *  is many-to-many, so the container is a projection of that set, not the
+   *  set itself. */
+  async containersAndPlacements(notes) {
     const containers = {};
+    const placements = {};
     const bundles = this.relationStore ? await this.relationStore.getBatches([...new Set(notes.map((n) => n.id))]) : void 0;
     const pageCache = /* @__PURE__ */ new Map();
     for (const note of notes) {
-      let page;
       let bundle;
+      let resolved;
       if (bundles) {
         bundle = bundles.get(note.id);
-        const [first] = [...bundle?.links ?? []].sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-        page = first ? bundle.pages.find((p) => p.id === first.pageId) : void 0;
+        resolved = wodWikiCore.resolvePlacements(bundle?.links ?? [], bundle?.pages ?? []);
         if (bundle && bundle.tags.length > 0 && (!note.tags || note.tags.length === 0)) {
           note.tags = bundle.tags.map((t2) => t2.label);
         }
       } else {
         const links = await this.pageStore.getNotePages(note.id);
-        if (links.length > 0) {
-          const [first] = [...links].sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-          if (!pageCache.has(first.pageId)) {
-            pageCache.set(first.pageId, await this.pageStore.getPage(first.pageId));
+        const pages = [];
+        for (const link of links) {
+          if (!pageCache.has(link.pageId)) {
+            pageCache.set(link.pageId, await this.pageStore.getPage(link.pageId));
           }
-          page = pageCache.get(first.pageId);
+          const page = pageCache.get(link.pageId);
+          if (page) pages.push(page);
         }
+        resolved = wodWikiCore.resolvePlacements(links, pages);
       }
-      containers[note.id] = page ? { kind: "page", id: page.id, ...page.slug ? { slug: page.slug } : {}, ...page.date ? { date: page.date } : {} } : { kind: "note", id: note.id };
+      placements[note.id] = resolved;
+      const primary = resolved[0];
+      containers[note.id] = primary ? { kind: "page", id: primary.pageId, ...primary.slug ? { slug: primary.slug } : {}, ...primary.date ? { date: primary.date } : {} } : { kind: "note", id: note.id };
     }
-    return containers;
+    return { containers, placements };
   }
   async hydrateBlocks(rows) {
     const ids = [...new Set(rows.map((row) => row.noteId))];
@@ -3898,20 +3951,9 @@ var QueryService = class {
         blocks = blocks.filter((b) => wanted.has(b.dataType));
       }
     }
-    for (const filter of parsed.filters) {
-      if (filter.key === "catalog") {
-        const wanted = new Set(filter.values.map((v) => v.value));
-        blocks = blocks.filter((b) => {
-          const cat = catalogOfItem(b);
-          if (!cat) return filter.negate;
-          const hit = wanted.has(cat);
-          return filter.negate ? !hit : hit;
-        });
-      }
-    }
     blocks = applyNotebookFilter(blocks, parsed.filters);
     for (const filter of parsed.filters) {
-      if (filter.key === "tags" && !filter.negate) {
+      if (isTagLabelKey(filter.key) && !filter.negate) {
         const matchingNoteIds = /* @__PURE__ */ new Set();
         for (const v of filter.values) {
           const ids = await this.noteStore.getNoteIdsForTag(v.value);
@@ -3961,7 +4003,9 @@ var QueryService = class {
     return { parsed, notes: [], blocks, stages: { selected: selectedCount, matched: blocks.length } };
   }
   /**
-   * Execute a :effort query against the effort registry.
+   * Execute a :effort query: the registry is the filter plane (discipline,
+   * intensity, origin, text), the note plane is the result plane — matched
+   * projections resolve to their owning definition notes.
    */
   async runFindEffort(parsed) {
     const all = await this.effortStore.getAllEfforts();
@@ -4010,7 +4054,17 @@ var QueryService = class {
       const offset = pipes.offset ?? 0;
       efforts = pipes.limit !== void 0 ? efforts.slice(offset, offset + pipes.limit) : efforts.slice(offset);
     }
-    return { parsed, notes: [], blocks: [], efforts, stages: { selected: selectedCount, matched: efforts.length } };
+    const ownerIds = [...new Set(efforts.map((e) => e.ownerNoteId).filter((id) => typeof id === "string" && id.length > 0))];
+    let notes = [];
+    if (ownerIds.length > 0) {
+      const fetched = this.noteStore.getNotesByIds ? await this.noteStore.getNotesByIds(ownerIds) : (await this.noteStore.getAllNotes()).filter((n) => ownerIds.includes(n.id));
+      const byId = new Map(fetched.map((n) => [n.id, n]));
+      notes = ownerIds.flatMap((id) => {
+        const note = byId.get(id);
+        return note ? [note] : [];
+      });
+    }
+    return { parsed, notes, blocks: [], efforts, stages: { selected: selectedCount, matched: efforts.length } };
   }
   async run(parsed, options2 = {}) {
     if (isPipelineQuery(parsed)) {
@@ -4122,6 +4176,7 @@ var QueryService = class {
           ...content.runs?.length ? { runs: content.runs } : {},
           ...content.table ? { table: content.table } : {},
           ...content.containers ? { containers: content.containers } : {},
+          ...content.placements ? { placements: content.placements } : {},
           ...parsed.sink ? { chart: parsed.sink } : {}
         };
       }
@@ -4494,139 +4549,293 @@ var QueryService = class {
     return new Set(links.map((l) => l.noteId));
   }
   /**
-   * Find catalogs: identifies catalogs whose member notes (or catalog landing
-   * notes) match the authored criteria (effort, tags, text, typed tags, etc.).
+   * Execute a :notebook query (ticket 08) — the notebook plane is a NOTE
+   * plane (ticket 05 semantics preserved): bare `:notebook{}` returns the
+   * notes of every notebook — journal, playground, defaults, user-created,
+   * feed-delivered. `notebook:{slug}` narrows to members of those
+   * notebooks and `!notebook:` excludes them; the result shape never
+   * changes with polarity, and container criteria (tags:, effort:, typed
+   * tags, text:) narrow the members exactly like the note plane — this
+   * delegates to it. The notebook CONTAINER listing (the /notebooks
+   * management surface) is the app's NotebookService model, not WQL rows.
    */
-  async runFindCatalog(parsed, options2, allNotes) {
+  async runFindNotebook(parsed, options2 = {}) {
+    return this.runFind({ ...parsed, target: "note" }, options2);
+  }
+  /**
+   * Execute a :page query (ticket 08) — the placement plane. Results are
+   * the placed notes; `placements` carries every page each note sits on
+   * (many-to-many) and `containers` the primary projection. `page:{slug}`
+   * (or a `YYYY-MM-DD` date, or a page id) narrows the placements.
+   */
+  async runFindPage(parsed, options2 = {}) {
+    const empty = { parsed, notes: [], blocks: [], stages: { selected: 0, matched: 0 } };
+    if (!this.pageStore?.getAllPages || !this.pageStore?.getAllLinks) return empty;
     const ctx = runContext(options2);
-    const feedNotes = allNotes.filter((n) => sourceMatches(n, "feeds") || n.catalog && !n.sourceId);
-    let catalogNotes = feedNotes.filter((n) => n.type === "feed" || n.sourceId?.startsWith("page:collection:"));
-    const existingCatIds = new Set(catalogNotes.map((n) => catalogOfItem(n) ?? n.id));
-    for (const n of feedNotes) {
-      const cat = catalogOfItem(n);
-      if (cat && !existingCatIds.has(cat)) {
-        catalogNotes.push({
-          id: cat,
-          title: cat,
-          type: "feed",
-          sourceId: `page:collection:${cat}`,
-          catalog: cat,
-          createdAt: n.createdAt ?? 0,
-          rawContent: "",
-          sourceRevision: 1,
-          blocks: {}
-        });
-        existingCatIds.add(cat);
+    const [pages, links] = await Promise.all([this.pageStore.getAllPages(), this.pageStore.getAllLinks()]);
+    let placements = wodWikiCore.resolvePlacements(links, pages);
+    const selected = new Set(placements.map((p) => p.noteId)).size;
+    for (const filter of parsed.filters) {
+      if (filter.key !== "page") continue;
+      const wanted = new Set(filter.values.map((v) => v.value));
+      placements = placements.filter((p) => {
+        const hit = wanted.has(p.pageId) || p.slug !== void 0 && wanted.has(p.slug) || p.date !== void 0 && wanted.has(p.date);
+        return filter.negate ? !hit : hit;
+      });
+    }
+    const placedIds = [...new Set(placements.map((p) => p.noteId))];
+    let notes = this.noteStore.getNotesByIds ? await this.noteStore.getNotesByIds(placedIds) : (await this.noteStore.getAllNotes()).filter((n) => placedIds.includes(n.id));
+    for (const filter of parsed.filters) {
+      if (filter.key === "note") {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        notes = notes.filter((n) => filter.negate ? !wanted.has(n.id) : wanted.has(n.id));
       }
     }
-    const membersByCat = /* @__PURE__ */ new Map();
-    for (const catNote of catalogNotes) {
-      const catId = catalogOfItem(catNote) ?? catNote.id;
-      membersByCat.set(catId, [catNote]);
-    }
-    for (const n of feedNotes) {
-      const catId = catalogOfItem(n);
-      if (catId) {
-        const list = membersByCat.get(catId);
-        if (list) {
-          if (!list.includes(n)) list.push(n);
-        } else {
-          membersByCat.set(catId, [n]);
-        }
+    for (const filter of parsed.filters) {
+      if (filter.key === "text") {
+        const search = filter.values.map((v) => v.value).join(" ").toLowerCase();
+        notes = notes.filter((n) => {
+          const hit = n.title.toLowerCase().includes(search) || n.rawContent.toLowerCase().includes(search);
+          return filter.negate ? !hit : hit;
+        });
       }
     }
-    const criteriaFilters = parsed.filters.filter(
-      (f) => !(f.key === "source" && !f.negate && f.values.some((v) => v.value === "feeds" || v.value === "feed" || v.value === "notebooks" || v.value === "notebook")) && !(f.key === "type" && !f.negate && f.values.some((v) => v.value === "feed"))
-    );
-    let matchingCatalogs = [...catalogNotes];
-    for (const filter of criteriaFilters) {
-      if (filter.key === "catalog" || filter.key === "notebook") {
-        const wanted = new Set(filter.values.map((v) => wodWikiCore.notebookSlugFromId(v.value)));
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = wodWikiCore.notebookSlugFromId(catalogOfItem(c) ?? c.id);
-          const hit = wanted.has(catId);
+    notes = applyNotebookFilter(notes, parsed.filters);
+    if (parsed.window || options2.range) {
+      notes = notes.filter((n) => effectiveTimeWindow(n.date ?? n.createdAt, parsed.window, options2.range, ctx));
+    }
+    notes = applyOrderAndPage(notes, parsed);
+    const survived = new Set(notes.map((n) => n.id));
+    const byNote = /* @__PURE__ */ new Map();
+    for (const p of placements) {
+      if (!survived.has(p.noteId)) continue;
+      const list = byNote.get(p.noteId);
+      if (list) list.push(p);
+      else byNote.set(p.noteId, [p]);
+    }
+    const containers = {};
+    for (const note of notes) {
+      const primary = byNote.get(note.id)?.[0];
+      containers[note.id] = primary ? { kind: "page", id: primary.pageId, ...primary.slug ? { slug: primary.slug } : {}, ...primary.date ? { date: primary.date } : {} } : { kind: "note", id: note.id };
+    }
+    return {
+      parsed,
+      notes,
+      blocks: [],
+      containers,
+      placements: Object.fromEntries(byNote),
+      stages: { selected, matched: notes.length }
+    };
+  }
+  /**
+   * Execute a :tag query (ticket 08) — the tag plane. Every tag record
+   * surfaces as one synthetic note row, so results are notes end to end.
+   * `tag:{label}` narrows; `type:` narrows by the tag's configured type;
+   * `contributes:` narrows by what a tag contributes (`metric`,
+   * `metric:<type>`, `tag:<slug>`, `function:<name>`) — a contribution is
+   * exposed here, never as a `tags:` label filter. The synthetic row's body
+   * summarizes the contributions so `text:` reaches them too.
+   */
+  async runFindTag(parsed, options2 = {}) {
+    const ctx = runContext(options2);
+    const tags = this.tagsStore.getAll ? await this.tagsStore.getAll() : [];
+    const selected = tags.length;
+    let matched = tags;
+    for (const filter of parsed.filters) {
+      if (isTagLabelKey(filter.key)) {
+        const wanted = new Set(filter.values.map((v) => v.value.toLowerCase()));
+        matched = matched.filter((t2) => {
+          const hit = typeof t2.label === "string" && wanted.has(t2.label.toLowerCase());
           return filter.negate ? !hit : hit;
         });
-      } else if (filter.key === "effort") {
-        const matchingIds = /* @__PURE__ */ new Set();
-        for (const v of filter.values) {
-          const ids = await this.getNoteIdsForEffort(v.value);
-          ids.forEach((id) => matchingIds.add(id));
-        }
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = catalogOfItem(c) ?? c.id;
-          const members = membersByCat.get(catId) ?? [];
-          const hit = members.some((m) => matchingIds.has(m.id));
+      } else if (filter.key === "type") {
+        const wanted = new Set(filter.values.map((v) => v.value));
+        matched = matched.filter((t2) => {
+          const hit = t2.type !== void 0 && wanted.has(t2.type);
           return filter.negate ? !hit : hit;
         });
-      } else if (filter.key === "tags") {
+      } else if (filter.key === "contributes") {
+        matched = matched.filter((t2) => {
+          const hit = (t2.contributions ?? []).some((c) => filter.values.some((v) => tagContributionMatches(c, v.value)));
+          return filter.negate ? !hit : hit;
+        });
+      } else if (filter.key === "text") {
+        const search = filter.values.map((v) => v.value).join(" ").toLowerCase();
+        matched = matched.filter((t2) => filter.negate !== `${t2.label ?? ""} ${tagContributionSummary(t2)}`.toLowerCase().includes(search));
+      }
+    }
+    let rows = matched.map((t2) => ({
+      id: `tag/${typeof t2.type === "string" && t2.type ? t2.type : "general"}/${t2.label}`,
+      title: t2.label,
+      type: "tag",
+      tagType: typeof t2.type === "string" ? t2.type : void 0,
+      contributions: t2.contributions ?? [],
+      createdAt: typeof t2.createdAt === "number" ? t2.createdAt : 0,
+      content: tagContributionSummary(t2),
+      rawContent: tagContributionSummary(t2),
+      sourceRevision: 1,
+      blocks: {}
+    }));
+    if (parsed.window || options2.range) {
+      rows = rows.filter((r) => effectiveTimeWindow(r.createdAt, parsed.window, options2.range, ctx));
+    }
+    rows = applyOrderAndPage(rows, parsed);
+    return { parsed, notes: rows, blocks: [], stages: { selected, matched: rows.length } };
+  }
+  /**
+   * Execute an :equipment query (ticket 08) — the equipment plane. Results
+   * are the equipment notes (the equipment notebook's members, typed
+   * 'equipment' rows included). `equipment:{label}` narrows by the
+   * equipment typed tag ("every equipment note tagged kettlebell" is
+   * `:equipment{equipment:kettlebell}`); `tags:` and `text:` narrow like
+   * the note plane.
+   */
+  async runFindEquipment(parsed, options2 = {}) {
+    const allNotes = await this.noteStore.getAllNotes();
+    const ctx = runContext(options2);
+    let notes = allNotes.filter((n) => notebookOfItem(n) === "notebook/equipment" || n.type === "equipment" || sourceMatches(n, "equipment"));
+    const selected = notes.length;
+    for (const filter of parsed.filters) {
+      if (filter.key === "equipment") {
         const matchingIds = /* @__PURE__ */ new Set();
         for (const v of filter.values) {
-          const ids = await this.noteStore.getNoteIdsForTag(v.value);
-          ids.forEach((id) => matchingIds.add(id));
+          (await this.getNoteIdsForTypedTag("equipment", v.value)).forEach((id) => matchingIds.add(id));
         }
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = catalogOfItem(c) ?? c.id;
-          const members = membersByCat.get(catId) ?? [];
-          const hit = members.some((m) => matchingIds.has(m.id) || m.tags && filter.values.some((v) => m.tags.includes(v.value)));
-          return filter.negate ? !hit : hit;
-        });
-      } else if (WQL_TYPED_TAG_KEYS.includes(filter.key)) {
+        notes = notes.filter((n) => filter.negate ? !matchingIds.has(n.id) : matchingIds.has(n.id));
+      } else if (isTagLabelKey(filter.key) && !filter.negate) {
         const matchingIds = /* @__PURE__ */ new Set();
         for (const v of filter.values) {
-          const ids = await this.getNoteIdsForTypedTag(filter.key, v.value);
-          ids.forEach((id) => matchingIds.add(id));
+          (await this.noteStore.getNoteIdsForTag(v.value)).forEach((id) => matchingIds.add(id));
         }
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = catalogOfItem(c) ?? c.id;
-          const members = membersByCat.get(catId) ?? [];
-          const hit = members.some((m) => matchingIds.has(m.id));
-          return filter.negate ? !hit : hit;
-        });
-      } else if (filter.key === "text") {
+        notes = notes.filter((n) => matchingIds.has(n.id));
+      } else if (isTagLabelKey(filter.key) && filter.negate) {
+        for (const v of filter.values) {
+          const ids = await this.noteStore.getNoteIdsForTag(v.value);
+          notes = notes.filter((n) => !ids.has(n.id));
+        }
+      }
+    }
+    for (const filter of parsed.filters) {
+      if (filter.key === "text") {
         const search = filter.values.map((v) => v.value).join(" ").toLowerCase();
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = catalogOfItem(c) ?? c.id;
-          const members = membersByCat.get(catId) ?? [];
-          const hit = members.some((m) => m.title.toLowerCase().includes(search) || m.rawContent.toLowerCase().includes(search));
-          return filter.negate ? !hit : hit;
-        });
-      } else if (filter.key === "note") {
-        const wanted = new Set(filter.values.map((v) => v.value));
-        matchingCatalogs = matchingCatalogs.filter((c) => {
-          const catId = catalogOfItem(c) ?? c.id;
-          const members = membersByCat.get(catId) ?? [];
-          const hit = members.some((m) => wanted.has(m.id));
+        notes = notes.filter((n) => {
+          const hit = n.title.toLowerCase().includes(search) || n.rawContent.toLowerCase().includes(search);
           return filter.negate ? !hit : hit;
         });
       }
     }
+    notes = applyNotebookFilter(notes, parsed.filters);
     if (parsed.window || options2.range) {
-      matchingCatalogs = matchingCatalogs.filter((c) => {
-        const catId = catalogOfItem(c) ?? c.id;
-        const members = membersByCat.get(catId) ?? [];
-        return members.some((m) => effectiveTimeWindow(m.date ?? m.createdAt, parsed.window, options2.range, ctx));
-      });
-    }
-    if (parsed.pipes?.order) {
-      for (const order of [...parsed.pipes.order].reverse()) {
-        const dir = order.dir === "desc" ? -1 : 1;
-        matchingCatalogs = [...matchingCatalogs].sort((a, b) => {
-          const av = a[order.col] ?? "";
-          const bv = b[order.col] ?? "";
-          if (av === bv) return 0;
-          return (av > bv ? 1 : -1) * dir;
-        });
-      }
+      notes = notes.filter((n) => effectiveTimeWindow(n.date ?? n.createdAt, parsed.window, options2.range, ctx));
     }
-    return {
-      parsed,
-      notes: matchingCatalogs,
-      blocks: [],
-      stages: { selected: catalogNotes.length, matched: matchingCatalogs.length }
-    };
+    notes = applyOrderAndPage(notes, parsed);
+    return { parsed, notes, blocks: [], stages: { selected, matched: notes.length } };
   }
 };
+function applyOrderAndPage(rows, parsed) {
+  let out = rows;
+  if (parsed.pipes?.order) {
+    for (const order of [...parsed.pipes.order].reverse()) {
+      const dir = order.dir === "desc" ? -1 : 1;
+      out = [...out].sort((a, b) => {
+        const av = a[order.col] ?? "";
+        const bv = b[order.col] ?? "";
+        if (av === bv) return 0;
+        return (av > bv ? 1 : -1) * dir;
+      });
+    }
+  }
+  const pipes = parsed.pipes;
+  if (pipes && (pipes.limit !== void 0 || (pipes.offset ?? 0) > 0)) {
+    const offset = pipes.offset ?? 0;
+    out = pipes.limit !== void 0 ? out.slice(offset, offset + pipes.limit) : out.slice(offset);
+  }
+  return out;
+}
+function isTagLabelKey(key) {
+  return key === "tags" || key === "tag";
+}
+function tagContributionMatches(contribution, value) {
+  const sep = value.indexOf(":");
+  const kind = sep === -1 ? value : value.slice(0, sep);
+  const qualifier = sep === -1 ? "" : value.slice(sep + 1);
+  if (contribution.kind !== kind) return false;
+  if (!qualifier) return true;
+  if (contribution.kind === "metric") return contribution.type === qualifier;
+  if (contribution.kind === "tag") return contribution.slug === qualifier;
+  return contribution.name === qualifier;
+}
+function tagContributionSummary(tag) {
+  const parts = (tag.contributions ?? []).map((c) => c.kind === "metric" ? `metric ${c.type}` : c.kind === "tag" ? `tag ${c.slug}` : `function ${c.name}`);
+  return parts.length ? `contributes ${parts.join(", ")}` : "";
+}
+
+// src/notebookVocabulary.ts
+function migrateLegacyChunkId(chunkId) {
+  if (chunkId.startsWith("collection.")) return `notebook.${chunkId.slice("collection.".length)}`;
+  if (chunkId.startsWith("feed.")) return `notebook.${chunkId.slice("feed.".length)}`;
+  return chunkId;
+}
+function migrateLegacySourcePath(path) {
+  if (path.startsWith("markdown/collections/")) return `markdown/notebooks/${path.slice("markdown/collections/".length)}`;
+  if (path.startsWith("markdown/feeds/")) return `markdown/notebooks/${path.slice("markdown/feeds/".length)}`;
+  return path;
+}
+function migrateLegacySourceId(sourceId) {
+  if (sourceId.startsWith("page:collection:")) return `page:${sourceId.slice("page:collection:".length)}`;
+  if (sourceId.startsWith("collection:")) return `notebook:${sourceId.slice("collection:".length)}`;
+  if (sourceId.startsWith("feed:")) {
+    return `notebook:${sourceId.slice("feed:".length).replace(/^feeds\//, "")}`;
+  }
+  return sourceId;
+}
+function migrateLegacyRouteId(routeId) {
+  return routeId.startsWith("feeds/") ? routeId.slice("feeds/".length) : routeId;
+}
+function migrateLegacyRow(row) {
+  let next = row;
+  const apply = (patch) => {
+    next = { ...next, ...patch };
+  };
+  const sourceId = row["sourceId"];
+  if (typeof sourceId === "string") {
+    const migrated = migrateLegacySourceId(sourceId);
+    if (migrated !== sourceId) apply({ sourceId: migrated });
+  }
+  const sourcePath = row["sourcePath"];
+  if (typeof sourcePath === "string") {
+    const migrated = migrateLegacySourcePath(sourcePath);
+    if (migrated !== sourcePath) apply({ sourcePath: migrated });
+  }
+  const seedChunkId = row["seedChunkId"];
+  if (typeof seedChunkId === "string") {
+    const migrated = migrateLegacyChunkId(seedChunkId);
+    if (migrated !== seedChunkId) apply({ seedChunkId: migrated });
+  }
+  const routeId = row["routeId"];
+  if (typeof routeId === "string") {
+    const migrated = migrateLegacyRouteId(routeId);
+    if (migrated !== routeId) apply({ routeId: migrated });
+  }
+  if ("catalog" in next) {
+    next = { ...next };
+    delete next["catalog"];
+  }
+  if (next["type"] === "feed") apply({ type: "note" });
+  return next;
+}
+function hasLegacyIdentity(row) {
+  const sourceId = row["sourceId"];
+  if (typeof sourceId === "string" && (/^(collection|feed):/.test(sourceId) || sourceId.startsWith("page:collection:"))) return true;
+  const sourcePath = row["sourcePath"];
+  if (typeof sourcePath === "string" && (sourcePath.startsWith("markdown/collections/") || sourcePath.startsWith("markdown/feeds/"))) return true;
+  const seedChunkId = row["seedChunkId"];
+  if (typeof seedChunkId === "string" && /^(collection|feed)\./.test(seedChunkId)) return true;
+  const routeId = row["routeId"];
+  if (typeof routeId === "string" && routeId.startsWith("feeds/")) return true;
+  if ("catalog" in row || row["type"] === "feed") return true;
+  return false;
+}
 
 // src/dashboard/model.ts
 var DASHBOARD_WIDGET_TYPES = [
@@ -5269,13 +5478,13 @@ ${query}
 }
 
 // src/version.ts
-var VERSION = "0.44.2159";
-var GIT_SHA = "30e43c7";
-var BUILD_TIME = "2026-10-24T23:07:22.311Z";
+var VERSION = "0.45.2166";
+var GIT_SHA = "32bda10";
+var BUILD_TIME = "2026-10-26T20:01:09.868Z";
 var SEMVER = {
-  version: "0.44.2159",
-  gitSha: "30e43c7",
-  buildTime: "2026-10-24T23:07:22.311Z"
+  version: "0.45.2166",
+  gitSha: "32bda10",
+  buildTime: "2026-10-26T20:01:09.868Z"
 };
 
 Object.defineProperty(exports, "DEFAULT_NOTEBOOK_SLUGS", {
@@ -5331,6 +5540,7 @@ exports.PageSourceRegistry = PageSourceRegistry;
 exports.QueryDocumentRunner = QueryDocumentRunner;
 exports.QueryService = QueryService;
 exports.SEMVER = SEMVER;
+exports.SOURCE_ID_SHAPES = SOURCE_ID_SHAPES;
 exports.SharedQueryDocumentRunner = QueryDocumentRunner2;
 exports.UNASSIGNED = UNASSIGNED;
 exports.VERSION = VERSION;
@@ -5350,6 +5560,7 @@ exports.WQL_KEYWORDS = WQL_KEYWORDS;
 exports.WQL_METRIC_AGGREGATES = WQL_METRIC_AGGREGATES;
 exports.WQL_METRIC_FAMILIES = WQL_METRIC_FAMILIES;
 exports.WQL_NOTE_DEFAULT_SOURCES = WQL_NOTE_DEFAULT_SOURCES;
+exports.WQL_NOTE_HEAD_ALIASES = WQL_NOTE_HEAD_ALIASES;
 exports.WQL_RESULT_PLANES = WQL_RESULT_PLANES;
 exports.WQL_ROLLUP_PERIODS = WQL_ROLLUP_PERIODS;
 exports.WQL_SOURCES = WQL_SOURCES;
@@ -5368,7 +5579,6 @@ exports.buildDashboardDocument = buildDashboardDocument;
 exports.buildDashboardScaffold = buildDashboardScaffold;
 exports.buildDrillDownQuery = buildDrillDownQuery;
 exports.captureContext = captureContext;
-exports.catalogOfItem = catalogOfItem;
 exports.civilDateAdd = civilDateAdd;
 exports.civilDateDiff = civilDateDiff;
 exports.civilDateOf = civilDateOf;
@@ -5384,10 +5594,12 @@ exports.duplicateWidget = duplicateWidget;
 exports.eventsToStoredLogs = eventsToStoredLogs;
 exports.extractDashboardTokens = extractDashboardTokens;
 exports.extractFrontmatterTags = extractFrontmatterTags;
+exports.feedOfItem = feedOfItem;
 exports.findTargetAdvisories = findTargetAdvisories;
 exports.getList = getList;
 exports.getScalar = getScalar;
 exports.getUnitFamily = getUnitFamily;
+exports.hasLegacyIdentity = hasLegacyIdentity;
 exports.inRange = inRange;
 exports.isAggregateQuery = isAggregateQuery;
 exports.isDashboardMeta = isDashboardMeta;
@@ -5396,11 +5608,18 @@ exports.isEffortDiscipline = isEffortDiscipline;
 exports.isFindQuery = isFindQuery;
 exports.isPipelineQuery = isPipelineQuery;
 exports.isProposedMetric = isProposedMetric;
+exports.migrateLegacyChunkId = migrateLegacyChunkId;
 exports.migrateLegacyDashboardBodies = migrateLegacyDashboardBodies;
+exports.migrateLegacyRouteId = migrateLegacyRouteId;
+exports.migrateLegacyRow = migrateLegacyRow;
+exports.migrateLegacySourceId = migrateLegacySourceId;
+exports.migrateLegacySourcePath = migrateLegacySourcePath;
 exports.moveWidget = moveWidget;
 exports.normalizeSummaryFacts = normalizeSummaryFacts;
 exports.normalizeWql = normalizeWql;
 exports.notebookOfItem = notebookOfItem;
+exports.notebookOriginOfItem = notebookOriginOfItem;
+exports.notebookSlugOfSourceId = notebookSlugOfSourceId;
 exports.parseDashboardNote = parseDashboardNote;
 exports.parseDocument = parseDocument;
 exports.parseFlatProperties = parseFlatProperties;
@@ -5426,6 +5645,7 @@ exports.serializeDocument = serializeDocument;
 exports.serializeFrontmatter = serializeFrontmatter;
 exports.setDashboardTokenValue = setDashboardTokenValue;
 exports.sourceMatches = sourceMatches;
+exports.sourceShape = sourceShape;
 exports.splitAtWhere = splitAtWhere;
 exports.stripFrontmatter = stripFrontmatter;
 exports.substituteTokens = substituteTokens2;