@batalabs/virlow-mcp-core 3.19.0 → 3.68.0

package/dist/cjs/attrs.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_MAX_BYTES = exports.ATTRS_MAX_BYTES = exports.TAGS_PROP = exports.CREATED = exports.LAST_CHANGED = exports.HOME_PRESET_LABELS = exports.HOME_PRESETS = exports.DEFAULT_HOME_WIDGETS = exports.HOME_SUMMARY_MAX = exports.HOME_TEXT_MAX = exports.HOME_TITLE_MAX = exports.PINNED_MAX = void 0;
+exports.isPropertyFilter = isPropertyFilter;
+exports.matchesFilter = matchesFilter;
+exports.matchesAll = matchesAll;
+exports.isHomeSort = isHomeSort;
+exports.spanOf = spanOf;
+exports.isHomeWidget = isHomeWidget;
+exports.withHomeWidgets = withHomeWidgets;
+exports.newWidgetId = newWidgetId;
+exports.homeWidgets = homeWidgets;
+exports.isHomePreset = isHomePreset;
+exports.presetWidgets = presetWidgets;
+exports.isPinned = isPinned;
+exports.withPinToggled = withPinToggled;
+exports.isNoteDate = isNoteDate;
+exports.formatProp = formatProp;
+exports.emptyAttrs = emptyAttrs;
+exports.emptySchema = emptySchema;
+exports.newPropId = newPropId;
+exports.sortedProps = sortedProps;
+exports.defineProp = defineProp;
+exports.updateProp = updateProp;
+exports.removeProp = removeProp;
+exports.reorderProps = reorderProps;
+exports.encodeAttrs = encodeAttrs;
+exports.decodeAttrs = decodeAttrs;
+exports.encodeSchema = encodeSchema;
+exports.decodeSchema = decodeSchema;
+exports.tagsFromAttrs = tagsFromAttrs;
+exports.withTags = withTags;
+const virlow_crypto_1 = require("@batalabs/virlow-crypto");
+const FILTER_OPS = ['is', 'has', 'checked', 'unchecked', 'empty', 'notEmpty'];
+function isPropertyFilter(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.propId !== 'string' || value.propId === '')
+        return false;
+    if (!FILTER_OPS.includes(value.op))
+        return false;
+    if (value.op === 'is' || value.op === 'has')
+        return typeof value.value === 'string';
+    return value.value === undefined;
+}
+/** Whether a value counts as absent. An empty string and an empty list read as
+ *  nothing to the person looking at the row, so they filter as nothing too. */
+function isEmptyValue(value) {
+    if (value === undefined)
+        return true;
+    switch (value.t) {
+        case 'text':
+        case 'url':
+        case 'select':
+        case 'date':
+            return value.v === '';
+        case 'multiSelect':
+        case 'relation':
+            return value.v.length === 0;
+        case 'number':
+            return Number.isNaN(value.v);
+        case 'checkbox':
+            // A checkbox is never absent: false is an answer, not a blank.
+            return false;
+        default:
+            return true;
+    }
+}
+function matchesFilter(attrs, filter) {
+    const value = attrs?.props[filter.propId];
+    switch (filter.op) {
+        case 'is':
+            return value?.t === 'select' && value.v === filter.value;
+        case 'has':
+            return value?.t === 'multiSelect' && value.v.includes(filter.value);
+        case 'checked':
+            return value?.t === 'checkbox' && value.v === true;
+        case 'unchecked':
+            // Unticked and never touched are the same thing to the reader, so a note
+            // with no value for the box counts as unchecked rather than dropping out
+            // of both halves of the filter.
+            return value === undefined || (value.t === 'checkbox' && value.v === false);
+        case 'empty':
+            return isEmptyValue(value);
+        case 'notEmpty':
+            return !isEmptyValue(value);
+        default:
+            return true;
+    }
+}
+/** Every filter passes. Filters across different properties are an AND: each
+ *  one narrows what the last one left, which is what picking two of them from
+ *  a menu looks like it should do. */
+function matchesAll(attrs, filters) {
+    return (filters ?? []).every((filter) => matchesFilter(attrs, filter));
+}
+function isHomeSort(value) {
+    return (isRecord(value) &&
+        typeof value.by === 'string' &&
+        value.by !== '' &&
+        (value.dir === 'asc' || value.dir === 'desc'));
+}
+const PINNED_LOOKS = ['list', 'notes'];
+/** The most notes one pinned block holds. Past this it is a listing, and a
+ *  table with a filter is the block for a listing. */
+exports.PINNED_MAX = 50;
+/** The longest a table block's title may be: a heading, not a description. */
+exports.HOME_TITLE_MAX = 60;
+/** The longest a `text` widget may be. A home is a surface, not a document;
+ *  anything longer belongs in a note. */
+exports.HOME_TEXT_MAX = 280;
+/** The longest a `summary` may be. Room for a paragraph or two of context,
+ *  and short of the point where the dashboard becomes a document. */
+exports.HOME_SUMMARY_MAX = 2000;
+const HOME_KINDS = [
+    'counts',
+    'recent',
+    'starred',
+    'breakdown',
+    'upcoming',
+    'text',
+    'summary',
+    'table',
+    'calendar',
+    'board',
+    'activity',
+    'stale',
+    'tasks',
+    'pinned',
+    'quick',
+];
+const SPANS = ['half', 'full'];
+/**
+ * A block's width when it has not been given one.
+ *
+ * A table's columns and a month grid need the room; a stat row and a short
+ * list do not, and pairing them is what makes the page read as a dashboard
+ * rather than a column of cards.
+ */
+const DEFAULT_SPAN = {
+    counts: 'half',
+    recent: 'half',
+    starred: 'half',
+    breakdown: 'half',
+    upcoming: 'half',
+    text: 'full',
+    summary: 'full',
+    table: 'full',
+    calendar: 'full',
+    board: 'full',
+    activity: 'half',
+    stale: 'half',
+    tasks: 'half',
+    pinned: 'half',
+    quick: 'full',
+};
+function spanOf(widget) {
+    return widget.span ?? DEFAULT_SPAN[widget.kind] ?? 'half';
+}
+/** True for a block this build can draw. Exported so the MCP layer can refuse
+ *  one at the tool boundary rather than writing it and skipping it on read. */
+function isHomeWidget(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string')
+        return false;
+    if (!HOME_KINDS.includes(value.kind))
+        return false;
+    // An unknown span is dropped rather than rendered at some guessed width.
+    if (value.span !== undefined && !SPANS.includes(value.span))
+        return false;
+    if (value.kind === 'breakdown' ||
+        value.kind === 'upcoming' ||
+        value.kind === 'calendar' ||
+        value.kind === 'board') {
+        return typeof value.propId === 'string';
+    }
+    if (value.kind === 'table' || value.kind === 'tasks') {
+        // A malformed filter is refused rather than ignored: a table that silently
+        // shows everything is wrong in the way that is hardest to notice.
+        if (value.filters !== undefined) {
+            if (!Array.isArray(value.filters) || !value.filters.every(isPropertyFilter))
+                return false;
+        }
+        if (value.kind === 'table') {
+            if (value.sort !== undefined && !isHomeSort(value.sort))
+                return false;
+            if (value.title !== undefined) {
+                if (typeof value.title !== 'string' || value.title.length > exports.HOME_TITLE_MAX)
+                    return false;
+            }
+        }
+        return true;
+    }
+    if (value.kind === 'pinned') {
+        if (!Array.isArray(value.noteIds) ||
+            value.noteIds.length > exports.PINNED_MAX ||
+            !value.noteIds.every((id) => typeof id === 'string' && id !== ''))
+            return false;
+        if (value.look !== undefined && !PINNED_LOOKS.includes(value.look))
+            return false;
+        if (value.colors !== undefined) {
+            if (!isRecord(value.colors))
+                return false;
+            if (!Object.values(value.colors).every((c) => typeof c === 'string' && c.length <= 24))
+                return false;
+        }
+        return true;
+    }
+    if (value.kind === 'text')
+        return typeof value.body === 'string';
+    if (value.kind === 'summary') {
+        if (typeof value.body !== 'string')
+            return false;
+        return value.at === undefined || typeof value.at === 'string';
+    }
+    return true;
+}
+/**
+ * What a workspace shows when nobody has arranged its home.
+ *
+ * A default rather than an empty screen: a workspace should be worth opening
+ * the first time, and these three need no configuration to mean something.
+ */
+exports.DEFAULT_HOME_WIDGETS = [
+    { id: 'default-counts', kind: 'counts' },
+    { id: 'default-recent', kind: 'recent', limit: 5 },
+    { id: 'default-starred', kind: 'starred', limit: 5 },
+];
+/**
+ * The widgets to draw, dropping any this build cannot read.
+ *
+ * Mirrors sortedProps: a newer client may write a kind this one does not
+ * know, and the right answer is to skip it rather than to throw away the
+ * whole home or crash rendering it.
+ */
+/**
+ * A home with `widgets` written out in full.
+ *
+ * The first edit to a workspace that has never been arranged has to write the
+ * defaults down alongside the change. Otherwise removing a default block does
+ * nothing: homeWidgets would see an empty list, fall back, and put it
+ * straight back. Materialising turns "no opinion" into "this arrangement",
+ * which is what an edit means.
+ */
+function withHomeWidgets(schema, widgets) {
+    return { ...schema, home: { ...schema.home, widgets } };
+}
+/** A widget id that will not collide with another in the same home. */
+function newWidgetId() {
+    const bytes = crypto.getRandomValues(new Uint8Array(6));
+    return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function homeWidgets(schema, 
+/** The workspace's properties. Given them, an unarranged home leads with a
+ *  calendar when there is a date property to place notes on. Omitted, the
+ *  default is the plain three, which is what a caller with no schema to
+ *  hand should get. */
+defs) {
+    const configured = schema?.home?.widgets;
+    if (!Array.isArray(configured))
+        return defaultWidgets(defs);
+    const known = configured.filter(isHomeWidget);
+    return known.length > 0 ? known : defaultWidgets(defs);
+}
+/**
+ * What an unarranged workspace shows.
+ *
+ * A calendar first: dates are what people open a workspace to see, and a
+ * month grid answers "what is happening here" in a way three counts cannot.
+ */
+function defaultWidgets(defs) {
+    // A workspace's own date property when it has one, and otherwise the notes'
+    // edit times, so every workspace opens on a calendar rather than only the
+    // ones that have been configured.
+    const date = defs?.find((def) => def.type === 'date');
+    return [
+        {
+            id: 'default-calendar',
+            kind: 'calendar',
+            propId: date ? date.id : exports.LAST_CHANGED,
+        },
+        ...exports.DEFAULT_HOME_WIDGETS,
+    ];
+}
+/**
+ * Starting arrangements.
+ *
+ * An empty page is where most people stall: every block exists, and none of
+ * them says which six to put together for a project. A preset is that
+ * answer written down, built from the workspace's own properties where it
+ * has them (a board wants a select, a calendar wants a date) and from the
+ * notes' own dates where it does not, so every preset draws something on
+ * the workspace it is applied to. Applying one replaces the arrangement,
+ * and the one it replaced is kept for undo like any other change.
+ */
+exports.HOME_PRESETS = ['project', 'research', 'journal'];
+exports.HOME_PRESET_LABELS = {
+    project: {
+        name: 'Project',
+        blurb: 'Open tasks, a board by stage, a calendar, and what has gone quiet.',
+    },
+    research: {
+        name: 'Research',
+        blurb: 'Pinned sources, the latest additions, and a calendar of when things arrived.',
+    },
+    journal: {
+        name: 'Journal',
+        blurb: 'This week, recent entries, open tasks, and how often you write.',
+    },
+};
+function isHomePreset(value) {
+    return exports.HOME_PRESETS.includes(value);
+}
+function presetWidgets(preset, defs = [], id = newWidgetId) {
+    const select = defs.find((d) => d.type === 'select');
+    const date = defs.find((d) => d.type === 'date');
+    switch (preset) {
+        case 'project':
+            return [
+                { id: id(), kind: 'tasks', limit: 10, span: 'half' },
+                { id: id(), kind: 'counts', span: 'half' },
+                select
+                    ? { id: id(), kind: 'board', propId: select.id, span: 'full' }
+                    : { id: id(), kind: 'table', limit: 10, span: 'full' },
+                { id: id(), kind: 'calendar', propId: date ? date.id : exports.LAST_CHANGED, span: 'full' },
+                { id: id(), kind: 'pinned', noteIds: [], look: 'notes', span: 'half' },
+                { id: id(), kind: 'stale', days: 30, limit: 5, span: 'half' },
+            ];
+        case 'research':
+            return [
+                { id: id(), kind: 'pinned', noteIds: [], look: 'notes', span: 'half' },
+                { id: id(), kind: 'recent', limit: 10, span: 'half' },
+                {
+                    id: id(),
+                    kind: 'table',
+                    title: 'Latest additions',
+                    limit: 10,
+                    sort: { by: exports.CREATED, dir: 'desc' },
+                    span: 'full',
+                },
+                select
+                    ? { id: id(), kind: 'breakdown', propId: select.id, span: 'half' }
+                    : { id: id(), kind: 'activity', weeks: 12, span: 'half' },
+                { id: id(), kind: 'tasks', limit: 10, span: 'half' },
+                { id: id(), kind: 'calendar', propId: exports.CREATED, span: 'full' },
+            ];
+        case 'journal':
+            return [
+                { id: id(), kind: 'quick', span: 'full' },
+                { id: id(), kind: 'calendar', propId: exports.LAST_CHANGED, range: 'week', span: 'full' },
+                { id: id(), kind: 'recent', limit: 7, span: 'half' },
+                { id: id(), kind: 'tasks', limit: 10, span: 'half' },
+                { id: id(), kind: 'activity', weeks: 26, span: 'half' },
+                { id: id(), kind: 'stale', days: 14, limit: 5, span: 'half' },
+            ];
+        default:
+            return defaultWidgets(defs);
+    }
+}
+/** True when a note is on one of this home's Pinned blocks. */
+function isPinned(schema, noteId) {
+    return homeWidgets(schema).some((w) => w.kind === 'pinned' && w.noteIds.includes(noteId));
+}
+/**
+ * Pins a note to a workspace's home, or unpins it: what "Pin to dashboard" in
+ * a note's menu writes.
+ *
+ * Unpinning takes the note off every Pinned block it is on. Pinning puts it
+ * on the first block with room, and when the home has no Pinned block yet it
+ * adds one, as sticky notes, at the top: pinning from a note is a request to
+ * see it on the dashboard, and a pin into a block nobody can see is not that.
+ * An unarranged home is written out as its defaults plus the new block, so
+ * nothing already on it disappears.
+ *
+ * Null when every Pinned block is full, which the caller has to say.
+ */
+function withPinToggled(schema, defs, noteId) {
+    const widgets = homeWidgets(schema, defs);
+    if (isPinned(schema, noteId)) {
+        return withHomeWidgets(schema, widgets.map((w) => w.kind === 'pinned' && w.noteIds.includes(noteId)
+            ? { ...w, noteIds: w.noteIds.filter((id) => id !== noteId) }
+            : w));
+    }
+    const target = widgets.find((w) => w.kind === 'pinned' && w.noteIds.length < exports.PINNED_MAX);
+    if (target) {
+        return withHomeWidgets(schema, widgets.map((w) => w === target && w.kind === 'pinned'
+            ? { ...w, noteIds: [...w.noteIds, noteId] }
+            : w));
+    }
+    if (widgets.some((w) => w.kind === 'pinned'))
+        return null;
+    return withHomeWidgets(schema, [
+        { id: newWidgetId(), kind: 'pinned', noteIds: [noteId], look: 'notes' },
+        ...widgets,
+    ]);
+}
+/**
+ * The reserved property id meaning "place notes by when they last changed".
+ *
+ * Not a property: it is a fact every note already carries. A calendar could
+ * previously only be drawn by a workspace that had defined a date property,
+ * which made "calendar by default" false for exactly the workspaces that had
+ * never set anything up, which is most of them at the point somebody first
+ * opens a dashboard. A calendar of when you last touched things needs no
+ * setup and answers a real question.
+ *
+ * A calendar in this mode is read only: you cannot decide when a note was
+ * last edited.
+ */
+exports.LAST_CHANGED = '@lastChanged';
+/**
+ * The reserved property id meaning "place notes by when they were created".
+ *
+ * The other half of the same idea as LAST_CHANGED. They answer different
+ * questions and people want both: what have I touched lately, and what did I
+ * start when. Neither needs a workspace to have defined anything, and neither
+ * can be dragged, because you cannot decide when a note came into existence.
+ */
+exports.CREATED = '@created';
+/** True for the built-in date sources, which come from the note itself rather
+ *  than from a property somebody defined. */
+function isNoteDate(propId) {
+    return propId === exports.LAST_CHANGED || propId === exports.CREATED;
+}
+/** The reserved property id that carries what used to be the plaintext tags column. */
+exports.TAGS_PROP = 'tags';
+/** Matches the server's cap on the encrypted attrs blob (HTTP 413
+ * `ATTRS_TOO_LARGE`), measured as UTF-8 bytes of the ciphertext string. The
+ * single source of truth for both mcp-core (notes.ts) and the web app
+ * (src/lib/attrs/next.ts), so the two never drift apart. */
+exports.ATTRS_MAX_BYTES = 16384;
+/** Matches the server's cap on the encrypted folder schema blob (HTTP 413
+ * `SCHEMA_TOO_LARGE`), measured as UTF-8 bytes of the ciphertext string. Lives
+ * beside ATTRS_MAX_BYTES for the same reason: mcp-core (notes.ts) and the web
+ * app (src/hooks/useFolderSchema.ts) both refuse an oversize blob before
+ * sending it, and two copies of the number would eventually disagree. */
+exports.SCHEMA_MAX_BYTES = 32768;
+const DATE = new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+function day(value) {
+    // Date-only strings are parsed as UTC; formatting them in the local zone
+    // would show the day before for anyone west of Greenwich.
+    const iso = /^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T12:00:00Z` : value;
+    const parsed = new Date(iso);
+    return Number.isNaN(parsed.getTime()) ? '' : DATE.format(parsed);
+}
+function formatProp(def, value) {
+    if (!value)
+        return '';
+    switch (value.t) {
+        case 'text':
+        case 'url':
+            return value.v;
+        case 'number':
+            return String(value.v);
+        case 'checkbox':
+            return value.v ? 'Yes' : 'No';
+        case 'date':
+            return value.end ? `${day(value.v)} to ${day(value.end)}` : day(value.v);
+        case 'select':
+            return def.options?.find((o) => o.id === value.v)?.name ?? '';
+        case 'multiSelect':
+            return value.v.map((id) => def.options?.find((o) => o.id === id)?.name).filter(Boolean).join(', ');
+        case 'relation':
+            return value.v.length === 1 ? '1 note' : `${value.v.length} notes`;
+        default:
+            return '';
+    }
+}
+function emptyAttrs(now = new Date().toISOString()) {
+    return { v: 1, props: {}, links: [], mentions: [], updated: now };
+}
+function emptySchema() {
+    return { v: 1, properties: [], views: { default: 'list' } };
+}
+const PROP_TYPES = ['text', 'number', 'select', 'multiSelect', 'date', 'checkbox', 'url', 'relation'];
+/** 12 hex characters, enough entropy that two properties never collide. */
+function newPropId() {
+    const bytes = crypto.getRandomValues(new Uint8Array(6));
+    return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function isPropDefinition(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        typeof value.name === 'string' &&
+        PROP_TYPES.includes(value.type) &&
+        typeof value.order === 'number');
+}
+/** Definitions in display order. Unknown shapes are dropped rather than
+ * thrown on: a newer client may write a type this one does not know. */
+function sortedProps(schema) {
+    const list = Array.isArray(schema?.properties) ? schema.properties : [];
+    return list
+        .filter(isPropDefinition)
+        .slice()
+        .sort((a, b) => a.order - b.order);
+}
+/**
+ * Everything in `properties` that `sortedProps` drops: an entry whose type
+ * this build does not know, or whose shape it cannot read. A newer client
+ * writes those, and this one must hand them back untouched.
+ *
+ * Every mutator below rebuilds `properties`, and rebuilding it from
+ * `sortedProps` alone deleted these: renaming one property in the web app
+ * silently destroyed a property the desktop build had defined. The same vault
+ * is edited by three clients, and `setProperties` already keeps unknown attrs
+ * fields, so dropping them here made the codec disagree with itself.
+ *
+ * They are re-appended at the end and never renumbered. Their `order` belongs
+ * to a definition this build cannot read, and rewriting it would be guessing.
+ */
+function unreadableProps(schema) {
+    const list = Array.isArray(schema?.properties) ? schema.properties : [];
+    return list.filter((p) => !isPropDefinition(p));
+}
+/** The id an entry carries, whether or not this build can read the rest of
+ * it, so an explicit remove can still find it. */
+function idOf(prop) {
+    const id = prop.id;
+    return typeof id === 'string' ? id : undefined;
+}
+/** Appends a new property definition, assigning it a fresh id (unless one is
+ * given) and an order past the current last property. Never mutates schema. */
+function defineProp(schema, def) {
+    const props = sortedProps(schema);
+    const last = props[props.length - 1];
+    const order = last === undefined ? 0 : last.order + 1;
+    const { id, ...rest } = def;
+    return { ...schema, properties: [...props, { ...rest, id: id ?? newPropId(), order }, ...unreadableProps(schema)] };
+}
+/** Patches a property definition by id, keeping its id fixed regardless of
+ * what the patch contains. Never mutates schema. */
+function updateProp(schema, id, patch) {
+    return {
+        ...schema,
+        properties: [
+            ...sortedProps(schema).map((p) => (p.id === id ? { ...p, ...patch, id: p.id } : p)),
+            // Never patched: a patch is written against a type this build knows,
+            // and applying it to a definition it cannot read would corrupt it.
+            ...unreadableProps(schema),
+        ],
+    };
+}
+/** Removes a property definition by id. Never mutates schema. */
+function removeProp(schema, id) {
+    return {
+        ...schema,
+        properties: [
+            ...sortedProps(schema).filter((p) => p.id !== id),
+            // Keeping the unreadable ones is about not deleting them by accident.
+            // A remove naming that id is not an accident, so it takes effect.
+            ...unreadableProps(schema).filter((p) => idOf(p) !== id),
+        ],
+    };
+}
+/** Reassigns order so the definitions match orderedIds; any definition whose
+ * id is not in the list keeps its relative position after the known ones.
+ * Never mutates schema. */
+function reorderProps(schema, orderedIds) {
+    const props = sortedProps(schema);
+    const rank = new Map(orderedIds.map((id, i) => [id, i]));
+    const next = props
+        .slice()
+        .sort((a, b) => (rank.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (rank.get(b.id) ?? Number.MAX_SAFE_INTEGER))
+        .map((p, i) => ({ ...p, order: i }));
+    return { ...schema, properties: [...next, ...unreadableProps(schema)] };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((x) => typeof x === 'string') : [];
+}
+/**
+ * The type says v: 1, but a blob written by a future client may carry a
+ * higher version number. That numeric value is preserved on purpose, not
+ * downgraded, so a round trip through this reader does not lose it; only a
+ * missing or non-numeric v falls back to 1. The cast is needed because the
+ * field's declared type is the literal 1, not number.
+ */
+function decodedVersion(r) {
+    return (typeof r.v === 'number' && Number.isFinite(r.v) ? r.v : 1);
+}
+/** Normalize a decoded object into a NoteAttrsV1, keeping unknown fields. */
+function asAttrs(raw) {
+    const r = isRecord(raw) ? raw : {};
+    return {
+        ...r,
+        v: decodedVersion(r),
+        props: isRecord(r.props) ? r.props : {},
+        links: stringArray(r.links),
+        mentions: stringArray(r.mentions),
+        ...(r.aliases !== undefined ? { aliases: stringArray(r.aliases) } : {}),
+        updated: typeof r.updated === 'string' ? r.updated : new Date(0).toISOString(),
+    };
+}
+function asSchema(raw) {
+    const r = isRecord(raw) ? raw : {};
+    const views = isRecord(r.views) ? r.views : {};
+    const def = views.default;
+    // 'home' was briefly one of these. It is not a way of listing notes, so it
+    // moved to the editor pane and out of this union; a workspace saved as
+    // 'home' by that build clamps to 'list' here rather than rendering nothing.
+    const allowed = ['list', 'table', 'board', 'calendar'];
+    return {
+        ...r,
+        v: decodedVersion(r),
+        properties: Array.isArray(r.properties) ? r.properties : [],
+        views: { ...views, default: allowed.includes(def) ? def : 'list' },
+    };
+}
+async function encodeAttrs(key, attrs) {
+    return (0, virlow_crypto_1.encryptStringBlob)(key, JSON.stringify(attrs));
+}
+async function decodeAttrs(key, blob) {
+    if (!blob)
+        return null;
+    return asAttrs(JSON.parse(await (0, virlow_crypto_1.decryptStringBlob)(key, blob)));
+}
+async function encodeSchema(key, schema) {
+    return (0, virlow_crypto_1.encryptStringBlob)(key, JSON.stringify(schema));
+}
+async function decodeSchema(key, blob) {
+    if (!blob)
+        return null;
+    return asSchema(JSON.parse(await (0, virlow_crypto_1.decryptStringBlob)(key, blob)));
+}
+function tagsFromAttrs(attrs) {
+    const value = attrs?.props[exports.TAGS_PROP];
+    return value && value.t === 'multiSelect' ? [...value.v] : [];
+}
+function withTags(attrs, tags, now = new Date().toISOString()) {
+    return { ...attrs, props: { ...attrs.props, [exports.TAGS_PROP]: { t: 'multiSelect', v: [...tags] } }, updated: now };
+}

package/dist/cjs/index.d.ts

@@ -14,6 +14,10 @@ export type { Exposure } from './exposure.js';
 export { EmbeddingCache } from './embedding-cache.js';
 export type { EmbeddingCacheLike } from './embedding-cache.js';
 export { MEMORIES_DISABLED_MESSAGE, memoriesAllowed } from './memories-enabled.js';
+export { ATTRS_MAX_BYTES, TAGS_PROP, decodeAttrs, decodeSchema, defineProp, emptyAttrs, emptySchema, encodeAttrs, encodeSchema, newPropId, removeProp, reorderProps, sortedProps, tagsFromAttrs, updateProp, withTags, } from './attrs.js';
+export type { FolderSchemaV1, NoteAttrsV1, PropDefinition, PropOption, PropType, PropValue, TagsValue } from './attrs.js';
+export { buildTitleMatcher, extractLinkIds, htmlToText } from './attrs-extract.js';
+export type { TitleEntry, TitleMatcher } from './attrs-extract.js';
 /**
  * The MCP tool surface is NOT exported here. It lives at the `/tools` subpath,
  * which is ESM-only, because it depends on @modelcontextprotocol/sdk — an

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoriesAllowed = exports.MEMORIES_DISABLED_MESSAGE = exports.EmbeddingCache = exports.filteredNotice = exports.computeExposure = exports.resolveMemoryTree = exports.ensureNamespace = exports.MEMORIES_ROOT_NAME = exports.toCodeEnvelope = exports.serializeMemoryBody = exports.parseMemoryNote = exports.mergeMeta = exports.MEMORY_NOTE_TYPE = exports.SYNC_PAGE_LIMIT = exports.MemoryStore = exports.SEARCH_SCAN_CAP = exports.NotesService = exports.Vault = exports.LockedError = exports.VirlowApi = exports.ApiError = void 0;
+exports.htmlToText = exports.extractLinkIds = exports.buildTitleMatcher = exports.withTags = exports.updateProp = exports.tagsFromAttrs = exports.sortedProps = exports.reorderProps = exports.removeProp = exports.newPropId = exports.encodeSchema = exports.encodeAttrs = exports.emptySchema = exports.emptyAttrs = exports.defineProp = exports.decodeSchema = exports.decodeAttrs = exports.TAGS_PROP = exports.ATTRS_MAX_BYTES = exports.memoriesAllowed = exports.MEMORIES_DISABLED_MESSAGE = exports.EmbeddingCache = exports.filteredNotice = exports.computeExposure = exports.resolveMemoryTree = exports.ensureNamespace = exports.MEMORIES_ROOT_NAME = exports.toCodeEnvelope = exports.serializeMemoryBody = exports.parseMemoryNote = exports.mergeMeta = exports.MEMORY_NOTE_TYPE = exports.SYNC_PAGE_LIMIT = exports.MemoryStore = exports.SEARCH_SCAN_CAP = exports.NotesService = exports.Vault = exports.LockedError = exports.VirlowApi = exports.ApiError = void 0;
 var api_js_1 = require("./api.js");
 Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return api_js_1.ApiError; } });
 Object.defineProperty(exports, "VirlowApi", { enumerable: true, get: function () { return api_js_1.VirlowApi; } });
@@ -31,6 +31,27 @@ Object.defineProperty(exports, "EmbeddingCache", { enumerable: true, get: functi
 var memories_enabled_js_1 = require("./memories-enabled.js");
 Object.defineProperty(exports, "MEMORIES_DISABLED_MESSAGE", { enumerable: true, get: function () { return memories_enabled_js_1.MEMORIES_DISABLED_MESSAGE; } });
 Object.defineProperty(exports, "memoriesAllowed", { enumerable: true, get: function () { return memories_enabled_js_1.memoriesAllowed; } });
+var attrs_js_1 = require("./attrs.js");
+Object.defineProperty(exports, "ATTRS_MAX_BYTES", { enumerable: true, get: function () { return attrs_js_1.ATTRS_MAX_BYTES; } });
+Object.defineProperty(exports, "TAGS_PROP", { enumerable: true, get: function () { return attrs_js_1.TAGS_PROP; } });
+Object.defineProperty(exports, "decodeAttrs", { enumerable: true, get: function () { return attrs_js_1.decodeAttrs; } });
+Object.defineProperty(exports, "decodeSchema", { enumerable: true, get: function () { return attrs_js_1.decodeSchema; } });
+Object.defineProperty(exports, "defineProp", { enumerable: true, get: function () { return attrs_js_1.defineProp; } });
+Object.defineProperty(exports, "emptyAttrs", { enumerable: true, get: function () { return attrs_js_1.emptyAttrs; } });
+Object.defineProperty(exports, "emptySchema", { enumerable: true, get: function () { return attrs_js_1.emptySchema; } });
+Object.defineProperty(exports, "encodeAttrs", { enumerable: true, get: function () { return attrs_js_1.encodeAttrs; } });
+Object.defineProperty(exports, "encodeSchema", { enumerable: true, get: function () { return attrs_js_1.encodeSchema; } });
+Object.defineProperty(exports, "newPropId", { enumerable: true, get: function () { return attrs_js_1.newPropId; } });
+Object.defineProperty(exports, "removeProp", { enumerable: true, get: function () { return attrs_js_1.removeProp; } });
+Object.defineProperty(exports, "reorderProps", { enumerable: true, get: function () { return attrs_js_1.reorderProps; } });
+Object.defineProperty(exports, "sortedProps", { enumerable: true, get: function () { return attrs_js_1.sortedProps; } });
+Object.defineProperty(exports, "tagsFromAttrs", { enumerable: true, get: function () { return attrs_js_1.tagsFromAttrs; } });
+Object.defineProperty(exports, "updateProp", { enumerable: true, get: function () { return attrs_js_1.updateProp; } });
+Object.defineProperty(exports, "withTags", { enumerable: true, get: function () { return attrs_js_1.withTags; } });
+var attrs_extract_js_1 = require("./attrs-extract.js");
+Object.defineProperty(exports, "buildTitleMatcher", { enumerable: true, get: function () { return attrs_extract_js_1.buildTitleMatcher; } });
+Object.defineProperty(exports, "extractLinkIds", { enumerable: true, get: function () { return attrs_extract_js_1.extractLinkIds; } });
+Object.defineProperty(exports, "htmlToText", { enumerable: true, get: function () { return attrs_extract_js_1.htmlToText; } });
 /**
  * The MCP tool surface is NOT exported here. It lives at the `/tools` subpath,
  * which is ESM-only, because it depends on @modelcontextprotocol/sdk — an