@protoyard/blueprint 0.0.0-stage → 1.1.1

package/dist/migrations.js

@@ -0,0 +1,351 @@
+import { entityTable, parseBlueprint, } from "./schema.js";
+import { deriveStores, relationProperty } from "./storage.js";
+export class MigrationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'MigrationError';
+        this.code = code;
+    }
+}
+/** Row property stored for a field (`customerId`, tags multi-entry → `tags`, …). */
+export function fieldProperty(field) {
+    return relationProperty(field) ?? field.name;
+}
+/**
+ * Default written when a field is added to an existing table. Prefers the
+ * field's declared `default`, otherwise a kind-appropriate empty value so
+ * old rows stay readable.
+ */
+export function defaultForField(field) {
+    if ('default' in field && field.default !== undefined)
+        return field.default;
+    switch (field.kind) {
+        case 'boolean':
+            return false;
+        case 'tags':
+            return [];
+        case 'json':
+            return null;
+        case 'relation':
+            return field.cardinality === 'many' ? [] : null;
+        case 'persona':
+            return null;
+        case 'file':
+            return field.multiple ? [] : null;
+        case 'integer':
+        case 'number':
+        case 'money':
+            return null;
+        default:
+            return null;
+    }
+}
+function tablesOf(blueprint) {
+    const map = new Map();
+    for (const entity of blueprint.entities) {
+        map.set(entityTable(entity), entity);
+    }
+    return map;
+}
+function fieldByProperty(entity) {
+    const map = new Map();
+    for (const field of entity.fields) {
+        map.set(fieldProperty(field), field);
+    }
+    return map;
+}
+function sortedKeys(record) {
+    return Object.keys(record).sort();
+}
+function dedupeOps(ops) {
+    const seen = new Set();
+    const out = [];
+    for (const op of ops) {
+        const key = JSON.stringify(op);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(op);
+    }
+    return out;
+}
+function planFieldChanges(args) {
+    const { prevEntity, nextEntity, prevTable, nextTable, fieldRenames, allowDrop, ops } = args;
+    const prevByProp = fieldByProperty(prevEntity);
+    const nextByProp = fieldByProperty(nextEntity);
+    const renameTargets = new Set(Object.keys(fieldRenames)
+        .filter((key) => key.startsWith(`${nextTable}.`))
+        .map((key) => key.slice(nextTable.length + 1)));
+    const renameSources = new Set(Object.entries(fieldRenames)
+        .filter(([key]) => key.startsWith(`${nextTable}.`))
+        .map(([, from]) => from));
+    for (const prevProp of [...prevByProp.keys()].sort()) {
+        if (nextByProp.has(prevProp) || renameSources.has(prevProp))
+            continue;
+        if (!allowDrop) {
+            throw new MigrationError('drop-requires-allow', `Dropping field "${prevProp}" from table "${nextTable}" requires allowDrop: true (migrations never delete user data silently)`);
+        }
+    }
+    for (const [key, from] of Object.entries(fieldRenames)) {
+        if (!key.startsWith(`${nextTable}.`))
+            continue;
+        const to = key.slice(nextTable.length + 1);
+        if (!prevByProp.has(from)) {
+            throw new MigrationError('rename-source-missing', `renamedFrom.fields["${key}"] points at unknown previous property "${from}" on "${prevTable}"`);
+        }
+        if (!nextByProp.has(to)) {
+            throw new MigrationError('rename-source-missing', `renamedFrom.fields["${key}"] but next table "${nextTable}" has no property "${to}"`);
+        }
+        ops.push({ op: 'renameField', table: nextTable, from, to });
+    }
+    for (const [property, previous] of prevByProp) {
+        const next = nextByProp.get(property);
+        if (!next)
+            continue;
+        const kindChanged = previous.kind !== next.kind;
+        const removedEnumValues = previous.kind === 'enum' && next.kind === 'enum'
+            ? previous.values.filter((value) => !next.values.includes(value))
+            : [];
+        if (!kindChanged && removedEnumValues.length === 0)
+            continue;
+        const change = kindChanged
+            ? `Changing field "${property}" from ${previous.kind} to ${next.kind}`
+            : `Removing enum values from field "${property}"`;
+        if (!allowDrop) {
+            throw new MigrationError('drop-requires-allow', `${change} on table "${nextTable}" requires allowDrop: true`);
+        }
+        const fallback = next.kind === 'enum'
+            ? next.default && next.values.includes(next.default)
+                ? next.default
+                : next.values[0]
+            : defaultForField(next);
+        ops.push({ op: 'resetField', table: nextTable, field: property, value: fallback });
+    }
+    for (const nextProp of [...nextByProp.keys()].sort()) {
+        if (prevByProp.has(nextProp) || renameTargets.has(nextProp))
+            continue;
+        const field = nextByProp.get(nextProp);
+        if (!field)
+            continue;
+        ops.push({
+            op: 'backfill',
+            table: nextTable,
+            field: nextProp,
+            value: defaultForField(field),
+        });
+    }
+}
+/**
+ * Diff two blueprints into the next `DatabaseVersion` (plus serializable ops).
+ * Returns `null` when stores and data shape are unchanged (no version bump).
+ *
+ * Classifies: add entity, add field (backfill default), add index (store
+ * string only), rename via `renamedFrom`, drop (needs `allowDrop` → `null`).
+ */
+export function diffBlueprints(prev, next, options = {}) {
+    const fromVersion = options.fromVersion ?? 1;
+    const allowDrop = options.allowDrop === true;
+    const tableRenames = options.renamedFrom?.tables ?? {};
+    const fieldRenames = options.renamedFrom?.fields ?? {};
+    const prevStores = deriveStores(prev);
+    const nextStores = deriveStores(next);
+    const prevTables = tablesOf(prev);
+    const nextTables = tablesOf(next);
+    const stores = {};
+    const ops = [];
+    const renameSources = new Set(Object.values(tableRenames));
+    // Dropped tables (not a rename source)
+    for (const prevTable of sortedKeys(prevStores)) {
+        if (nextStores[prevTable] !== undefined)
+            continue;
+        if (renameSources.has(prevTable))
+            continue;
+        if (!allowDrop) {
+            throw new MigrationError('drop-requires-allow', `Dropping table "${prevTable}" requires allowDrop: true (migrations never delete user data silently)`);
+        }
+        stores[prevTable] = null;
+    }
+    // Table renames: create next, copy rows, drop previous
+    for (const nextTable of sortedKeys(tableRenames)) {
+        const prevTable = tableRenames[nextTable];
+        if (prevStores[prevTable] === undefined) {
+            throw new MigrationError('rename-source-missing', `renamedFrom.tables["${nextTable}"] points at unknown previous table "${prevTable}"`);
+        }
+        if (nextStores[nextTable] === undefined) {
+            throw new MigrationError('rename-source-missing', `renamedFrom.tables["${nextTable}"] but next blueprint has no table "${nextTable}"`);
+        }
+        stores[nextTable] = nextStores[nextTable];
+        stores[prevTable] = null;
+        ops.push({ op: 'copyTable', from: prevTable, to: nextTable });
+        const prevEntity = prevTables.get(prevTable);
+        const nextEntity = nextTables.get(nextTable);
+        if (prevEntity && nextEntity) {
+            planFieldChanges({
+                prevEntity,
+                nextEntity,
+                prevTable,
+                nextTable,
+                fieldRenames,
+                allowDrop,
+                ops,
+            });
+        }
+    }
+    // New and changed tables (excluding rename targets already handled)
+    for (const nextTable of sortedKeys(nextStores)) {
+        if (tableRenames[nextTable] !== undefined)
+            continue;
+        const nextStore = nextStores[nextTable];
+        const prevStore = prevStores[nextTable];
+        const prevEntity = prevTables.get(nextTable);
+        const nextEntity = nextTables.get(nextTable);
+        if (prevStore === undefined) {
+            stores[nextTable] = nextStore;
+            continue;
+        }
+        if (prevEntity && nextEntity) {
+            planFieldChanges({
+                prevEntity,
+                nextEntity,
+                prevTable: nextTable,
+                nextTable,
+                fieldRenames,
+                allowDrop,
+                ops,
+            });
+        }
+        if (prevStore !== nextStore) {
+            stores[nextTable] = nextStore;
+        }
+    }
+    // softDelete newly enabled → backfill deletedAt (platform column, not a field)
+    for (const nextEntity of next.entities) {
+        const nextTable = entityTable(nextEntity);
+        const prevTable = tableRenames[nextTable] ?? nextTable;
+        const prevEntity = prevTables.get(prevTable);
+        if (!prevEntity)
+            continue;
+        if (nextEntity.features.softDelete && !prevEntity.features.softDelete) {
+            ops.push({ op: 'backfill', table: nextTable, field: 'deletedAt', value: null });
+            if (stores[nextTable] === undefined && nextStores[nextTable] !== undefined) {
+                stores[nextTable] = nextStores[nextTable];
+            }
+        }
+    }
+    const uniqueOps = dedupeOps(ops);
+    // Ops on an unchanged store string still need a version entry so Dexie runs upgrade.
+    for (const op of uniqueOps) {
+        if (op.op === 'backfill' || op.op === 'renameField') {
+            if (stores[op.table] === undefined && nextStores[op.table] !== undefined) {
+                stores[op.table] = nextStores[op.table];
+            }
+        }
+    }
+    if (Object.keys(stores).length === 0 && uniqueOps.length === 0) {
+        return null;
+    }
+    const migration = {
+        version: fromVersion + 1,
+        stores,
+        ops: uniqueOps,
+    };
+    if (uniqueOps.length > 0) {
+        migration.upgrade = (tx) => applyUpgradeOps(tx, uniqueOps);
+    }
+    return migration;
+}
+/**
+ * Runs serializable upgrade ops against a Dexie transaction. Safe to call
+ * multiple times on the same ops list (backfill only fills `undefined`).
+ */
+export async function applyUpgradeOps(tx, ops) {
+    const transaction = tx;
+    for (const op of ops) {
+        if (op.op === 'backfill') {
+            await transaction
+                .table(op.table)
+                .toCollection()
+                .modify((row) => {
+                if (row[op.field] === undefined)
+                    row[op.field] = op.value;
+            });
+        }
+        else if (op.op === 'renameField') {
+            await transaction
+                .table(op.table)
+                .toCollection()
+                .modify((row) => {
+                if (Object.hasOwn(row, op.from)) {
+                    if (row[op.to] === undefined)
+                        row[op.to] = row[op.from];
+                    delete row[op.from];
+                }
+            });
+        }
+        else if (op.op === 'copyTable') {
+            const rows = await transaction.table(op.from).toArray();
+            if (rows.length > 0) {
+                await transaction.table(op.to).bulkPut(rows);
+            }
+        }
+        else if (op.op === 'resetField') {
+            await transaction
+                .table(op.table)
+                .toCollection()
+                .modify((row) => {
+                row[op.field] = op.value;
+            });
+        }
+    }
+}
+/** Core `DatabaseVersion` ready to append to a prototype's `database.versions`. */
+export function toDatabaseVersion(migration) {
+    return {
+        version: migration.version,
+        stores: migration.stores,
+        ...(migration.ops.length > 0
+            ? { upgrade: (tx) => applyUpgradeOps(tx, migration.ops) }
+            : {}),
+    };
+}
+/**
+ * Builds the full version list: previous versions plus the diff as the tip.
+ * When `diffBlueprints` returns null, returns `previous` unchanged.
+ */
+export function appendMigration(previous, migration) {
+    if (!migration)
+        return [...previous];
+    return [...previous, toDatabaseVersion(migration)];
+}
+/**
+ * Every database version of a blueprint, rebuilt from its `history`: version 1
+ * holds the oldest entry's stores, then each step appends the diff against the
+ * previous blueprint (steps that change nothing add no version). Deterministic,
+ * so generated prototypes and `protoyard validate` agree without running code.
+ */
+export function deriveDatabaseVersions(blueprint) {
+    const chain = [
+        ...blueprint.history.map((entry) => ({
+            blueprint: parseBlueprint(entry.blueprint),
+            allowDrop: entry.migrateNext?.allowDrop === true,
+        })),
+        { blueprint, allowDrop: false },
+    ];
+    const first = chain[0];
+    let versions = [{ version: 1, stores: deriveStores(first.blueprint) }];
+    for (let i = 1; i < chain.length; i++) {
+        const prev = chain[i - 1];
+        const migration = diffBlueprints(prev.blueprint, chain[i].blueprint, {
+            fromVersion: versions[versions.length - 1].version,
+            allowDrop: prev.allowDrop,
+        });
+        versions = appendMigration(versions, migration);
+    }
+    return versions;
+}
+/** The latest schema version `deriveDatabaseVersions` produces. */
+export function latestSchemaVersion(blueprint) {
+    const versions = deriveDatabaseVersions(blueprint);
+    return versions[versions.length - 1].version;
+}

