@dinoxx/dinox-cli 2.1.1 → 2.3.0

package/dist/vendor/electron/domain/saved-views.js

@@ -0,0 +1,1117 @@
+import { bindDetailSavedView, isPropertyType, isSavedViewDisplayOnlyField, isSavedViewDynamicDateFilterOperator, MAX_SAVED_VIEW_RELATIVE_DAYS, normalizeDatePropertyValue, parsePropertyDefConfigEnvelope, parsePropertyDefOptionsEnvelope, PROPERTY_DEF_CONFIG_KEY_PREFIX, resolvePropertyDefConfig, resolveStandaloneSavedViewFilter, SAVED_VIEW_LAYOUTS, SAVED_VIEW_PRIMARY_RESOURCE_TYPES, savedViewAnalyticsInputSchema, savedViewCatalogInputSchema, savedViewConfigSchema, savedViewCountInputSchema, savedViewCreateInputSchema, savedViewFilterSchema, savedViewFilterUsesSelf, savedViewNoteDetailInputSchema, savedViewPageInputSchema, savedViewSoftDeleteInputSchema, savedViewUpdateInputSchema, } from "../shared/index.js";
+import { uuidv7 } from "uuidv7";
+import { rowsFromResult } from "../rpc.js";
+import { defineCommand, defineReadModel, } from "../rpc.js";
+import { normalizeLimit } from "../sql-utils.js";
+import { fetchSavedViewAnalytics } from "./saved-view-analytics.js";
+import { resolveSavedViewRelativeDateRange, resolveSavedViewTimeZone, } from "./saved-view-relative-date.js";
+const SAVED_VIEW_TABLE = "c_saved_view";
+const ACTIVE_SAVED_VIEW_TYPE_SQL = `view_type IN (${SAVED_VIEW_LAYOUTS.map((layout) => `'${layout}'`).join(", ")})`;
+/** Same order as the phone sidebar: higher sort_rank (newer views) first. */
+const SAVED_VIEW_SIDEBAR_ORDER_SQL = "sort_rank DESC, updated_at DESC, id DESC";
+const NOTE_TABLE = "c_note";
+const PROPERTY_DEF_TABLE = "c_property_def";
+const CONFIG_PROPERTY_TABLE = "c_config_property";
+const ZETTEL_BOX_TABLE = "c_zettel_box";
+const SYSTEM_FIELD_SQL = {
+    "sys.id": "n.id",
+    "sys.title": "n.title",
+    "sys.created_at": "n.created_at",
+    "sys.updated_at": "n.updated_at",
+    "sys.tags": "n.tags",
+    "sys.zettel_boxes": "n.zettel_boxes",
+    "sys.source": "n.source",
+    "sys.type": "n.type",
+    "sys.starred_at": "n.starred_at",
+    "sys.images": "n.images",
+    "sys.primary_resource_type": notePrimaryResourceTypeSql("n"),
+};
+const SYSTEM_FIELD_SEMANTICS = {
+    "sys.title": { type: "text" },
+    "sys.created_at": { type: "date", dateMode: "datetime" },
+    "sys.updated_at": { type: "date", dateMode: "datetime" },
+    "sys.tags": { type: "list", propertyType: "multi_select" },
+    "sys.zettel_boxes": { type: "list", propertyType: "relation" },
+    "sys.source": { type: "text" },
+    "sys.type": { type: "text" },
+    "sys.starred_at": { type: "date", dateMode: "datetime" },
+    "sys.images": { type: "text" },
+    "sys.primary_resource_type": { type: "select" },
+    "sys.cover": { type: "text", displayOnly: true },
+    "sys.audio": { type: "text", displayOnly: true },
+    "sys.video": { type: "text", displayOnly: true },
+    "sys.file": { type: "text", displayOnly: true },
+};
+function notePrimaryResourceTypeSql(noteTable) {
+    const detail = `CASE WHEN json_valid(${noteTable}.audio_detail) THEN ${noteTable}.audio_detail ELSE '{}' END`;
+    const legacyType = `json_extract(${detail}, '$.type')`;
+    return `NULLIF(COALESCE((SELECT CASE
+    WHEN lower(primary_resource.mime_type) LIKE 'audio/%' THEN 'audio'
+    WHEN lower(primary_resource.mime_type) LIKE 'video/%' THEN 'video'
+    WHEN lower(primary_resource.mime_type) LIKE 'image/%' THEN 'image'
+    WHEN primary_resource.category = 'audios' THEN 'audio'
+    WHEN primary_resource.category = 'videos' THEN 'video'
+    WHEN primary_resource.category = 'images' THEN 'image'
+    WHEN primary_resource.category IN ('documents', 'files') THEN 'file'
+    WHEN lower(primary_resource.mime_type) LIKE 'application/%' OR lower(primary_resource.mime_type) LIKE 'text/%' THEN 'file'
+    ELSE '' END FROM c_resource AS primary_resource
+    WHERE primary_resource.id = ${noteTable}.resource_id AND primary_resource.is_del = 0),
+    CASE WHEN ${legacyType} IN ('audio', 'video', 'file', 'image') THEN ${legacyType} END), '')`;
+}
+const TEXT_FILTER_OPERATORS = new Set([
+    "equals",
+    "notEquals",
+    "contains",
+    "notContains",
+    "isEmpty",
+    "isNotEmpty",
+]);
+const LIST_FILTER_OPERATORS = new Set([
+    "contains",
+    "notContains",
+    "isEmpty",
+    "isNotEmpty",
+]);
+const SELECT_FILTER_OPERATORS = new Set([
+    "equals",
+    "notEquals",
+    "isEmpty",
+    "isNotEmpty",
+]);
+const ORDERABLE_FILTER_OPERATORS = new Set([
+    "equals",
+    "notEquals",
+    "greaterThan",
+    "greaterThanOrEqual",
+    "lessThan",
+    "lessThanOrEqual",
+    "isEmpty",
+    "isNotEmpty",
+]);
+const DATE_FILTER_OPERATORS = new Set([
+    ...ORDERABLE_FILTER_OPERATORS,
+    "withinLastDays",
+    "isToday",
+    "isThisWeek",
+    "isThisMonth",
+]);
+const BOOLEAN_FILTER_OPERATORS = new Set([
+    "equals",
+    "notEquals",
+    "isEmpty",
+    "isNotEmpty",
+]);
+export function createSavedViewReadModels() {
+    return [
+        defineReadModel({
+            name: "savedViews.snapshot",
+            inputSchema: savedViewPageInputSchema,
+            tables: () => [SAVED_VIEW_TABLE, NOTE_TABLE, PROPERTY_DEF_TABLE, CONFIG_PROPERTY_TABLE, ZETTEL_BOX_TABLE],
+            fetch: (db, input) => db.readTransaction(async (tx) => {
+                const scope = await resolveSavedViewQueryScope(tx, input);
+                const rows = await fetchSavedViewScopedPage(tx, input, scope);
+                const total_count = await countSavedViewScopedRows(tx, input, scope);
+                return [{ rows, total_count }];
+            }),
+        }),
+        defineReadModel({
+            name: "savedViews.analytics",
+            inputSchema: savedViewAnalyticsInputSchema,
+            tables: () => [SAVED_VIEW_TABLE, NOTE_TABLE, PROPERTY_DEF_TABLE, CONFIG_PROPERTY_TABLE, ZETTEL_BOX_TABLE],
+            fetch: (db, input) => db.readTransaction(async (tx) => {
+                const scope = await resolveSavedViewQueryScope(tx, input);
+                return [await fetchSavedViewAnalytics(tx, input, scope)];
+            }),
+        }),
+        defineReadModel({
+            name: "savedViews.noteDetail",
+            inputSchema: savedViewNoteDetailInputSchema,
+            tables: () => [
+                SAVED_VIEW_TABLE,
+                NOTE_TABLE,
+                PROPERTY_DEF_TABLE,
+                CONFIG_PROPERTY_TABLE,
+                ZETTEL_BOX_TABLE,
+            ],
+            fetch: (db, input) => db.readTransaction((tx) => fetchSavedViewNoteDetail(tx, input)),
+        }),
+        defineReadModel({
+            name: "savedViews.catalog",
+            inputSchema: savedViewCatalogInputSchema,
+            tables: () => [SAVED_VIEW_TABLE],
+            fetch: fetchSavedViewCatalog,
+        }),
+        defineReadModel({
+            name: "savedViews.page",
+            inputSchema: savedViewPageInputSchema,
+            tables: () => [
+                SAVED_VIEW_TABLE,
+                NOTE_TABLE,
+                PROPERTY_DEF_TABLE,
+                CONFIG_PROPERTY_TABLE,
+                ZETTEL_BOX_TABLE,
+            ],
+            fetch: fetchSavedViewPage,
+        }),
+        defineReadModel({
+            name: "savedViews.count",
+            inputSchema: savedViewCountInputSchema,
+            tables: () => [
+                SAVED_VIEW_TABLE,
+                NOTE_TABLE,
+                PROPERTY_DEF_TABLE,
+                CONFIG_PROPERTY_TABLE,
+            ],
+            fetch: fetchSavedViewCount,
+        }),
+    ];
+}
+export function createSavedViewCommands() {
+    return [
+        defineCommand({
+            name: "savedViews.create",
+            inputSchema: savedViewCreateInputSchema,
+            run: async (db, input) => ({
+                result: await createSavedView(db, input),
+                affectedTables: [SAVED_VIEW_TABLE],
+            }),
+        }),
+        defineCommand({
+            name: "savedViews.update",
+            inputSchema: savedViewUpdateInputSchema,
+            run: async (db, input) => {
+                const changed = await updateSavedView(db, input);
+                return {
+                    result: changed,
+                    affectedTables: changed ? [SAVED_VIEW_TABLE] : [],
+                };
+            },
+        }),
+        defineCommand({
+            name: "savedViews.softDelete",
+            inputSchema: savedViewSoftDeleteInputSchema,
+            run: async (db, input) => {
+                const changed = await softDeleteSavedView(db, input);
+                return {
+                    result: changed,
+                    affectedTables: changed ? [SAVED_VIEW_TABLE] : [],
+                };
+            },
+        }),
+    ];
+}
+async function fetchSavedViewCatalog(db, input) {
+    const limit = normalizeLimit(input.limit, 200, 5000);
+    if (limit <= 0)
+        return [];
+    return rowsFromResult(await db.getAll(`
+        SELECT
+          id,
+          user_id,
+          name,
+          emoji,
+          filter_json,
+          view_type,
+          config_json,
+          template_id,
+          group_id,
+          sort_rank,
+          pinned_at,
+          created_at,
+          updated_at,
+          is_del
+	        FROM c_saved_view
+	        WHERE user_id = ?
+	          AND ${ACTIVE_SAVED_VIEW_TYPE_SQL}
+	          AND (is_del IS NULL OR is_del = 0)
+        ORDER BY ${SAVED_VIEW_SIDEBAR_ORDER_SQL}
+        LIMIT ?
+      `, [input.userId, limit]));
+}
+async function fetchSavedViewDefinition(executor, input) {
+    return await executor.getOptional(`
+	      SELECT id, name, emoji, filter_json, view_type, config_json, updated_at
+		      FROM c_saved_view
+	      WHERE id = ?
+	        AND user_id = ?
+	        AND ${ACTIVE_SAVED_VIEW_TYPE_SQL}
+	        AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.viewId, input.userId]);
+}
+function parseStoredJson(raw, schema, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw ?? "");
+    }
+    catch {
+        throw new Error(`SAVED_VIEW_INVALID_${label}`);
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`SAVED_VIEW_INVALID_${label}`);
+    }
+    return result.data;
+}
+export async function resolveSavedViewQueryScope(executor, input) {
+    const definition = await fetchSavedViewDefinition(executor, input);
+    if (!definition) {
+        throw new Error("SAVED_VIEW_NOT_FOUND");
+    }
+    const storedFilter = parseStoredJson(definition.filter_json, savedViewFilterSchema, "FILTER");
+    const config = parseStoredJson(definition.config_json, savedViewConfigSchema, "CONFIG");
+    const filter = resolveStandaloneSavedViewFilter(config, storedFilter);
+    return compileResolvedSavedViewScope(executor, input, definition, filter, config);
+}
+const NOTE_DETAIL_VIEW_CAP = 20;
+const NOTE_DETAIL_CATALOG_LIMIT = 200;
+async function compileResolvedSavedViewScope(executor, input, definition, filter, config) {
+    const unboundSelf = savedViewFilterUsesSelf(filter);
+    const semantics = await validateSavedViewSemantics(executor, input.userId, unboundSelf ? { ...filter, root: null } : filter, config);
+    const timeZone = resolveSavedViewTimeZone(input.timeZone);
+    return {
+        definition,
+        filter,
+        config,
+        semantics,
+        where: unboundSelf
+            ? { sql: "0", params: [] }
+            : compileFilter(filter, semantics, { timeZone }),
+        order: compileOrder(config, semantics),
+    };
+}
+export async function fetchSavedViewNoteDetail(executor, input) {
+    const hostRow = await executor.getOptional(`
+      SELECT
+        id, title, source, type, created_at, updated_at, starred_at,
+        tags, zettel_boxes, properties
+      FROM c_note
+      WHERE id = ?
+        AND user_no = ?
+        AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.noteId, input.userId]);
+    if (!hostRow?.id)
+        return [];
+    const host = savedViewSelfHostFromNote(hostRow);
+    const views = await executor.getAll(`
+      SELECT id, name, emoji, filter_json, view_type, config_json, updated_at
+      FROM c_saved_view
+      WHERE user_id = ?
+        AND ${ACTIVE_SAVED_VIEW_TYPE_SQL}
+        AND (is_del IS NULL OR is_del = 0)
+      ORDER BY ${SAVED_VIEW_SIDEBAR_ORDER_SQL}
+      LIMIT ?
+    `, [input.userId, NOTE_DETAIL_CATALOG_LIMIT]);
+    const limit = normalizeLimit(input.limit, 6, 100);
+    const sections = [];
+    for (const view of views) {
+        if (sections.length >= NOTE_DETAIL_VIEW_CAP)
+            break;
+        const section = await loadNoteDetailSection(executor, input, host, view, limit);
+        if (section)
+            sections.push(section);
+    }
+    return sections;
+}
+async function loadNoteDetailSection(executor, input, host, view, limit) {
+    let storedFilter;
+    let config;
+    try {
+        storedFilter = parseStoredJson(view.filter_json, savedViewFilterSchema, "FILTER");
+        config = parseStoredJson(view.config_json, savedViewConfigSchema, "CONFIG");
+    }
+    catch {
+        return null;
+    }
+    const filter = bindDetailSavedView({ config, filter: storedFilter }, host);
+    if (!filter)
+        return null;
+    let scope;
+    try {
+        scope = await compileResolvedSavedViewScope(executor, input, view, filter, config);
+    }
+    catch {
+        return null;
+    }
+    const pageInput = {
+        viewId: view.id,
+        userId: input.userId,
+        timeZone: input.timeZone,
+        limit,
+        offset: 0,
+    };
+    const rows = await fetchSavedViewScopedPage(executor, pageInput, scope);
+    const total_count = await countSavedViewScopedRows(executor, pageInput, scope);
+    return {
+        view_id: view.id,
+        name: view.name?.trim() || "",
+        emoji: view.emoji?.trim() || null,
+        total_count,
+        rows,
+    };
+}
+function savedViewSelfHostFromNote(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        source: row.source,
+        type: row.type,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        starredAt: row.starred_at,
+        tags: parseSavedViewStringList(row.tags),
+        zettelBoxes: parseSavedViewStringList(row.zettel_boxes),
+        properties: parseSavedViewSelfProperties(row.properties),
+    };
+}
+function parseSavedViewStringList(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        return parsed.filter((item) => typeof item === "string");
+    }
+    catch {
+        return null;
+    }
+}
+function parseSavedViewSelfProperties(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        const properties = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            const normalized = normalizeSavedViewSelfProperty(value);
+            if (normalized !== undefined)
+                properties[key] = normalized;
+        }
+        return properties;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSavedViewSelfProperty(value) {
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (!Array.isArray(value))
+        return undefined;
+    const scalars = value.filter((item) => typeof item === "string" ||
+        typeof item === "number" ||
+        typeof item === "boolean");
+    return scalars.length === value.length ? scalars : undefined;
+}
+export async function fetchSavedViewScopedPage(executor, input, scope) {
+    const resolvedScope = scope ?? (await resolveSavedViewQueryScope(executor, input));
+    const limit = normalizeLimit(input.limit, 100, 500);
+    const offset = Math.max(0, Math.trunc(input.offset ?? 0));
+    // Resolve box labels only for the selected page, not rows considered by the sort.
+    return rowsFromResult(await executor.getAll(`
+        WITH page AS MATERIALIZED (
+          SELECT n.id
+          FROM c_note AS n
+          WHERE n.user_no = ?
+            AND (n.is_del IS NULL OR n.is_del = 0)
+            AND (${resolvedScope.where.sql})
+          ORDER BY ${resolvedScope.order.sql}
+          LIMIT ? OFFSET ?
+        )
+        SELECT
+          n.id,
+          n.title,
+          n.created_at,
+          n.updated_at,
+          n.tags,
+          n.zettel_boxes,
+          (
+            SELECT json_group_array(
+              json_object(
+                'fullPath', saved_view_box.display_path,
+                'color', saved_view_box.color
+              )
+            )
+            FROM (
+              SELECT
+                COALESCE(
+                  NULLIF(trim(box.path), ''),
+                  NULLIF(trim(box.name), '')
+                ) AS display_path,
+                NULLIF(trim(box.color), '') AS color
+              FROM json_each(
+                CASE
+                  WHEN json_valid(n.zettel_boxes) THEN n.zettel_boxes
+                  ELSE '[]'
+                END
+              ) AS box_ref
+              JOIN c_zettel_box AS box
+                ON box.id = CAST(box_ref.value AS TEXT)
+              WHERE (box.is_del IS NULL OR box.is_del = 0)
+                AND COALESCE(
+                  NULLIF(trim(box.path), ''),
+                  NULLIF(trim(box.name), '')
+                ) IS NOT NULL
+              ORDER BY CAST(box_ref.key AS INTEGER)
+            ) AS saved_view_box
+          ) AS zettel_box_details,
+		  n.source,
+		  n.type,
+		  n.starred_at,
+		  n.properties,
+		  n.images,
+		  ${notePrimaryResourceTypeSql("n")} AS primary_resource_type
+        FROM page JOIN c_note AS n ON n.id = page.id
+        ORDER BY ${resolvedScope.order.sql}
+      `, [
+        input.userId,
+        ...resolvedScope.where.params,
+        ...resolvedScope.order.params,
+        limit,
+        offset,
+        ...resolvedScope.order.params,
+    ]));
+}
+export async function countSavedViewScopedRows(executor, input, scope) {
+    const resolvedScope = scope ?? (await resolveSavedViewQueryScope(executor, input));
+    const rows = rowsFromResult(await executor.getAll(`
+        SELECT COUNT(*) AS total_count
+        FROM c_note AS n
+        WHERE n.user_no = ?
+          AND (n.is_del IS NULL OR n.is_del = 0)
+          AND (${resolvedScope.where.sql})
+      `, [input.userId, ...resolvedScope.where.params]));
+    const total = Number(rows[0]?.total_count ?? 0);
+    return Number.isFinite(total) ? Math.max(0, Math.trunc(total)) : 0;
+}
+export async function filterSavedViewNoteIds(executor, input, scope) {
+    const noteIds = Array.from(new Set(input.noteIds.map((id) => id.trim()).filter(Boolean))).slice(0, 200);
+    if (noteIds.length === 0)
+        return [];
+    const resolvedScope = scope ?? (await resolveSavedViewQueryScope(executor, input));
+    const placeholders = noteIds.map(() => "?").join(", ");
+    const rows = rowsFromResult(await executor.getAll(`
+        SELECT n.id
+        FROM c_note AS n
+        WHERE n.user_no = ?
+          AND (n.is_del IS NULL OR n.is_del = 0)
+          AND (${resolvedScope.where.sql})
+          AND n.id IN (${placeholders})
+      `, [input.userId, ...resolvedScope.where.params, ...noteIds]));
+    const allowed = new Set(rows.map((row) => row.id?.trim()).filter(Boolean));
+    return noteIds.filter((id) => allowed.has(id));
+}
+async function fetchSavedViewPage(db, input) {
+    return fetchSavedViewScopedPage(db, input);
+}
+async function fetchSavedViewCount(db, input) {
+    return [{ total_count: await countSavedViewScopedRows(db, input) }];
+}
+function propertyJsonPath(field) {
+    const key = field.slice("prop.".length);
+    const escaped = key.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+    return `$."${escaped}"`;
+}
+function compileField(field) {
+    const systemSql = SYSTEM_FIELD_SQL[field];
+    if (systemSql) {
+        return { sql: systemSql, params: [] };
+    }
+    if (!field.startsWith("prop.") || field.length <= "prop.".length) {
+        throw new Error("SAVED_VIEW_INVALID_FIELD");
+    }
+    return {
+        sql: "json_extract(CASE WHEN json_valid(n.properties) THEN n.properties ELSE '{}' END, ?)",
+        params: [propertyJsonPath(field)],
+    };
+}
+function requireConditionValue(condition) {
+    if (condition.value === undefined || condition.value === null) {
+        throw new Error("SAVED_VIEW_FILTER_VALUE_REQUIRED");
+    }
+    return condition.value;
+}
+function normalizeSqlParameter(value) {
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    return value;
+}
+function compileCondition(condition, semantics, options = {}) {
+    const field = compileField(condition.field);
+    const value = condition.value;
+    const semantic = semantics?.get(condition.field) ?? SYSTEM_FIELD_SEMANTICS[condition.field];
+    if (semantic?.propertyType === "relation" &&
+        (condition.operator === "equals" || condition.operator === "notEquals") &&
+        value !== undefined &&
+        value !== null) {
+        return compileContains(field, value, condition.operator === "notEquals", semantic);
+    }
+    if (isSavedViewDynamicDateFilterOperator(condition.operator)) {
+        return compileDynamicDateCondition(field, condition.operator, condition.value, semantic, options);
+    }
+    switch (condition.operator) {
+        case "equals":
+            if (value === undefined || value === null) {
+                return compileEmptyCheck(field, true);
+            }
+            return comparison(field, "=", value, semantic, 0);
+        case "notEquals":
+            if (value === undefined || value === null) {
+                return compileEmptyCheck(field, false);
+            }
+            return comparison(field, "!=", value, semantic, 1);
+        case "contains":
+            return compileContains(field, requireConditionValue(condition), false, semantic);
+        case "notContains":
+            return compileContains(field, requireConditionValue(condition), true, semantic);
+        case "greaterThan":
+            return comparison(field, ">", requireConditionValue(condition), semantic);
+        case "greaterThanOrEqual":
+            return comparison(field, ">=", requireConditionValue(condition), semantic);
+        case "lessThan":
+            return comparison(field, "<", requireConditionValue(condition), semantic);
+        case "lessThanOrEqual":
+            return comparison(field, "<=", requireConditionValue(condition), semantic);
+        case "isEmpty":
+            return compileEmptyCheck(field, true);
+        case "isNotEmpty":
+            return compileEmptyCheck(field, false);
+        default:
+            throw new Error("SAVED_VIEW_INVALID_OPERATOR");
+    }
+}
+function compileDynamicDateCondition(field, operator, value, semantic, options) {
+    if (semantic?.type !== "date") {
+        throw new Error("SAVED_VIEW_OPERATOR_TYPE_MISMATCH");
+    }
+    const range = resolveSavedViewRelativeDateRange({
+        operator,
+        value,
+        now: options.now,
+        timeZone: options.timeZone,
+    });
+    const dateTime = semantic.dateMode === "datetime";
+    const sqlFunction = dateTime ? "julianday" : "date";
+    const start = dateTime ? range.startInstant : range.startDate;
+    const endExclusive = dateTime
+        ? range.endInstantExclusive
+        : range.endDateExclusive;
+    return {
+        sql: `COALESCE((${sqlFunction}(${field.sql}) >= ${sqlFunction}(?) AND ${sqlFunction}(${field.sql}) < ${sqlFunction}(?)), 0)`,
+        params: [
+            ...field.params,
+            start,
+            ...field.params,
+            endExclusive,
+        ],
+    };
+}
+function compileContains(field, value, negated, semantic) {
+    const normalizedValue = normalizeSqlParameter(value);
+    if (semantic?.type !== "list") {
+        const predicate = `COALESCE(
+		  instr(lower(CAST(${field.sql} AS TEXT)), lower(CAST(? AS TEXT))) > 0,
+		  0
+		)`;
+        return {
+            sql: negated ? `(NOT (${predicate}))` : predicate,
+            params: [...field.params, normalizedValue],
+        };
+    }
+    const predicate = `EXISTS (
+	    SELECT 1
+	    FROM (SELECT ${field.sql} AS field_value) AS saved_view_field
+	    WHERE json_valid(CAST(saved_view_field.field_value AS TEXT))
+	      AND json_type(CAST(saved_view_field.field_value AS TEXT)) = 'array'
+	      AND EXISTS (
+	        SELECT 1
+	        FROM json_each(CAST(saved_view_field.field_value AS TEXT)) AS saved_view_item
+	        WHERE CAST(saved_view_item.value AS TEXT) = CAST(? AS TEXT)
+	      )
+	  )`;
+    return {
+        sql: negated ? `(NOT (${predicate}))` : predicate,
+        params: [...field.params, normalizedValue],
+    };
+}
+function comparison(field, operator, value, semantic, nullResult = 0) {
+    const isDate = semantic?.type === "date";
+    const dateFunction = semantic?.dateMode === "datetime" || (operator !== "=" && operator !== "!=")
+        ? "julianday"
+        : "date";
+    const left = isDate
+        ? `${dateFunction}(${field.sql})`
+        : semantic?.type === "number"
+            ? `CAST(${field.sql} AS REAL)`
+            : field.sql;
+    const right = isDate
+        ? `${dateFunction}(?)`
+        : semantic?.type === "number"
+            ? "CAST(? AS REAL)"
+            : "?";
+    return {
+        sql: `COALESCE((${left} ${operator} ${right}), ${nullResult})`,
+        params: [...field.params, normalizeSqlParameter(value)],
+    };
+}
+function compileEmptyCheck(field, empty) {
+    const emptySql = `(${field.sql} IS NULL OR trim(CAST(${field.sql} AS TEXT)) = '' OR CAST(${field.sql} AS TEXT) = '[]')`;
+    return {
+        sql: empty ? emptySql : `(NOT ${emptySql})`,
+        params: [...field.params, ...field.params, ...field.params],
+    };
+}
+function compileFilterNode(node, budget, depth, semantics, options = {}) {
+    budget.nodes += 1;
+    if (depth > 8 || budget.nodes > 100) {
+        throw new Error("SAVED_VIEW_FILTER_TOO_COMPLEX");
+    }
+    if (node.kind === "condition") {
+        return compileCondition(node, semantics, options);
+    }
+    if (node.kind === "not") {
+        const child = compileFilterNode(node.child, budget, depth + 1, semantics, options);
+        return { sql: `(NOT (${child.sql}))`, params: child.params };
+    }
+    const children = node.children.map((child) => compileFilterNode(child, budget, depth + 1, semantics, options));
+    if (children.length === 0) {
+        return { sql: node.operator === "and" ? "1" : "0", params: [] };
+    }
+    return {
+        sql: `(${children.map((child) => `(${child.sql})`).join(node.operator === "and" ? " AND " : " OR ")})`,
+        params: children.flatMap((child) => child.params),
+    };
+}
+export function compileFilter(filter, semantics, options = {}) {
+    return filter.root
+        ? compileFilterNode(filter.root, { nodes: 0 }, 1, semantics, options)
+        : { sql: "1", params: [] };
+}
+export function compileOrder(config, semantics) {
+    const clauses = [];
+    const params = [];
+    for (const sort of config.sort ?? []) {
+        const field = compileField(sort.field);
+        const direction = sort.direction === "asc" ? "ASC" : "DESC";
+        const semantic = semantics?.get(sort.field) ?? SYSTEM_FIELD_SEMANTICS[sort.field];
+        if (semantic?.type === "list" ||
+            semantic?.displayOnly ||
+            sort.field === "sys.images" ||
+            sort.field === "sys.primary_resource_type") {
+            throw new Error("SAVED_VIEW_SORT_TYPE_UNSUPPORTED");
+        }
+        clauses.push(`CASE WHEN ${field.sql} IS NULL OR trim(CAST(${field.sql} AS TEXT)) = '' THEN 1 ELSE 0 END ASC`);
+        params.push(...field.params, ...field.params);
+        if (semantic?.type === "select" && (semantic.options?.length ?? 0) > 0) {
+            const options = [...(semantic.options ?? [])].sort((left, right) => left.sortRank - right.sortRank || left.id.localeCompare(right.id));
+            clauses.push(`CASE WHEN ${field.sql} IN (${options.map(() => "?").join(", ")}) THEN 0 ELSE 1 END ASC`, `CASE ${field.sql} ${options.map(() => "WHEN ? THEN ?").join(" ")} ELSE NULL END ${direction}`, `${field.sql} COLLATE NOCASE ${direction}`);
+            params.push(...field.params, ...options.map((option) => option.id), ...field.params, ...options.flatMap((option) => [option.id, option.sortRank]), ...field.params);
+            continue;
+        }
+        const orderExpression = semantic?.type === "date"
+            ? `julianday(${field.sql})`
+            : semantic?.type === "number"
+                ? `CAST(${field.sql} AS REAL)`
+                : `${field.sql} COLLATE NOCASE`;
+        clauses.push(`${orderExpression} ${direction}`);
+        params.push(...field.params);
+    }
+    if (clauses.length === 0) {
+        clauses.push("COALESCE(n.updated_at, n.created_at, n.id) DESC");
+    }
+    clauses.push("n.id DESC");
+    return { sql: clauses.join(", "), params };
+}
+function collectFilterConditions(node, conditions) {
+    if (!node)
+        return;
+    if (node.kind === "condition") {
+        conditions.push(node);
+        return;
+    }
+    if (node.kind === "not") {
+        collectFilterConditions(node.child, conditions);
+        return;
+    }
+    for (const child of node.children) {
+        collectFilterConditions(child, conditions);
+    }
+}
+function propertyDefToSemantic(type, optionsJson, configJson) {
+    let options;
+    if (type === "select" || type === "multi_select" || type === "status") {
+        const parsedOptions = parsePropertyDefOptionsEnvelope(optionsJson);
+        if (parsedOptions.status === "invalid" || parsedOptions.status === "unsupported") {
+            throw new Error("SAVED_VIEW_PROPERTY_OPTIONS_INVALID");
+        }
+        if (parsedOptions.status === "empty" || parsedOptions.status === "legacy") {
+            throw new Error("SAVED_VIEW_PROPERTY_OPTIONS_MIGRATION_REQUIRED");
+        }
+        options = parsedOptions.options;
+    }
+    const parsedConfig = parsePropertyDefConfigEnvelope(configJson);
+    const config = parsedConfig.status === "empty"
+        ? resolvePropertyDefConfig(type, null)
+        : parsedConfig.status === "valid" && parsedConfig.config.type === type
+            ? parsedConfig.config
+            : undefined;
+    if (parsedConfig.status !== "empty" && !config) {
+        throw new Error("SAVED_VIEW_PROPERTY_CONFIG_INVALID");
+    }
+    switch (type) {
+        case "number":
+            return { type: "number", propertyType: type };
+        case "date":
+            return {
+                type: "date",
+                propertyType: type,
+                dateMode: config?.type === "date" ? config.mode : "date",
+            };
+        case "select":
+        case "status":
+            return {
+                type: "select",
+                propertyType: type,
+                options,
+            };
+        case "unique_id":
+            return { type: "number", propertyType: type };
+        case "checkbox":
+            return { type: "boolean", propertyType: type };
+        case "multi_select": {
+            return {
+                type: "list",
+                propertyType: type,
+                options,
+            };
+        }
+        case "relation":
+            return { type: "list", propertyType: type };
+        default:
+            return { type: "text", propertyType: type };
+    }
+}
+function assertConditionSemantics(condition, semantic) {
+    const allowedOperators = semantic.displayOnly
+        ? new Set()
+        : condition.field === "sys.images"
+            ? new Set(["isEmpty", "isNotEmpty"])
+            : condition.field === "sys.primary_resource_type"
+                ? new Set(["equals", "notEquals", "isEmpty", "isNotEmpty"])
+                : semantic.propertyType === "relation"
+                    ? new Set([...SELECT_FILTER_OPERATORS, ...LIST_FILTER_OPERATORS])
+                    : semantic.type === "text"
+                        ? TEXT_FILTER_OPERATORS
+                        : semantic.type === "select"
+                            ? SELECT_FILTER_OPERATORS
+                            : semantic.type === "list"
+                                ? LIST_FILTER_OPERATORS
+                                : semantic.type === "boolean"
+                                    ? BOOLEAN_FILTER_OPERATORS
+                                    : semantic.type === "date"
+                                        ? DATE_FILTER_OPERATORS
+                                        : ORDERABLE_FILTER_OPERATORS;
+    if (!allowedOperators.has(condition.operator)) {
+        throw new Error("SAVED_VIEW_OPERATOR_TYPE_MISMATCH");
+    }
+    if (condition.field === "sys.primary_resource_type" &&
+        (condition.operator === "equals" || condition.operator === "notEquals") &&
+        !SAVED_VIEW_PRIMARY_RESOURCE_TYPES.some((option) => option === condition.value)) {
+        throw new Error("SAVED_VIEW_VALUE_TYPE_MISMATCH");
+    }
+    const value = condition.value;
+    if (isSavedViewDynamicDateFilterOperator(condition.operator)) {
+        if (condition.operator === "withinLastDays" &&
+            (typeof value !== "number" ||
+                !Number.isInteger(value) ||
+                value < 1 ||
+                value > MAX_SAVED_VIEW_RELATIVE_DAYS)) {
+            throw new Error("SAVED_VIEW_INVALID_RELATIVE_DAYS");
+        }
+        if (condition.operator !== "withinLastDays" &&
+            value !== undefined &&
+            value !== null) {
+            throw new Error("SAVED_VIEW_VALUE_TYPE_MISMATCH");
+        }
+        return;
+    }
+    if (value === undefined || value === null)
+        return;
+    if (semantic.type === "number" && typeof value !== "number") {
+        throw new Error("SAVED_VIEW_VALUE_TYPE_MISMATCH");
+    }
+    if (semantic.type === "boolean" && typeof value !== "boolean") {
+        throw new Error("SAVED_VIEW_VALUE_TYPE_MISMATCH");
+    }
+    if ((semantic.type === "text" ||
+        semantic.type === "select" ||
+        semantic.type === "list" ||
+        semantic.type === "date") &&
+        typeof value !== "string") {
+        throw new Error("SAVED_VIEW_VALUE_TYPE_MISMATCH");
+    }
+    if (semantic.type === "date" &&
+        typeof value === "string" &&
+        normalizeDatePropertyValue(value, semantic.dateMode ?? "date") === null) {
+        throw new Error("SAVED_VIEW_INVALID_DATE_VALUE");
+    }
+    if ((semantic.propertyType === "select" ||
+        semantic.propertyType === "multi_select") &&
+        typeof value === "string" &&
+        !(semantic.options ?? []).some((option) => option.id === value)) {
+        throw new Error("SAVED_VIEW_OPTION_NOT_FOUND");
+    }
+}
+async function validateSavedViewSemantics(executor, userId, filter, config) {
+    const conditions = [];
+    collectFilterConditions(filter?.root ?? null, conditions);
+    const fields = new Set();
+    for (const condition of conditions)
+        fields.add(condition.field);
+    for (const column of config?.columns ?? [])
+        fields.add(column.field);
+    for (const sort of config?.sort ?? [])
+        fields.add(sort.field);
+    const propertyKeys = Array.from(new Set([...fields]
+        .filter((field) => field.startsWith("prop."))
+        .map((field) => field.slice("prop.".length))));
+    const propertySemantics = new Map();
+    if (propertyKeys.length > 0) {
+        const placeholders = propertyKeys.map(() => "?").join(", ");
+        const rows = await executor.getAll(`
+	        SELECT
+	          ranked.id,
+	          ranked.key,
+	          ranked.type,
+	          ranked.options,
+	          (
+	            SELECT cp.c_value
+	            FROM ${CONFIG_PROPERTY_TABLE} AS cp
+	            WHERE cp.user_id = ranked.user_id
+	              AND cp.c_key = '${PROPERTY_DEF_CONFIG_KEY_PREFIX}' || ranked.id
+	              AND (cp.is_del IS NULL OR cp.is_del = 0)
+	            ORDER BY COALESCE(cp.updated_at, cp.created_at, cp.id) DESC, cp.id DESC
+	            LIMIT 1
+	          ) AS config_json
+	        FROM (
+	          SELECT
+	            id,
+	            user_id,
+	            key,
+	            type,
+	            options,
+	            ROW_NUMBER() OVER (
+	              PARTITION BY key
+	              ORDER BY
+	                COALESCE(NULLIF(updated_at, ''), NULLIF(created_at, ''), id) DESC,
+	                id DESC
+	            ) AS key_rank
+	          FROM ${PROPERTY_DEF_TABLE}
+	          WHERE user_id = ?
+	            AND key IN (${placeholders})
+	            AND (is_del IS NULL OR is_del = 0)
+	        ) AS ranked
+	        WHERE ranked.key_rank = 1
+	      `, [userId, ...propertyKeys]);
+        for (const row of rows) {
+            if (row.key && isPropertyType(row.type)) {
+                propertySemantics.set(row.key, propertyDefToSemantic(row.type, row.options, row.config_json));
+            }
+        }
+        for (const key of propertyKeys) {
+            if (!propertySemantics.has(key)) {
+                throw new Error("SAVED_VIEW_PROPERTY_NOT_FOUND");
+            }
+        }
+    }
+    const semantics = new Map();
+    for (const field of fields) {
+        const semantic = field.startsWith("prop.")
+            ? propertySemantics.get(field.slice("prop.".length))
+            : SYSTEM_FIELD_SEMANTICS[field];
+        if (!semantic) {
+            throw new Error("SAVED_VIEW_INVALID_FIELD");
+        }
+        semantics.set(field, semantic);
+    }
+    for (const condition of conditions) {
+        assertConditionSemantics(condition, semantics.get(condition.field));
+    }
+    for (const sort of config?.sort ?? []) {
+        const semantic = semantics.get(sort.field);
+        if (semantic?.type === "list" ||
+            semantic?.displayOnly ||
+            isSavedViewDisplayOnlyField(sort.field) ||
+            sort.field === "sys.images" ||
+            sort.field === "sys.primary_resource_type") {
+            throw new Error("SAVED_VIEW_SORT_TYPE_UNSUPPORTED");
+        }
+    }
+    return semantics;
+}
+function normalizeSavedViewDateValues(filter, semantics) {
+    const normalizeNode = (node) => {
+        if (node.kind === "condition") {
+            if (semantics.get(node.field)?.type === "date" &&
+                typeof node.value === "string") {
+                const semantic = semantics.get(node.field);
+                const normalized = normalizeDatePropertyValue(node.value, semantic.dateMode ?? "date");
+                if (!normalized)
+                    throw new Error("SAVED_VIEW_INVALID_DATE_VALUE");
+                return { ...node, value: normalized };
+            }
+            return node;
+        }
+        if (node.kind === "not") {
+            return { ...node, child: normalizeNode(node.child) };
+        }
+        return { ...node, children: node.children.map(normalizeNode) };
+    };
+    return {
+        ...filter,
+        root: filter.root ? normalizeNode(filter.root) : null,
+    };
+}
+async function createSavedView(db, input) {
+    return await db.writeTransaction(async (tx) => {
+        const semanticTypes = await validateSavedViewSemantics(tx, input.userId, input.filter, input.config);
+        const normalizedFilter = normalizeSavedViewDateValues(input.filter, semanticTypes);
+        const id = uuidv7();
+        const rank = input.sortRank ??
+            (await tx.getOptional(`
+            SELECT COALESCE(MAX(sort_rank), -1) + 1 AS next_rank
+            FROM c_saved_view
+            WHERE user_id = ?
+              AND (is_del IS NULL OR is_del = 0)
+          `, [input.userId]))?.next_rank ??
+            0;
+        await tx.execute(`
+          INSERT INTO c_saved_view (
+            id,
+            user_id,
+            name,
+            emoji,
+            filter_json,
+            view_type,
+            config_json,
+            template_id,
+            group_id,
+            sort_rank,
+            pinned_at,
+            created_at,
+            updated_at,
+            is_del
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+        `, [
+            id,
+            input.userId,
+            input.name,
+            input.emoji ?? null,
+            JSON.stringify(normalizedFilter),
+            input.config.layout,
+            JSON.stringify(input.config),
+            input.templateId ?? null,
+            input.groupId ?? null,
+            rank,
+            input.pinnedAt ?? null,
+            input.updatedAt,
+            input.updatedAt,
+        ]);
+        return id;
+    });
+}
+async function findOwnedSavedView(executor, input) {
+    return await executor.getOptional(`
+      SELECT id
+	      FROM c_saved_view
+	      WHERE id = ?
+	        AND user_id = ?
+	        AND ${ACTIVE_SAVED_VIEW_TYPE_SQL}
+	        AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.id, input.userId]);
+}
+async function updateSavedView(db, input) {
+    return await db.writeTransaction(async (tx) => {
+        const target = await findOwnedSavedView(tx, input);
+        if (!target)
+            return false;
+        let normalizedFilter = input.filter;
+        if (input.filter !== undefined || input.config !== undefined) {
+            const semanticTypes = await validateSavedViewSemantics(tx, input.userId, input.filter, input.config);
+            if (input.filter) {
+                normalizedFilter = normalizeSavedViewDateValues(input.filter, semanticTypes);
+            }
+        }
+        const assignments = [];
+        const params = [];
+        const set = (column, value) => {
+            assignments.push(`${column} = ?`);
+            params.push(value);
+        };
+        if (input.name !== undefined)
+            set("name", input.name);
+        if (input.emoji !== undefined)
+            set("emoji", input.emoji);
+        if (normalizedFilter !== undefined) {
+            set("filter_json", JSON.stringify(normalizedFilter));
+        }
+        if (input.config !== undefined) {
+            set("config_json", JSON.stringify(input.config));
+            set("view_type", input.config.layout);
+        }
+        if (input.templateId !== undefined)
+            set("template_id", input.templateId);
+        if (input.groupId !== undefined)
+            set("group_id", input.groupId);
+        if (input.sortRank !== undefined)
+            set("sort_rank", input.sortRank);
+        if (input.pinnedAt !== undefined)
+            set("pinned_at", input.pinnedAt);
+        set("updated_at", input.updatedAt);
+        set("is_del", 0);
+        await tx.execute(`UPDATE c_saved_view SET ${assignments.join(", ")} WHERE id = ? AND user_id = ?`, [...params, input.id, input.userId]);
+        return true;
+    });
+}
+async function softDeleteSavedView(db, input) {
+    return await db.writeTransaction(async (tx) => {
+        const target = await findOwnedSavedView(tx, input);
+        if (!target)
+            return false;
+        await tx.execute(`
+        UPDATE c_saved_view
+        SET is_del = 1,
+          updated_at = ?
+        WHERE id = ?
+          AND user_id = ?
+      `, [input.updatedAt, input.id, input.userId]);
+        return true;
+    });
+}
+/**
+ * Read-modify-write of one view's config inside a single write transaction, for writers
+ * that only touch the analytics layer (Agent tools). `apply` receives the stored config and
+ * returns the next one; filter, columns and sort stay as stored.
+ */
+export async function updateSavedViewConfig(db, input, apply) {
+    return await db.writeTransaction(async (tx) => {
+        const definition = await fetchSavedViewDefinition(tx, {
+            viewId: input.viewId,
+            userId: input.userId,
+        });
+        if (!definition)
+            throw new Error("SAVED_VIEW_NOT_FOUND");
+        const previous = parseStoredJson(definition.config_json, savedViewConfigSchema, "CONFIG");
+        const next = savedViewConfigSchema.parse(apply(previous));
+        await tx.execute("UPDATE c_saved_view SET config_json = ?, updated_at = ? WHERE id = ? AND user_id = ?", [JSON.stringify(next), input.updatedAt, input.viewId, input.userId]);
+        return { previous, next };
+    });
+}