@dinoxx/dinox-cli 2.1.1 → 2.3.0

package/dist/commands/savedViews/model.d.ts

@@ -1,70 +1,14 @@
-export declare const SAVED_VIEW_FILTER_VERSION = 1;
-export declare const SAVED_VIEW_CONFIG_VERSION = 1;
-export declare const MAX_SAVED_VIEW_FILTER_DEPTH = 8;
-export declare const MAX_SAVED_VIEW_FILTER_NODES = 100;
-export declare const MAX_SAVED_VIEW_FILTER_VALUE_LENGTH = 2000;
-export declare const MAX_SAVED_VIEW_COLUMNS = 100;
-export declare const MAX_SAVED_VIEW_SORTS = 20;
-export declare const SAVED_VIEW_SYSTEM_FIELDS: readonly ["title", "created_at", "updated_at", "tags", "zettel_boxes", "source", "type", "starred_at"];
-export declare const SAVED_VIEW_FILTER_OPERATORS: readonly ["equals", "notEquals", "contains", "notContains", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "isEmpty", "isNotEmpty"];
-export type SavedViewSystemField = (typeof SAVED_VIEW_SYSTEM_FIELDS)[number];
-export type SavedViewFieldRef = `sys.${SavedViewSystemField}` | `prop.${string}`;
-export type SavedViewFilterOperator = (typeof SAVED_VIEW_FILTER_OPERATORS)[number];
-export type SavedViewFilterValue = string | number | boolean | null;
-export type SavedViewFilterCondition = {
-    kind: 'condition';
-    field: SavedViewFieldRef;
-    operator: SavedViewFilterOperator;
-    value?: SavedViewFilterValue;
-};
-export type SavedViewFilterGroup = {
-    kind: 'group';
-    operator: 'and' | 'or';
-    children: SavedViewFilterNode[];
-};
-export type SavedViewFilterNot = {
-    kind: 'not';
-    child: SavedViewFilterNode;
-};
-export type SavedViewFilterNode = SavedViewFilterCondition | SavedViewFilterGroup | SavedViewFilterNot;
-export type SavedViewFilter = {
-    version: typeof SAVED_VIEW_FILTER_VERSION;
-    root: SavedViewFilterNode | null;
-};
-export type SavedViewColumn = {
-    field: SavedViewFieldRef;
-};
-export type SavedViewSort = {
-    field: SavedViewFieldRef;
-    direction: 'asc' | 'desc';
-};
-export type SavedViewConfig = {
-    version: typeof SAVED_VIEW_CONFIG_VERSION;
-    layout: 'table';
-    columns: SavedViewColumn[];
-    sort?: SavedViewSort[];
-};
-export type SavedViewRow = {
-    id: string;
-    user_id: string | null;
-    name: string | null;
-    emoji: string | null;
-    filter_json: string | null;
-    view_type: string | null;
-    config_json: string | null;
-    template_id: string | null;
-    group_id: string | null;
-    sort_rank: number | null;
-    pinned_at: string | null;
-    created_at: string | null;
-    updated_at: string | null;
-    is_del: number | null;
-};
+import { type DinoxErrorCode } from '../../utils/errors.js';
+import { createDefaultSavedViewConfig, createDefaultSavedViewFilter, SAVED_VIEW_LAYOUTS, type SavedViewCatalogRow, type SavedViewConfig, type SavedViewFilter, type SavedViewLayout } from '../../vendor/electron/shared/index.js';
+export { createDefaultSavedViewConfig, createDefaultSavedViewFilter, SAVED_VIEW_LAYOUTS, type SavedViewConfig, type SavedViewFilter, type SavedViewLayout, };
+export type { SavedViewFieldRef, SavedViewFilterCondition, SavedViewFilterNode, } from '../../vendor/electron/shared/index.js';
+export type SavedViewRow = SavedViewCatalogRow;
 export type SavedViewDefinition = {
     id: string;
     userId: string;
     name: string;
     emoji: string | null;
+    layout: SavedViewLayout;
     filter: SavedViewFilter;
     config: SavedViewConfig;
     templateId: string | null;
@@ -74,14 +18,28 @@ export type SavedViewDefinition = {
     createdAt: string | null;
     updatedAt: string | null;
 };
-export declare function isNotePropertyKeyValid(value: unknown): value is string;
-export declare function isSavedViewFieldRef(value: unknown): value is SavedViewFieldRef;
+/** A stored row the CLI could not parse; returned instead of throwing so it stays inspectable. */
+export type InvalidSavedViewDefinition = Omit<SavedViewDefinition, 'layout' | 'filter' | 'config'> & {
+    viewType: string | null;
+    filterJson: string | null;
+    configJson: string | null;
+};
+export type SavedViewInspection = {
+    valid: true;
+    view: SavedViewDefinition;
+} | {
+    valid: false;
+    view: InvalidSavedViewDefinition;
+    error: {
+        code: DinoxErrorCode;
+        message: string;
+        issues?: unknown;
+    };
+};
 export declare function validateSavedViewFilter(value: unknown): SavedViewFilter;
-export declare function parseSavedViewFilter(raw: string | null | undefined): SavedViewFilter;
-export declare function serializeSavedViewFilter(value: unknown): string;
 export declare function validateSavedViewConfig(value: unknown): SavedViewConfig;
+export declare function parseSavedViewFilter(raw: string | null | undefined): SavedViewFilter;
 export declare function parseSavedViewConfig(raw: string | null | undefined): SavedViewConfig;
-export declare function serializeSavedViewConfig(value: unknown): string;
-export declare function createDefaultSavedViewFilter(): SavedViewFilter;
-export declare function createDefaultSavedViewConfig(): SavedViewConfig;
 export declare function mapSavedViewRow(row: SavedViewRow): SavedViewDefinition;
+/** Parses a stored row without throwing, so catalogs and `view get` can surface bad rows. */
+export declare function inspectSavedViewRow(row: SavedViewRow): SavedViewInspection;

package/dist/commands/savedViews/model.js

@@ -1,301 +1,52 @@
+// Saved-view definitions as Dinox desktop stores them. Validation is delegated to the vendored
+// desktop zod schemas (src/vendor/electron/shared/saved-views.ts) so the CLI accepts every
+// filter version, layout, operator, and analytics config the desktop writes.
 import { DinoxError } from '../../utils/errors.js';
-export const SAVED_VIEW_FILTER_VERSION = 1;
-export const SAVED_VIEW_CONFIG_VERSION = 1;
-export const MAX_SAVED_VIEW_FILTER_DEPTH = 8;
-export const MAX_SAVED_VIEW_FILTER_NODES = 100;
-export const MAX_SAVED_VIEW_FILTER_VALUE_LENGTH = 2_000;
-export const MAX_SAVED_VIEW_COLUMNS = 100;
-export const MAX_SAVED_VIEW_SORTS = 20;
-export const SAVED_VIEW_SYSTEM_FIELDS = [
-    'title',
-    'created_at',
-    'updated_at',
-    'tags',
-    'zettel_boxes',
-    'source',
-    'type',
-    'starred_at',
-];
-export const SAVED_VIEW_FILTER_OPERATORS = [
-    'equals',
-    'notEquals',
-    'contains',
-    'notContains',
-    'greaterThan',
-    'greaterThanOrEqual',
-    'lessThan',
-    'lessThanOrEqual',
-    'isEmpty',
-    'isNotEmpty',
-];
-const systemFieldRefs = new Set(SAVED_VIEW_SYSTEM_FIELDS.map((field) => `sys.${field}`));
-const filterOperators = new Set(SAVED_VIEW_FILTER_OPERATORS);
-const valueRequiredOperators = new Set([
-    'contains',
-    'notContains',
-    'greaterThan',
-    'greaterThanOrEqual',
-    'lessThan',
-    'lessThanOrEqual',
-]);
-const valuelessOperators = new Set(['isEmpty', 'isNotEmpty']);
-function formatError(message, code, details) {
-    return new DinoxError(message, {
-        code,
-        details,
-        recoverable: false,
-    });
+import { createDefaultSavedViewConfig, createDefaultSavedViewFilter, SAVED_VIEW_LAYOUTS, savedViewConfigSchema, savedViewFilterSchema, } from '../../vendor/electron/shared/index.js';
+export { createDefaultSavedViewConfig, createDefaultSavedViewFilter, SAVED_VIEW_LAYOUTS, };
+function issuesOf(error) {
+    return error.issues.map((issue) => ({ path: issue.path.map(String).join('.'), message: issue.message }));
 }
-function isPlainRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+function invalid(code, message, issues) {
+    return new DinoxError(message, { code, details: issues === undefined ? undefined : { issues }, recoverable: false });
 }
-function assertAllowedKeys(record, allowed, label, code) {
-    const allowedKeys = new Set(allowed);
-    const unknownKeys = Object.keys(record).filter((key) => !allowedKeys.has(key));
-    if (unknownKeys.length > 0) {
-        throw formatError(`${label} contains unsupported fields`, code, { unknownKeys });
-    }
-}
-function parseStoredJson(raw, label, code) {
+function parseJson(raw, label, code) {
     const value = raw?.trim() ?? '';
-    if (!value) {
-        throw formatError(`${label} is required`, code);
-    }
+    if (!value)
+        throw invalid(code, `${label} is required`);
     try {
         return JSON.parse(value);
     }
-    catch (cause) {
-        throw formatError(`${label} must be valid JSON`, code, {
-            cause: cause instanceof Error ? cause.message : String(cause),
-        });
+    catch {
+        throw invalid(code, `${label} must be valid JSON`);
     }
 }
-export function isNotePropertyKeyValid(value) {
-    if (typeof value !== 'string')
-        return false;
-    const trimmed = value.trim();
-    if (!trimmed || trimmed !== value || trimmed.length > 64)
-        return false;
-    if (trimmed === '__proto__')
-        return false;
-    return !trimmed.includes('.') && !/[\n\r\t]/.test(trimmed);
-}
-export function isSavedViewFieldRef(value) {
-    if (typeof value !== 'string')
-        return false;
-    if (systemFieldRefs.has(value))
-        return true;
-    return value.startsWith('prop.') && isNotePropertyKeyValid(value.slice('prop.'.length));
-}
-function validateFilterValue(value, code) {
-    if (value === null || typeof value === 'boolean')
-        return value;
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string' && value.length <= MAX_SAVED_VIEW_FILTER_VALUE_LENGTH)
-        return value;
-    throw formatError('Saved view filter contains an invalid value', code, {
-        maxStringLength: MAX_SAVED_VIEW_FILTER_VALUE_LENGTH,
-    });
-}
-function validateFilterNode(value, state, depth) {
-    const code = 'SAVED_VIEW_INVALID_FILTER';
-    if (depth > MAX_SAVED_VIEW_FILTER_DEPTH) {
-        throw formatError(`Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_DEPTH} levels`, code);
-    }
-    if (!isPlainRecord(value)) {
-        throw formatError('Saved view filter nodes must be objects', code);
-    }
-    state.count += 1;
-    if (state.count > MAX_SAVED_VIEW_FILTER_NODES) {
-        throw formatError(`Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_NODES} nodes`, code);
-    }
-    if (value.kind === 'condition') {
-        assertAllowedKeys(value, ['kind', 'field', 'operator', 'value'], 'Saved view filter condition', code);
-        if (!isSavedViewFieldRef(value.field)) {
-            throw formatError('Saved view filter contains an invalid field reference', code, { field: value.field });
-        }
-        if (typeof value.operator !== 'string' || !filterOperators.has(value.operator)) {
-            throw formatError('Saved view filter contains an invalid operator', code, { operator: value.operator });
-        }
-        const operator = value.operator;
-        const hasValue = Object.hasOwn(value, 'value');
-        const parsedValue = hasValue ? validateFilterValue(value.value, code) : undefined;
-        if (valueRequiredOperators.has(operator)
-            && (parsedValue === undefined || parsedValue === null || (typeof parsedValue === 'string' && !parsedValue.trim()))) {
-            throw formatError(`Saved view operator ${operator} requires a non-empty value`, code);
-        }
-        if (valuelessOperators.has(operator) && parsedValue !== undefined && parsedValue !== null) {
-            throw formatError(`Saved view operator ${operator} does not accept a value`, code);
-        }
-        return {
-            kind: 'condition',
-            field: value.field,
-            operator,
-            ...(hasValue ? { value: parsedValue } : {}),
-        };
-    }
-    if (value.kind === 'group') {
-        assertAllowedKeys(value, ['kind', 'operator', 'children'], 'Saved view filter group', code);
-        if (value.operator !== 'and' && value.operator !== 'or') {
-            throw formatError('Saved view filter group operator must be and or or', code);
-        }
-        if (!Array.isArray(value.children) || value.children.length > MAX_SAVED_VIEW_FILTER_NODES) {
-            throw formatError(`Saved view filter groups support at most ${MAX_SAVED_VIEW_FILTER_NODES} children`, code);
-        }
-        return {
-            kind: 'group',
-            operator: value.operator,
-            children: value.children.map((child) => validateFilterNode(child, state, depth + 1)),
-        };
-    }
-    if (value.kind === 'not') {
-        assertAllowedKeys(value, ['kind', 'child'], 'Saved view filter not node', code);
-        return {
-            kind: 'not',
-            child: validateFilterNode(value.child, state, depth + 1),
-        };
-    }
-    throw formatError('Saved view filter contains an unsupported node kind', code, { kind: value.kind });
-}
 export function validateSavedViewFilter(value) {
-    const code = 'SAVED_VIEW_INVALID_FILTER';
-    if (!isPlainRecord(value)) {
-        throw formatError('Saved view filter must be a versioned object', code);
+    const parsed = savedViewFilterSchema.safeParse(value);
+    if (!parsed.success) {
+        throw invalid('SAVED_VIEW_INVALID_FILTER', 'Saved view filter is invalid', issuesOf(parsed.error));
     }
-    if (value.version !== SAVED_VIEW_FILTER_VERSION) {
-        throw formatError(`Unsupported saved view filter version: ${String(value.version)}`, 'SAVED_VIEW_UNSUPPORTED_FILTER_VERSION', {
-            supportedVersion: SAVED_VIEW_FILTER_VERSION,
-            receivedVersion: value.version,
-        });
-    }
-    assertAllowedKeys(value, ['version', 'root'], 'Saved view filter', code);
-    if (!Object.hasOwn(value, 'root')) {
-        throw formatError('Saved view filter root is required', code);
-    }
-    return {
-        version: SAVED_VIEW_FILTER_VERSION,
-        root: value.root === null ? null : validateFilterNode(value.root, { count: 0 }, 1),
-    };
-}
-export function parseSavedViewFilter(raw) {
-    return validateSavedViewFilter(parseStoredJson(raw, 'Saved view filter_json', 'SAVED_VIEW_INVALID_FILTER'));
-}
-export function serializeSavedViewFilter(value) {
-    return JSON.stringify(validateSavedViewFilter(value));
+    return parsed.data;
 }
 export function validateSavedViewConfig(value) {
-    const code = 'SAVED_VIEW_INVALID_CONFIG';
-    if (!isPlainRecord(value)) {
-        throw formatError('Saved view config must be a versioned object', code);
-    }
-    if (value.version !== SAVED_VIEW_CONFIG_VERSION) {
-        throw formatError(`Unsupported saved view config version: ${String(value.version)}`, 'SAVED_VIEW_UNSUPPORTED_CONFIG_VERSION', {
-            supportedVersion: SAVED_VIEW_CONFIG_VERSION,
-            receivedVersion: value.version,
-        });
-    }
-    assertAllowedKeys(value, ['version', 'layout', 'columns', 'sort'], 'Saved view config', code);
-    if (value.layout !== 'table') {
-        throw formatError(`Unsupported saved view layout: ${String(value.layout)}`, 'SAVED_VIEW_UNSUPPORTED_LAYOUT', {
-            supportedLayouts: ['table'],
-        });
-    }
-    if (!Array.isArray(value.columns) || value.columns.length === 0 || value.columns.length > MAX_SAVED_VIEW_COLUMNS) {
-        throw formatError(`Saved view config requires 1-${MAX_SAVED_VIEW_COLUMNS} columns`, code);
+    const parsed = savedViewConfigSchema.safeParse(value);
+    if (!parsed.success) {
+        throw invalid('SAVED_VIEW_INVALID_CONFIG', 'Saved view config is invalid', issuesOf(parsed.error));
     }
-    const columnFields = new Set();
-    const columns = value.columns.map((column, index) => {
-        if (!isPlainRecord(column)) {
-            throw formatError('Saved view columns must be objects', code, { index });
-        }
-        assertAllowedKeys(column, ['field'], 'Saved view column', code);
-        if (!isSavedViewFieldRef(column.field)) {
-            throw formatError('Saved view config contains an invalid column field', code, { index, field: column.field });
-        }
-        if (columnFields.has(column.field)) {
-            throw formatError('Saved view columns must be unique', code, { index, field: column.field });
-        }
-        columnFields.add(column.field);
-        return { field: column.field };
-    });
-    if (columns[0]?.field !== 'sys.title') {
-        throw formatError('The title field must be the first saved view column', code);
-    }
-    let sort;
-    if (value.sort !== undefined) {
-        if (!Array.isArray(value.sort) || value.sort.length > MAX_SAVED_VIEW_SORTS) {
-            throw formatError(`Saved view config supports at most ${MAX_SAVED_VIEW_SORTS} sort fields`, code);
-        }
-        const sortFields = new Set();
-        sort = value.sort.map((item, index) => {
-            if (!isPlainRecord(item)) {
-                throw formatError('Saved view sort entries must be objects', code, { index });
-            }
-            assertAllowedKeys(item, ['field', 'direction'], 'Saved view sort', code);
-            if (!isSavedViewFieldRef(item.field)) {
-                throw formatError('Saved view config contains an invalid sort field', code, { index, field: item.field });
-            }
-            if (item.direction !== 'asc' && item.direction !== 'desc') {
-                throw formatError('Saved view sort direction must be asc or desc', code, { index });
-            }
-            if (sortFields.has(item.field)) {
-                throw formatError('Saved view sort fields must be unique', code, { index, field: item.field });
-            }
-            sortFields.add(item.field);
-            return { field: item.field, direction: item.direction };
-        });
-    }
-    return {
-        version: SAVED_VIEW_CONFIG_VERSION,
-        layout: 'table',
-        columns,
-        ...(sort === undefined ? {} : { sort }),
-    };
-}
-export function parseSavedViewConfig(raw) {
-    return validateSavedViewConfig(parseStoredJson(raw, 'Saved view config_json', 'SAVED_VIEW_INVALID_CONFIG'));
-}
-export function serializeSavedViewConfig(value) {
-    return JSON.stringify(validateSavedViewConfig(value));
+    return parsed.data;
 }
-export function createDefaultSavedViewFilter() {
-    return { version: SAVED_VIEW_FILTER_VERSION, root: null };
+export function parseSavedViewFilter(raw) {
+    return validateSavedViewFilter(parseJson(raw, 'Saved view filter_json', 'SAVED_VIEW_INVALID_FILTER'));
 }
-export function createDefaultSavedViewConfig() {
-    return {
-        version: SAVED_VIEW_CONFIG_VERSION,
-        layout: 'table',
-        columns: [{ field: 'sys.title' }, { field: 'sys.updated_at' }],
-        sort: [{ field: 'sys.updated_at', direction: 'desc' }],
-    };
+export function parseSavedViewConfig(raw) {
+    return validateSavedViewConfig(parseJson(raw, 'Saved view config_json', 'SAVED_VIEW_INVALID_CONFIG'));
 }
-export function mapSavedViewRow(row) {
-    const id = row.id.trim();
-    const userId = row.user_id?.trim() ?? '';
-    const name = row.name?.trim() ?? '';
-    if (!id || !userId || !name || name.length > 120) {
-        throw formatError('c_saved_view row is missing a valid id, user_id, or name', 'SAVED_VIEW_INVALID_ROW', {
-            id: row.id,
-            userId: row.user_id,
-            name: row.name,
-        });
-    }
-    if (row.view_type !== 'table') {
-        throw formatError(`Unsupported c_saved_view view_type: ${String(row.view_type)}`, 'SAVED_VIEW_UNSUPPORTED_LAYOUT');
-    }
-    const filter = parseSavedViewFilter(row.filter_json);
-    const config = parseSavedViewConfig(row.config_json);
-    if (config.layout !== row.view_type) {
-        throw formatError('c_saved_view view_type must match config_json.layout', 'SAVED_VIEW_INVALID_ROW');
-    }
+function baseFields(row) {
     return {
-        id,
-        userId,
-        name,
+        id: row.id.trim(),
+        userId: row.user_id?.trim() ?? '',
+        name: row.name?.trim() ?? '',
         emoji: row.emoji,
-        filter,
-        config,
         templateId: row.template_id,
         groupId: row.group_id,
         sortRank: row.sort_rank,
@@ -304,3 +55,36 @@ export function mapSavedViewRow(row) {
         updatedAt: row.updated_at,
     };
 }
+export function mapSavedViewRow(row) {
+    const base = baseFields(row);
+    if (!base.id || !base.userId || !base.name || base.name.length > 120) {
+        throw invalid('SAVED_VIEW_INVALID_ROW', 'c_saved_view row is missing a valid id, user_id, or name');
+    }
+    const filter = parseSavedViewFilter(row.filter_json);
+    const config = parseSavedViewConfig(row.config_json);
+    return { ...base, layout: config.layout, filter, config };
+}
+/** Parses a stored row without throwing, so catalogs and `view get` can surface bad rows. */
+export function inspectSavedViewRow(row) {
+    try {
+        return { valid: true, view: mapSavedViewRow(row) };
+    }
+    catch (error) {
+        const dinoxError = error instanceof DinoxError ? error : invalid('SAVED_VIEW_INVALID_ROW', String(error));
+        const issues = dinoxError.details?.issues;
+        return {
+            valid: false,
+            view: {
+                ...baseFields(row),
+                viewType: row.view_type,
+                filterJson: row.filter_json,
+                configJson: row.config_json,
+            },
+            error: {
+                code: dinoxError.code,
+                message: dinoxError.message,
+                ...(issues === undefined ? {} : { issues }),
+            },
+        };
+    }
+}

package/dist/commands/savedViews/repo.d.ts

@@ -1,10 +1,12 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
-import { type SavedViewConfig, type SavedViewDefinition, type SavedViewFieldRef, type SavedViewFilter } from './model.js';
-import { type PropertyOption, type SavedViewFieldCatalogItem, type SavedViewFieldSemantic, type SavedViewSqlFragment } from './semantics.js';
+import { type PropertyOption, type SavedViewAnalyticsRow, type SavedViewComputedColumn, type SavedViewLayout, type SavedViewTableColumnKey } from '../../vendor/electron/shared/index.js';
+import { type SavedViewConfig, type SavedViewFilter, type SavedViewInspection } from './model.js';
+export { listSavedViewFields } from './fields.js';
 export type SavedViewCatalogItem = {
     id: string;
     name: string;
     emoji: string | null;
+    layout: string | null;
     templateId: string | null;
     groupId: string | null;
     sortRank: number | null;
@@ -17,39 +19,24 @@ export type SavedViewCatalogItem = {
         message: string;
     };
 };
-export type SavedViewPageRow = {
-    id: string;
-    title: string | null;
-    created_at: string | null;
-    updated_at: string | null;
-    tags: string | null;
-    zettel_boxes: string | null;
-    source: string | null;
-    type: string | null;
-    starred_at: string | null;
-    properties: string | null;
-};
-export type SavedViewQueryScope = {
-    definition: SavedViewDefinition;
-    semantics: ReadonlyMap<SavedViewFieldRef, SavedViewFieldSemantic>;
-    where: SavedViewSqlFragment;
-    order: SavedViewSqlFragment;
-};
 export type SavedViewProjectedRow = {
     id: string;
     title: string | null;
-    values: Partial<Record<SavedViewFieldRef, unknown>>;
-    displayValues?: Partial<Record<SavedViewFieldRef, unknown>>;
+    values: Partial<Record<SavedViewTableColumnKey, unknown>>;
+    displayValues?: Partial<Record<SavedViewTableColumnKey, unknown>>;
+};
+export type SavedViewProjectedColumn = {
+    field: SavedViewTableColumnKey;
+    type: string;
+    propertyType: string | null;
+    dateMode: string | null;
+    displayOnly?: boolean;
+    computed?: SavedViewComputedColumn;
+    options?: readonly PropertyOption[];
 };
 export type SavedViewQueryResult = {
-    view: SavedViewDefinition;
-    columns: Array<{
-        field: SavedViewFieldRef;
-        type: SavedViewFieldSemantic['type'];
-        propertyType: SavedViewFieldSemantic['propertyType'] | null;
-        dateMode: SavedViewFieldSemantic['dateMode'] | null;
-        options?: readonly PropertyOption[];
-    }>;
+    view: SavedViewInspection['view'];
+    columns: SavedViewProjectedColumn[];
     totalCount: number;
     offset: number;
     limit: number;
@@ -57,67 +44,82 @@ export type SavedViewQueryResult = {
     hasMore: boolean;
     rows: SavedViewProjectedRow[];
 };
-export type CreateSavedViewInput = {
-    userId: string;
-    name: string;
+export type SavedViewWriteInput = {
+    name?: string;
     emoji?: string | null;
     filter?: SavedViewFilter;
     config?: SavedViewConfig;
+    layout?: SavedViewLayout;
     templateId?: string | null;
     groupId?: string | null;
     sortRank?: number | null;
     pinnedAt?: string | null;
-    updatedAt?: string;
 };
-export type UpdateSavedViewInput = {
+export type CreateSavedViewInput = SavedViewWriteInput & {
+    userId: string;
+    name: string;
+};
+export type UpdateSavedViewInput = SavedViewWriteInput & {
     id: string;
     userId: string;
-    name?: string;
-    emoji?: string | null;
-    filter?: SavedViewFilter;
-    config?: SavedViewConfig;
-    templateId?: string | null;
-    groupId?: string | null;
-    sortRank?: number | null;
-    pinnedAt?: string | null;
-    updatedAt?: string;
 };
 export type DeleteSavedViewInput = {
     id: string;
     userId: string;
-    updatedAt?: string;
 };
-export type SavedViewMutationPlan = {
+export type SavedViewMutationPreview = {
     action: 'create' | 'update' | 'delete';
-    target: SavedViewDefinition | null;
-    changes: Record<string, unknown>;
+    before: SavedViewInspection | null;
+    after: SavedViewInspection | null;
 };
 export declare function listSavedViews(db: AbstractPowerSyncDatabase, input: {
     userId: string;
     limit?: number;
 }): Promise<SavedViewCatalogItem[]>;
+/** Reads one view without throwing on stored rows the CLI cannot parse (see `valid`). */
 export declare function getSavedView(db: AbstractPowerSyncDatabase, input: {
     id: string;
     userId: string;
-}): Promise<SavedViewDefinition>;
-export declare function resolveSavedViewQueryScope(db: AbstractPowerSyncDatabase, input: {
+}): Promise<SavedViewInspection>;
+/** Row-level evaluation, aligned with desktop: non-finite side or division by zero → null. */
+export declare function evaluateComputedColumn(properties: Record<string, unknown>, column: SavedViewComputedColumn): number | null;
+export declare function querySavedView(db: AbstractPowerSyncDatabase, input: {
     viewId: string;
     userId: string;
-}): Promise<SavedViewQueryScope>;
+    limit?: number;
+    offset?: number;
+    timeZone?: string;
+}): Promise<SavedViewQueryResult>;
 export declare function countSavedViewRows(db: AbstractPowerSyncDatabase, input: {
     viewId: string;
     userId: string;
-}, scope?: SavedViewQueryScope): Promise<number>;
-export declare function querySavedView(db: AbstractPowerSyncDatabase, input: {
+    timeZone?: string;
+}): Promise<number>;
+export declare function getSavedViewAnalytics(db: AbstractPowerSyncDatabase, input: {
+    viewId: string;
+    userId: string;
+    timeZone?: string;
+}): Promise<SavedViewAnalyticsRow & {
+    config: Pick<SavedViewConfig, 'stats' | 'charts' | 'summary' | 'computedColumns'>;
+}>;
+export type NoteDetailSection = {
     viewId: string;
+    name: string;
+    emoji: string | null;
+    totalCount: number;
+    columns: SavedViewProjectedColumn[];
+    rows: SavedViewProjectedRow[];
+};
+/** Saved views whose `noteDetail` rule matches the note, with `$self` bound to it. */
+export declare function getNoteDetailSections(db: AbstractPowerSyncDatabase, input: {
+    noteId: string;
     userId: string;
+    timeZone?: string;
     limit?: number;
-    offset?: number;
-}): Promise<SavedViewQueryResult>;
-export declare function getSavedViewFieldCatalog(db: AbstractPowerSyncDatabase, userId: string): Promise<SavedViewFieldCatalogItem[]>;
-export declare function inspectCreateSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewMutationPlan>;
-export declare function createSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewDefinition>;
-export declare function inspectUpdateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewMutationPlan>;
-export declare function updateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewDefinition>;
-export declare function inspectDeleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewMutationPlan>;
-export declare function deleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewDefinition>;
+}): Promise<NoteDetailSection[]>;
+export declare function createSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewInspection>;
+export declare function updateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewInspection>;
+export declare function deleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewInspection>;
+export declare function previewCreateSavedView(db: AbstractPowerSyncDatabase, input: CreateSavedViewInput): Promise<SavedViewMutationPreview>;
+export declare function previewUpdateSavedView(db: AbstractPowerSyncDatabase, input: UpdateSavedViewInput): Promise<SavedViewMutationPreview>;
+export declare function previewDeleteSavedView(db: AbstractPowerSyncDatabase, input: DeleteSavedViewInput): Promise<SavedViewMutationPreview>;