package/dist/motion.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+/**
+ * The blueprint `motion` block: a closed, optional vocabulary for how much a
+ * prototype animates. It mirrors the envelope motion of the Texuli spec
+ * (`{ level }`, spec 0.6) and maps one to one onto the `texuli/motion`
+ * `MotionProvider` level, which the player and generated prototypes render
+ * with. Agents name a level; nothing here is CSS, keyframes or milliseconds,
+ * and unknown keys or values are refused.
+ *
+ * Optional and additive to formatVersion 1: a blueprint without `motion`
+ * parses, hashes (content identity) and generates exactly as before.
+ *
+ * - `full`: every Texuli animation plays (the default).
+ * - `subtle`: shorter animations with no travel or scale.
+ * - `none`: no animation; every change is instant.
+ *
+ * The reader's `prefers-reduced-motion` and the prototype's reduced-motion
+ * setting still win: a level is a ceiling, never a way to force motion on.
+ */
+/** The motion levels, highest first (the same names as `texuli/motion`'s `MOTION_LEVEL_NAMES`). */
+export declare const BLUEPRINT_MOTION_LEVELS: readonly ["full", "subtle", "none"];
+export type BlueprintMotionLevel = (typeof BLUEPRINT_MOTION_LEVELS)[number];
+/** The level a blueprint without `motion` (or without `motion.level`) plays at. */
+export declare const DEFAULT_BLUEPRINT_MOTION_LEVEL: BlueprintMotionLevel;
+export declare const BlueprintMotionSchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        none: "none";
+        subtle: "subtle";
+        full: "full";
+    }>;
+}, z.core.$strict>;
+export type BlueprintMotion = z.infer<typeof BlueprintMotionSchema>;
+export declare function isBlueprintMotionLevel(value: unknown): value is BlueprintMotionLevel;
+/** The motion level of any parsed blueprint (`full` when it declares none). */
+export declare function blueprintMotionLevel(blueprint: {
+    readonly motion?: BlueprintMotion | undefined;
+}): BlueprintMotionLevel;
+/** The lower of two levels (`none` < `subtle` < `full`): a ceiling only ever lowers. */
+export declare function lowerMotionLevel(a: BlueprintMotionLevel, b: BlueprintMotionLevel): BlueprintMotionLevel;
+/**
+ * A deck with the blueprint's motion level as a ceiling on its own
+ * `style.motion` (slide transitions and fragments). Returns the same object
+ * when nothing changes, so a deck without a lower blueprint level keeps its
+ * identity (and Svelte does not re-render it).
+ */
+export declare function deckWithMotionCeiling<D extends {
+    readonly style?: {
+        readonly motion?: BlueprintMotionLevel | undefined;
+    } | undefined;
+}>(deck: D, level: BlueprintMotionLevel): D;

package/dist/motion.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * The blueprint `motion` block: a closed, optional vocabulary for how much a
+ * prototype animates. It mirrors the envelope motion of the Texuli spec
+ * (`{ level }`, spec 0.6) and maps one to one onto the `texuli/motion`
+ * `MotionProvider` level, which the player and generated prototypes render
+ * with. Agents name a level; nothing here is CSS, keyframes or milliseconds,
+ * and unknown keys or values are refused.
+ *
+ * Optional and additive to formatVersion 1: a blueprint without `motion`
+ * parses, hashes (content identity) and generates exactly as before.
+ *
+ * - `full`: every Texuli animation plays (the default).
+ * - `subtle`: shorter animations with no travel or scale.
+ * - `none`: no animation; every change is instant.
+ *
+ * The reader's `prefers-reduced-motion` and the prototype's reduced-motion
+ * setting still win: a level is a ceiling, never a way to force motion on.
+ */
+/** The motion levels, highest first (the same names as `texuli/motion`'s `MOTION_LEVEL_NAMES`). */
+export const BLUEPRINT_MOTION_LEVELS = ['full', 'subtle', 'none'];
+/** The level a blueprint without `motion` (or without `motion.level`) plays at. */
+export const DEFAULT_BLUEPRINT_MOTION_LEVEL = 'full';
+export const BlueprintMotionSchema = z.strictObject({
+    /** How much the prototype animates: `full` (default), `subtle` or `none`. */
+    level: z.enum(BLUEPRINT_MOTION_LEVELS),
+});
+export function isBlueprintMotionLevel(value) {
+    return (typeof value === 'string' && BLUEPRINT_MOTION_LEVELS.includes(value));
+}
+/** The motion level of any parsed blueprint (`full` when it declares none). */
+export function blueprintMotionLevel(blueprint) {
+    const level = blueprint.motion?.level;
+    return isBlueprintMotionLevel(level) ? level : DEFAULT_BLUEPRINT_MOTION_LEVEL;
+}
+/** The lower of two levels (`none` < `subtle` < `full`): a ceiling only ever lowers. */
+export function lowerMotionLevel(a, b) {
+    return BLUEPRINT_MOTION_LEVELS.indexOf(a) >= BLUEPRINT_MOTION_LEVELS.indexOf(b) ? a : b;
+}
+/**
+ * A deck with the blueprint's motion level as a ceiling on its own
+ * `style.motion` (slide transitions and fragments). Returns the same object
+ * when nothing changes, so a deck without a lower blueprint level keeps its
+ * identity (and Svelte does not re-render it).
+ */
+export function deckWithMotionCeiling(deck, level) {
+    const own = deck.style?.motion ?? DEFAULT_BLUEPRINT_MOTION_LEVEL;
+    const effective = lowerMotionLevel(own, level);
+    if (effective === own)
+        return deck;
+    return { ...deck, style: { ...deck.style, motion: effective } };
+}

package/dist/notifications.d.ts

@@ -0,0 +1,19 @@
+import { type PrototypeRuntime, type Row } from '@protoyard/core';
+import type { Blueprint, BlueprintEntity } from './schema.ts';
+export interface BlueprintNotificationService {
+    list(): Promise<Row[]>;
+    unreadCount(): Promise<number>;
+    markRead(id: string): Promise<boolean>;
+    markUnread(id: string): Promise<boolean>;
+    markAllRead(): Promise<number>;
+}
+export interface NotificationEvent {
+    readonly on: 'create' | 'update';
+    readonly entity: BlueprintEntity;
+    readonly row: Row;
+    readonly previous?: Row;
+}
+/** Writes rule matches into the caller's existing mutation transaction. */
+export declare function createNotificationWriter(runtime: PrototypeRuntime, blueprint: Blueprint): (event: NotificationEvent) => Promise<number>;
+/** Actor-scoped notification reads and updates. */
+export declare function createNotificationService(runtime: PrototypeRuntime): BlueprintNotificationService;

package/dist/notifications.js

@@ -0,0 +1,177 @@
+import { createRuntimeId } from '@protoyard/core';
+import { entityTable } from "./schema.js";
+import { FEATURE_TABLES } from "./storage.js";
+import { inputProperty } from "./validation.js";
+function personaProperty(field) {
+    return `${field}Id`;
+}
+function text(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value))
+        return value.map(text).join(', ');
+    if (typeof value === 'object')
+        return '[object]';
+    return String(value);
+}
+async function titleFor(template, entity, row, db, blueprint) {
+    const fields = new Map(entity.fields.map((field) => [field.name, field]));
+    const matches = [...template.matchAll(/\{([^{}]+)\}/g)];
+    let title = template;
+    for (const match of matches) {
+        const name = match[1] ?? '';
+        const field = fields.get(name);
+        if (!field)
+            continue;
+        const value = row[inputProperty(field)];
+        let display = value;
+        if (field.kind === 'persona' && typeof value === 'string') {
+            display = (await db.table('py_personas').get(value))?.name ?? value;
+        }
+        else if (field.kind === 'relation' && typeof value === 'string') {
+            const targetEntity = blueprint.entities.find((item) => item.name === field.to);
+            const target = targetEntity
+                ? await db.table(entityTable(targetEntity)).get(value)
+                : undefined;
+            const titleField = targetEntity?.titleField;
+            const displayField = targetEntity?.fields.find((candidate) => candidate.name === titleField);
+            display =
+                target && titleField && !displayField?.sensitive && typeof target[titleField] === 'string'
+                    ? target[titleField]
+                    : value;
+        }
+        title = title.replace(match[0], text(display));
+    }
+    return title;
+}
+/** Writes rule matches into the caller's existing mutation transaction. */
+export function createNotificationWriter(runtime, blueprint) {
+    const db = runtime.db;
+    const memberships = db.table('py_memberships');
+    const actorId = () => runtime.session.principal()?.persona.id;
+    async function recipients(rule, entity, row) {
+        const actor = actorId();
+        let ids = [];
+        if (rule.notify === 'owner' && entity.ownerField) {
+            const id = row[personaProperty(entity.ownerField)];
+            if (typeof id === 'string')
+                ids = [id];
+        }
+        else if (rule.notify === 'assignee') {
+            const id = row[personaProperty('assignee')];
+            if (typeof id === 'string')
+                ids = [id];
+        }
+        else if (rule.notify.startsWith('role:')) {
+            const role = rule.notify.slice('role:'.length);
+            const activeMembership = (await memberships.toArray()).find((item) => item.personaId === actor);
+            ids = (await memberships.toArray())
+                .filter((item) => item.role === role &&
+                (activeMembership?.organizationId === undefined ||
+                    item.organizationId === activeMembership.organizationId))
+                .map((item) => item.personaId)
+                .filter((id) => typeof id === 'string');
+        }
+        return [...new Set(ids)].filter((id) => id !== actor);
+    }
+    return async (event) => {
+        const rules = blueprint.notifications.filter((rule) => rule.entity === event.entity.name && rule.on === event.on);
+        const assignmentRules = blueprint.notifications.filter((rule) => rule.entity === event.entity.name && rule.on === 'assign');
+        const matchingRules = [...rules, ...assignmentRules];
+        if (matchingRules.length === 0)
+            return 0;
+        let count = 0;
+        const notificationTable = db.table(FEATURE_TABLES.notifications);
+        for (const rule of matchingRules) {
+            if (rule.on === 'assign') {
+                if (!rule.field || !event.previous)
+                    continue;
+                const property = personaProperty(rule.field);
+                const oldValue = event.previous[property];
+                const newValue = event.row[property];
+                if (typeof newValue !== 'string' || newValue === oldValue)
+                    continue;
+            }
+            const targetIds = await recipients(rule, event.entity, event.row);
+            const now = runtime.clock.now().toISOString();
+            for (const personaId of targetIds) {
+                await notificationTable.put({
+                    id: createRuntimeId('notification'),
+                    personaId,
+                    kind: `${event.entity.name}.${rule.on}`,
+                    title: await titleFor(rule.title, event.entity, event.row, db, blueprint),
+                    body: '',
+                    createdAt: now,
+                    readAt: null,
+                });
+                count += 1;
+            }
+        }
+        return count;
+    };
+}
+/** Actor-scoped notification reads and updates. */
+export function createNotificationService(runtime) {
+    const db = runtime.db;
+    const table = db.table(FEATURE_TABLES.notifications);
+    const { environment } = runtime;
+    const actorId = () => {
+        const id = runtime.session.principal()?.persona.id;
+        if (!id)
+            throw new Error('No active persona. Load a scenario first.');
+        return id;
+    };
+    const ownRow = async (id) => {
+        const row = await table.get(id);
+        return row?.personaId === actorId() ? row : undefined;
+    };
+    return {
+        async list() {
+            return (await table.where('personaId').equals(actorId()).toArray()).sort((a, b) => {
+                const byTime = String(b.createdAt).localeCompare(String(a.createdAt));
+                return byTime || String(b.id).localeCompare(String(a.id));
+            });
+        },
+        async unreadCount() {
+            const personaId = actorId();
+            const total = await table.where('personaId').equals(personaId).count();
+            const read = await table
+                .where('[personaId+readAt]')
+                .between([personaId, ''], [personaId, '\uffff'])
+                .count();
+            return total - read;
+        },
+        async markRead(id) {
+            const row = await ownRow(id);
+            if (!row)
+                return false;
+            if (row.readAt)
+                return true;
+            await environment.run('notifications.markRead', () => db.transaction('rw', [FEATURE_TABLES.notifications], async () => {
+                await table.update(id, { readAt: runtime.clock.now().toISOString() });
+            }));
+            return true;
+        },
+        async markUnread(id) {
+            const row = await ownRow(id);
+            if (!row)
+                return false;
+            if (!row.readAt)
+                return true;
+            await environment.run('notifications.markUnread', () => db.transaction('rw', [FEATURE_TABLES.notifications], async () => {
+                await table.update(id, { readAt: null });
+            }));
+            return true;
+        },
+        async markAllRead() {
+            const rows = await table.where('personaId').equals(actorId()).toArray();
+            const unread = rows.filter((row) => row.readAt === null || row.readAt === undefined);
+            await environment.run('notifications.markAllRead', () => db.transaction('rw', [FEATURE_TABLES.notifications], async () => {
+                const readAt = runtime.clock.now().toISOString();
+                for (const row of unread)
+                    await table.update(row.id, { readAt });
+            }));
+            return unread.length;
+        },
+    };
+}