@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/vendor/electron/domain/properties.js

@@ -0,0 +1,1549 @@
+// Generated by scripts/sync-electron-domain.ts from dinox-electron/packages/main/src/modules/powersync/typed-rpc/domain/properties.ts. Do not edit manually.
+/**
+ * Inputs: typed PowerSync read-model and command payloads for property definitions and note values.
+ * Outputs: catalog rows plus transactional definition, migration, and note-property mutations.
+ */
+import { ACTIVE_PROPERTY_TYPES, applyNotePropertySlotOperation, buildPropertyDefConfigKey, coercePropertyValue, DEFAULT_STATUS_OPTION_INPUTS, findPropertyOptionById, findPropertyOptionByLabel, getDefaultPropertyDefConfig, isIssuedUniqueId, isNumberPropertyValueAllowed, isPropertyKeyValid, isPropertyType, mergeNotePropertiesPatch, NOTE_PROPERTY_LIMITS, NUMBER_PROPERTY_PRESETS, normalizeDatePropertyValue, normalizeFilePropertyValue, normalizeNumberPropertyValue, normalizePlacePropertyValue, normalizePropertyDefConfig, normalizePropertyOptionLabel, normalizePropertyOptions, normalizeUniqueIdPrefix, normalizeUrlPropertyValue, parseNumberPropertyPreset, parsePropertyDefConfigEnvelope, parsePropertyDefOptionsEnvelope, parseStoredNoteProperties, parseUniqueIdPropertyConfig, propertyOptionLabelKey, PROPERTY_DEF_CONFIG_KEY_PREFIX, PROPERTY_OPTION_COLORS, PROPERTY_OPTION_LABEL_MAX_LENGTH, PROPERTY_OPTION_LIMITS, savedViewFilterSchema, serializeNumberPropertyPreset, serializePropertyDefConfig, serializePropertyDefOptions, serializeRawNoteProperties, serializeUniqueIdPropertyConfig, STATUS_PROPERTY_GROUPS, tryParseRawNoteProperties, } from "../shared/index.js";
+import { uuidv7 } from "uuidv7";
+import { z } from "zod";
+import { defineCommand, defineReadModel, } from "../rpc.js";
+import { normalizeLimit, normalizeOptionalString } from "../sql-utils.js";
+const PROPERTY_DEF_TABLE = "c_property_def";
+const CONFIG_PROPERTY_TABLE = "c_config_property";
+const NOTE_TABLE = "c_note";
+const SAVED_VIEW_TABLE = "c_saved_view";
+const PROPERTY_DEF_CONFIG_KEY_SQL_PREFIX = PROPERTY_DEF_CONFIG_KEY_PREFIX.replaceAll("'", "''");
+const NOTE_PROPERTY_KEY = z
+    .string()
+    .min(1)
+    .max(NOTE_PROPERTY_LIMITS.keyLength)
+    .refine(isPropertyKeyValid);
+const NOTE_PROPERTY_TEXT = z
+    .string()
+    .max(NOTE_PROPERTY_LIMITS.textLength)
+    .refine((value) => value.trim().length > 0, "Property value cannot be blank");
+const NOTE_PROPERTY_VALUE = z.union([
+    NOTE_PROPERTY_TEXT,
+    z.number().finite(),
+    z.boolean(),
+    z.array(NOTE_PROPERTY_TEXT).min(1).max(NOTE_PROPERTY_LIMITS.arrayLength),
+    z.custom((value) => {
+        const files = normalizeFilePropertyValue(value);
+        return files !== null && files.length > 0;
+    }, "Invalid file property value"),
+    z.custom((value) => normalizePlacePropertyValue(value) !== null, "Invalid place property value"),
+]);
+const NOTE_PROPERTIES_PATCH = z
+    .preprocess((patch, context) => {
+    if (patch && typeof patch === "object" && !Array.isArray(patch)) {
+        const invalidKey = Object.keys(patch).find((key) => !isPropertyKeyValid(key));
+        if (invalidKey !== undefined) {
+            context.addIssue({ code: "custom", message: "Invalid property key" });
+            return z.NEVER;
+        }
+    }
+    return patch;
+}, z.record(NOTE_PROPERTY_KEY, NOTE_PROPERTY_VALUE.nullable()))
+    .refine((patch) => Object.keys(patch).length > 0, "Property patch cannot be empty")
+    .refine((patch) => Object.keys(patch).length <= NOTE_PROPERTY_LIMITS.mutationKeys, "Property patch is too large");
+const NOTE_PROPERTY_VALUES = z
+    .preprocess((values, context) => {
+    if (values && typeof values === "object" && !Array.isArray(values)) {
+        const invalidKey = Object.keys(values).find((key) => !isPropertyKeyValid(key));
+        if (invalidKey !== undefined) {
+            context.addIssue({ code: "custom", message: "Invalid property key" });
+            return z.NEVER;
+        }
+    }
+    return values;
+}, z.record(NOTE_PROPERTY_KEY, NOTE_PROPERTY_VALUE))
+    .refine((values) => Object.keys(values).length > 0, "Property values cannot be empty")
+    .refine((values) => Object.keys(values).length <= NOTE_PROPERTY_LIMITS.mutationKeys, "Property values are too large");
+const PROPERTY_OPTION_INPUT_SCHEMA = z.object({
+    id: z.string().trim().min(1).max(200).optional(),
+    label: z.string().min(1).max(PROPERTY_OPTION_LABEL_MAX_LENGTH),
+    color: z.enum(PROPERTY_OPTION_COLORS).optional(),
+    sortRank: z.number().int().safe().optional(),
+    archived: z.boolean().optional(),
+    group: z.enum(STATUS_PROPERTY_GROUPS).optional(),
+});
+const PROPERTY_DEF_CONFIG_INPUT_SCHEMA = z.custom((value) => normalizePropertyDefConfig(value) !== undefined);
+const PROPERTY_DEF_CATALOG_INPUT = z.object({
+    userId: z.string().trim().min(1),
+    limit: z.number().int().positive().max(5000).optional(),
+});
+const PROPERTY_DEF_ENSURE_INPUT = z.object({
+    key: z.string().trim().min(1).max(64).refine(isPropertyKeyValid),
+    name: z.string().trim().max(120).nullable().optional(),
+    type: z.enum(ACTIVE_PROPERTY_TYPES).nullable().optional(),
+    optionItems: z.array(PROPERTY_OPTION_INPUT_SCHEMA).max(PROPERTY_OPTION_LIMITS.items).optional(),
+    uniqueIdPrefix: z.string().max(64).nullable().optional(),
+    numberPreset: z.enum(NUMBER_PROPERTY_PRESETS).nullable().optional(),
+    config: PROPERTY_DEF_CONFIG_INPUT_SCHEMA.optional(),
+    description: z.string().max(2000).nullable().optional(),
+    icon: z.string().max(120).nullable().optional(),
+    source: z.enum(["manual", "ai"]).nullable().optional(),
+    userId: z.string().trim().min(1),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const PROPERTY_DEF_CONFIGURE_INPUT = z
+    .object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    name: z.string().trim().max(120).nullable().optional(),
+    description: z.string().max(2000).nullable().optional(),
+    icon: z.string().max(120).nullable().optional(),
+    showOnCard: z.boolean().nullable().optional(),
+    sortRank: z.number().int().nullable().optional(),
+    options: z.array(PROPERTY_OPTION_INPUT_SCHEMA).max(PROPERTY_OPTION_LIMITS.items).optional(),
+    uniqueIdPrefix: z.string().max(64).nullable().optional(),
+    repairInvalidOptions: z.boolean().optional(),
+    config: PROPERTY_DEF_CONFIG_INPUT_SCHEMA.nullable().optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+})
+    .refine((input) => input.name !== undefined ||
+    input.description !== undefined ||
+    input.icon !== undefined ||
+    input.showOnCard !== undefined ||
+    input.sortRank !== undefined ||
+    input.options !== undefined ||
+    input.uniqueIdPrefix !== undefined ||
+    input.config !== undefined, {
+    message: "Property configure input cannot be empty",
+})
+    .refine((input) => !input.repairInvalidOptions || input.options !== undefined, {
+    message: "repairInvalidOptions requires replacement options",
+});
+const PROPERTY_DEF_MIGRATE_LEGACY_OPTIONS_INPUT = z.object({
+    userId: z.string().trim().min(1),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const PROPERTY_DEF_UPDATE_INPUT = z.object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    name: z.string().trim().max(120).nullable().optional(),
+    description: z.string().max(2000).nullable().optional(),
+    icon: z.string().max(120).nullable().optional(),
+    showOnCard: z.boolean().nullable().optional(),
+    sortRank: z.number().int().nullable().optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const PROPERTY_DEF_SOFT_DELETE_INPUT = z.object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const NOTE_PROPERTIES_UPDATE_INPUT = z.object({
+    noteId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    patch: NOTE_PROPERTIES_PATCH,
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const NOTE_PROPERTY_SLOTS_UPDATE_INPUT = z.object({
+    noteId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    operation: z.enum(["declare", "clear", "remove"]),
+    keys: z.array(NOTE_PROPERTY_KEY).min(1).max(NOTE_PROPERTY_LIMITS.mutationKeys),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const NOTE_PROPERTY_SLOTS_REORDER_INPUT = z.object({
+    noteId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    orderedKeys: z
+        .array(NOTE_PROPERTY_KEY)
+        .min(2)
+        .max(NOTE_PROPERTY_LIMITS.mutationKeys)
+        .refine((keys) => new Set(keys).size === keys.length, "Property slot order contains duplicates"),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+const NOTE_PROPERTIES_FILL_EMPTY_INPUT = z.object({
+    noteId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    values: NOTE_PROPERTY_VALUES,
+    updatedAt: z.string().trim().min(1).max(64),
+});
+export function createPropertyReadModels() {
+    return [
+        defineReadModel({
+            name: "properties.catalog",
+            inputSchema: PROPERTY_DEF_CATALOG_INPUT,
+            tables: () => [PROPERTY_DEF_TABLE, CONFIG_PROPERTY_TABLE],
+            fetch: fetchPropertyCatalog,
+        }),
+    ];
+}
+export function createPropertyCommands() {
+    return [
+        defineCommand({
+            name: "properties.ensure",
+            inputSchema: PROPERTY_DEF_ENSURE_INPUT,
+            run: async (db, input) => {
+                const result = await ensurePropertyDef(db, input);
+                return {
+                    result: result.id,
+                    affectedTables: affectedDefinitionTables(result),
+                };
+            },
+        }),
+        defineCommand({
+            name: "properties.configure",
+            inputSchema: PROPERTY_DEF_CONFIGURE_INPUT,
+            run: async (db, input) => {
+                const result = await configurePropertyDef(db, input);
+                return {
+                    result: result.changed,
+                    affectedTables: affectedDefinitionTables(result),
+                };
+            },
+        }),
+        defineCommand({
+            name: "properties.migrateLegacyOptions",
+            inputSchema: PROPERTY_DEF_MIGRATE_LEGACY_OPTIONS_INPUT,
+            run: async (db, input) => {
+                const result = await migrateLegacyPropertyOptions(db, input);
+                return {
+                    result,
+                    affectedTables: [
+                        ...(result.definitionsMigrated > 0 ? [PROPERTY_DEF_TABLE] : []),
+                        ...(result.notesUpdated > 0 ? [NOTE_TABLE] : []),
+                        ...(result.savedViewsUpdated > 0 ? [SAVED_VIEW_TABLE] : []),
+                    ],
+                };
+            },
+        }),
+        defineCommand({
+            name: "properties.update",
+            inputSchema: PROPERTY_DEF_UPDATE_INPUT,
+            run: async (db, input) => {
+                const changed = await updatePropertyDef(db, input);
+                return {
+                    result: changed,
+                    affectedTables: changed ? [PROPERTY_DEF_TABLE] : [],
+                };
+            },
+        }),
+        defineCommand({
+            name: "properties.softDelete",
+            inputSchema: PROPERTY_DEF_SOFT_DELETE_INPUT,
+            run: async (db, input) => {
+                const result = await softDeletePropertyDef(db, input);
+                return {
+                    result: result.definitionChanged,
+                    affectedTables: affectedDefinitionTables(result),
+                };
+            },
+        }),
+        defineCommand({
+            name: "notes.updateProperties",
+            inputSchema: NOTE_PROPERTIES_UPDATE_INPUT,
+            run: async (db, input) => {
+                const result = await updateNoteProperties(db, input);
+                return {
+                    result: result.noteChanged,
+                    affectedTables: [
+                        ...(result.noteChanged ? [NOTE_TABLE] : []),
+                        ...(result.definitionsChanged ? [PROPERTY_DEF_TABLE] : []),
+                    ],
+                };
+            },
+        }),
+        defineCommand({
+            name: "notes.updatePropertySlots",
+            inputSchema: NOTE_PROPERTY_SLOTS_UPDATE_INPUT,
+            run: async (db, input) => {
+                const changed = await updateNotePropertySlots(db, input);
+                return { result: changed, affectedTables: changed ? [NOTE_TABLE] : [] };
+            },
+        }),
+        defineCommand({
+            name: "notes.reorderPropertySlots",
+            inputSchema: NOTE_PROPERTY_SLOTS_REORDER_INPUT,
+            run: async (db, input) => {
+                const changed = await reorderNotePropertySlots(db, input);
+                return { result: changed, affectedTables: changed ? [NOTE_TABLE] : [] };
+            },
+        }),
+        defineCommand({
+            name: "notes.fillEmptyProperties",
+            inputSchema: NOTE_PROPERTIES_FILL_EMPTY_INPUT,
+            run: async (db, input) => {
+                const mutation = await fillEmptyNotePropertyValues(db, input);
+                return {
+                    result: mutation.result,
+                    affectedTables: [
+                        ...(mutation.result.appliedKeys.length > 0 ? [NOTE_TABLE] : []),
+                        ...(mutation.definitionsChanged ? [PROPERTY_DEF_TABLE] : []),
+                    ],
+                };
+            },
+        }),
+    ];
+}
+function affectedDefinitionTables(result) {
+    return [
+        ...(result.definitionChanged ? [PROPERTY_DEF_TABLE] : []),
+        ...(result.configChanged ? [CONFIG_PROPERTY_TABLE] : []),
+    ];
+}
+function isOptionPropertyType(type) {
+    return type === "select" || type === "multi_select" || type === "status";
+}
+function requireStoredPropertyType(value) {
+    if (!isPropertyType(value))
+        throw new Error("PROPERTY_DEF_TYPE_INVALID");
+    return value;
+}
+function configValueSubquery(alias) {
+    return `(
+		SELECT config.c_value
+		FROM c_config_property AS config
+		WHERE config.c_key = '${PROPERTY_DEF_CONFIG_KEY_SQL_PREFIX}' || ${alias}.id
+		  AND config.user_id = ${alias}.user_id
+		  AND (config.is_del IS NULL OR config.is_del = 0)
+		ORDER BY COALESCE(NULLIF(config.updated_at, ''), NULLIF(config.created_at, ''), config.id) DESC,
+		  config.id DESC
+		LIMIT 1
+	)`;
+}
+function propertyDefSelectList(alias) {
+    return `
+		${alias}.id AS id,
+		${alias}.user_id AS user_id,
+		${alias}.key AS key,
+		${alias}.name AS name,
+		${alias}.type AS type,
+		${alias}.options AS options,
+		${configValueSubquery(alias)} AS config_json,
+		${alias}.description AS description,
+		${alias}.icon AS icon,
+		${alias}.sort_rank AS sort_rank,
+		${alias}.show_on_card AS show_on_card,
+		${alias}.source AS source,
+		${alias}.created_at AS created_at,
+		${alias}.updated_at AS updated_at,
+		${alias}.is_del AS is_del
+	`;
+}
+async function loadLatestDefinitionByKey(executor, userId, key) {
+    return executor.getOptional(`
+		SELECT ${propertyDefSelectList("definition")}
+		FROM c_property_def AS definition
+		WHERE definition.user_id = ?
+		  AND definition.key = ?
+		ORDER BY COALESCE(definition.is_del, 0) ASC,
+		  COALESCE(NULLIF(definition.updated_at, ''), NULLIF(definition.created_at, ''), definition.id) DESC,
+		  definition.id DESC
+		LIMIT 1
+		`, [userId, key]);
+}
+async function loadDefinitionById(executor, id, userId) {
+    return executor.getOptional(`
+		SELECT ${propertyDefSelectList("definition")}
+		FROM c_property_def AS definition
+		WHERE definition.id = ?
+		  AND definition.user_id = ?
+		  AND (definition.is_del IS NULL OR definition.is_del = 0)
+		LIMIT 1
+		`, [id, userId]);
+}
+async function findPropertyConfigRow(executor, definitionId, userId) {
+    return executor.getOptional(`
+		SELECT id, c_value
+		FROM c_config_property
+		WHERE c_key = ?
+		  AND user_id = ?
+		  AND (is_del IS NULL OR is_del = 0)
+		ORDER BY COALESCE(NULLIF(updated_at, ''), NULLIF(created_at, ''), id) DESC,
+		  id DESC
+		LIMIT 1
+		`, [buildPropertyDefConfigKey(definitionId), userId]);
+}
+async function upsertPropertyConfig(executor, definitionId, userId, config, updatedAt) {
+    const serialized = serializePropertyDefConfig(config);
+    const existing = await findPropertyConfigRow(executor, definitionId, userId);
+    if (existing?.c_value === serialized)
+        return false;
+    if (existing) {
+        await executor.execute(`
+			UPDATE c_config_property
+			SET c_key = ?, c_value = ?, updated_at = ?, is_del = 0, user_id = ?
+			WHERE id = ?
+			`, [buildPropertyDefConfigKey(definitionId), serialized, updatedAt, userId, existing.id]);
+        return true;
+    }
+    await executor.execute(`
+		INSERT INTO c_config_property (
+		  id, c_key, c_value, created_at, updated_at, is_del, user_id, description
+		) VALUES (?, ?, ?, ?, ?, 0, ?, ?)
+		`, [
+        uuidv7(),
+        buildPropertyDefConfigKey(definitionId),
+        serialized,
+        updatedAt,
+        updatedAt,
+        userId,
+        "Property definition config",
+    ]);
+    return true;
+}
+async function clearPropertyConfig(executor, definitionId, userId, updatedAt) {
+    const key = buildPropertyDefConfigKey(definitionId);
+    const existing = await executor.getAll(`
+		SELECT id FROM c_config_property
+		WHERE c_key = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+		`, [key, userId]);
+    if (existing.length === 0)
+        return false;
+    await executor.execute(`
+		UPDATE c_config_property SET is_del = 1, updated_at = ?
+		WHERE c_key = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+		`, [updatedAt, key, userId]);
+    return true;
+}
+function nextOptionSortRank(options) {
+    const next = options.reduce((rank, option) => Math.max(rank, option.sortRank), -1) + 1;
+    if (!Number.isSafeInteger(next))
+        throw new Error("PROPERTY_OPTION_SORT_RANK_EXHAUSTED");
+    return next;
+}
+function createPropertyOption(label, sortRank, input) {
+    return {
+        id: uuidv7(),
+        label,
+        color: input?.color ?? "gray",
+        sortRank,
+        archived: input?.archived ?? false,
+        ...(input?.group ? { group: input.group } : {}),
+    };
+}
+function createOptionsForNewDefinition(items) {
+    const options = (items ?? []).map((item, index) => {
+        if (item.id !== undefined)
+            throw new Error("PROPERTY_OPTION_NEW_ID_FORBIDDEN");
+        const label = normalizePropertyOptionLabel(item.label);
+        if (!label)
+            throw new Error("PROPERTY_OPTION_LABEL_INVALID");
+        return createPropertyOption(label, item.sortRank ?? index, item);
+    });
+    const normalized = normalizePropertyOptions(options);
+    if (!normalized)
+        throw new Error("PROPERTY_OPTIONS_INVALID");
+    return normalized;
+}
+function replaceStableOptions(existing, inputs) {
+    const existingById = new Map(existing.map((option) => [option.id, option]));
+    const representedIds = new Set();
+    let nextRank = nextOptionSortRank(existing);
+    const next = inputs.map((input) => {
+        const label = normalizePropertyOptionLabel(input.label);
+        if (!label)
+            throw new Error("PROPERTY_OPTION_LABEL_INVALID");
+        if (input.id !== undefined) {
+            const current = existingById.get(input.id);
+            if (!current)
+                throw new Error("PROPERTY_OPTION_ID_UNKNOWN");
+            if (representedIds.has(input.id))
+                throw new Error("PROPERTY_OPTION_ID_DUPLICATE");
+            representedIds.add(input.id);
+            const group = input.group ?? current.group;
+            return {
+                id: current.id,
+                label,
+                color: input.color ?? current.color,
+                sortRank: input.sortRank ?? current.sortRank,
+                archived: input.archived ?? current.archived,
+                ...(group ? { group } : {}),
+            };
+        }
+        const option = createPropertyOption(label, input.sortRank ?? nextRank, input);
+        if (input.sortRank === undefined)
+            nextRank += 1;
+        return option;
+    });
+    for (const option of existing) {
+        if (!representedIds.has(option.id)) {
+            throw new Error("PROPERTY_OPTION_REMOVAL_REQUIRES_ARCHIVE");
+        }
+    }
+    const normalized = normalizePropertyOptions(next);
+    if (!normalized)
+        throw new Error("PROPERTY_OPTIONS_INVALID");
+    return normalized;
+}
+function stableOptionsFromRow(row) {
+    const parsed = parsePropertyDefOptionsEnvelope(row.options);
+    if (parsed.status === "valid")
+        return parsed.options;
+    if (parsed.status === "empty" || parsed.status === "legacy") {
+        throw new Error("PROPERTY_OPTIONS_MIGRATION_REQUIRED");
+    }
+    throw new Error("PROPERTY_OPTIONS_INVALID");
+}
+function normalizeExplicitConfig(config, type) {
+    const normalized = normalizePropertyDefConfig(config);
+    if (!normalized)
+        throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+    if (normalized.type !== type)
+        throw new Error("PROPERTY_DEF_CONFIG_TYPE_MISMATCH");
+    return normalized;
+}
+function optionsJsonForNewDefinition(type, input) {
+    if (type === "number") {
+        return input.numberPreset && input.numberPreset !== "number"
+            ? serializeNumberPropertyPreset(input.numberPreset)
+            : null;
+    }
+    if (type === "unique_id") {
+        return serializeUniqueIdPropertyConfig({
+            prefix: normalizeUniqueIdPrefix(input.uniqueIdPrefix, normalizeOptionalString(input.name)),
+            next: 1,
+        });
+    }
+    if (!isOptionPropertyType(type))
+        return null;
+    const items = type === "status" && input.optionItems === undefined
+        ? DEFAULT_STATUS_OPTION_INPUTS
+        : input.optionItems;
+    return serializePropertyDefOptions(createOptionsForNewDefinition(items));
+}
+async function ensurePropertyDef(db, input) {
+    const key = input.key.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    if (!isPropertyKeyValid(key) || !userId || !updatedAt) {
+        throw new Error("PROPERTY_DEF_ENSURE_INPUT_INVALID");
+    }
+    let result = null;
+    await db.writeTransaction(async (executor) => {
+        const existing = await loadLatestDefinitionByKey(executor, userId, key);
+        if (!existing) {
+            const type = input.type ?? "text";
+            const hasOptionInput = input.optionItems !== undefined;
+            if (type === "unique_id" && hasOptionInput) {
+                throw new Error("PROPERTY_OPTIONS_TYPE_MISMATCH");
+            }
+            if (!isOptionPropertyType(type) && type !== "unique_id" && hasOptionInput) {
+                throw new Error("PROPERTY_OPTIONS_TYPE_MISMATCH");
+            }
+            const options = optionsJsonForNewDefinition(type, input);
+            const explicitConfig = input.config === undefined ? undefined : normalizeExplicitConfig(input.config, type);
+            const config = explicitConfig ?? getDefaultPropertyDefConfig(type, "new");
+            const id = uuidv7();
+            await executor.execute(`
+				INSERT INTO c_property_def (
+				  id, user_id, key, name, type, options, description, icon,
+				  sort_rank, show_on_card, source, created_at, updated_at, is_del
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, ?, 0)
+				`, [
+                id,
+                userId,
+                key,
+                normalizeOptionalString(input.name) ?? key,
+                type,
+                options,
+                normalizeOptionalString(input.description),
+                normalizeOptionalString(input.icon),
+                normalizeOptionalString(input.source) ?? "manual",
+                updatedAt,
+                updatedAt,
+            ]);
+            const configChanged = config
+                ? await upsertPropertyConfig(executor, id, userId, config, updatedAt)
+                : false;
+            result = { id, definitionChanged: true, configChanged };
+            return;
+        }
+        const existingType = requireStoredPropertyType(existing.type);
+        if (input.type !== undefined && input.type !== null && input.type !== existingType) {
+            throw new Error("PROPERTY_DEF_TYPE_CONFLICT");
+        }
+        const hasOptionInput = input.optionItems !== undefined;
+        if (!isOptionPropertyType(existingType) && hasOptionInput) {
+            throw new Error("PROPERTY_OPTIONS_TYPE_MISMATCH");
+        }
+        let serializedOptions = existing.options;
+        let optionsChanged = false;
+        if (isOptionPropertyType(existingType)) {
+            const parsed = parsePropertyDefOptionsEnvelope(existing.options);
+            if (parsed.status === "invalid" || parsed.status === "unsupported") {
+                throw new Error("PROPERTY_OPTIONS_INVALID");
+            }
+            if (input.optionItems !== undefined) {
+                if (parsed.status !== "valid")
+                    throw new Error("PROPERTY_OPTIONS_MIGRATION_REQUIRED");
+                const configured = replaceStableOptions(parsed.options, input.optionItems);
+                const serialized = serializePropertyDefOptions(configured);
+                optionsChanged = serialized !== serializePropertyDefOptions(parsed.options);
+                serializedOptions = serialized;
+            }
+        }
+        let configChanged = false;
+        if (input.config !== undefined) {
+            configChanged = await upsertPropertyConfig(executor, existing.id, userId, normalizeExplicitConfig(input.config, existingType), updatedAt);
+        }
+        const isDeleted = Number(existing.is_del ?? 0) !== 0;
+        if (isDeleted) {
+            await executor.execute(`
+				UPDATE c_property_def
+				SET name = ?, type = ?, options = ?, description = ?, icon = ?,
+				  sort_rank = ?, show_on_card = ?, source = ?, is_del = 0, updated_at = ?
+				WHERE id = ? AND user_id = ?
+				`, [
+                normalizeOptionalString(input.name) ?? normalizeOptionalString(existing.name) ?? key,
+                existingType,
+                serializedOptions,
+                normalizeOptionalString(input.description) ?? normalizeOptionalString(existing.description),
+                normalizeOptionalString(input.icon) ?? normalizeOptionalString(existing.icon),
+                Number.isFinite(existing.sort_rank) ? Math.trunc(Number(existing.sort_rank)) : 0,
+                Number(existing.show_on_card ?? 0) === 1 ? 1 : 0,
+                normalizeOptionalString(input.source) ??
+                    normalizeOptionalString(existing.source) ??
+                    "manual",
+                updatedAt,
+                existing.id,
+                userId,
+            ]);
+            result = {
+                id: existing.id,
+                definitionChanged: true,
+                configChanged,
+            };
+            return;
+        }
+        if (optionsChanged) {
+            await executor.execute(`UPDATE c_property_def SET options = ?, updated_at = ? WHERE id = ? AND user_id = ?`, [serializedOptions, updatedAt, existing.id, userId]);
+        }
+        result = {
+            id: existing.id,
+            definitionChanged: optionsChanged,
+            configChanged,
+        };
+    });
+    if (!result)
+        throw new Error("PROPERTY_DEF_ENSURE_FAILED");
+    return result;
+}
+async function configurePropertyDef(db, input) {
+    const id = input.id.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let result = {
+        changed: false,
+        definitionChanged: false,
+        configChanged: false,
+    };
+    await db.writeTransaction(async (executor) => {
+        const row = await loadDefinitionById(executor, id, userId);
+        if (!row)
+            return;
+        const type = requireStoredPropertyType(row.type);
+        const assignments = [];
+        const params = [];
+        if (input.options !== undefined) {
+            if (!isOptionPropertyType(type)) {
+                if (input.options.length > 0)
+                    throw new Error("PROPERTY_OPTIONS_TYPE_MISMATCH");
+                if (input.repairInvalidOptions)
+                    throw new Error("PROPERTY_OPTIONS_TYPE_MISMATCH");
+            }
+            else {
+                const parsed = parsePropertyDefOptionsEnvelope(row.options);
+                let currentSerialized;
+                let next;
+                if (parsed.status === "valid") {
+                    currentSerialized = serializePropertyDefOptions(parsed.options);
+                    next = replaceStableOptions(parsed.options, input.options);
+                }
+                else if ((parsed.status === "invalid" || parsed.status === "unsupported") &&
+                    input.repairInvalidOptions) {
+                    if (input.options.some((option) => option.id !== undefined)) {
+                        throw new Error("PROPERTY_OPTION_REPAIR_ID_FORBIDDEN");
+                    }
+                    currentSerialized = row.options ?? "";
+                    next = createOptionsForNewDefinition(input.options);
+                }
+                else if (parsed.status === "empty" || parsed.status === "legacy") {
+                    throw new Error("PROPERTY_OPTIONS_MIGRATION_REQUIRED");
+                }
+                else {
+                    throw new Error("PROPERTY_OPTIONS_INVALID");
+                }
+                const nextSerialized = serializePropertyDefOptions(next);
+                if (currentSerialized !== nextSerialized) {
+                    assignments.push("options = ?");
+                    params.push(nextSerialized);
+                }
+            }
+        }
+        if (input.uniqueIdPrefix !== undefined) {
+            if (type !== "unique_id")
+                throw new Error("PROPERTY_UNIQUE_ID_TYPE_MISMATCH");
+            const current = parseUniqueIdPropertyConfig(row.options);
+            if (!current && row.options?.trim()) {
+                throw new Error("PROPERTY_UNIQUE_ID_CONFIG_INVALID");
+            }
+            const nextSerialized = serializeUniqueIdPropertyConfig({
+                prefix: normalizeUniqueIdPrefix(input.uniqueIdPrefix, row.name ?? row.key),
+                next: current?.next ?? 1,
+            });
+            if (nextSerialized !== (row.options ?? "")) {
+                assignments.push("options = ?");
+                params.push(nextSerialized);
+            }
+        }
+        if (input.name !== undefined) {
+            const value = normalizeOptionalString(input.name) ?? "";
+            if (value !== (row.name ?? "")) {
+                assignments.push("name = ?");
+                params.push(value);
+            }
+        }
+        if (input.description !== undefined) {
+            const value = normalizeOptionalString(input.description);
+            if (value !== normalizeOptionalString(row.description)) {
+                assignments.push("description = ?");
+                params.push(value);
+            }
+        }
+        if (input.icon !== undefined) {
+            const value = normalizeOptionalString(input.icon);
+            if (value !== normalizeOptionalString(row.icon)) {
+                assignments.push("icon = ?");
+                params.push(value);
+            }
+        }
+        if (input.showOnCard !== undefined) {
+            const value = input.showOnCard === true ? 1 : 0;
+            if (value !== (Number(row.show_on_card ?? 0) === 1 ? 1 : 0)) {
+                assignments.push("show_on_card = ?");
+                params.push(value);
+            }
+        }
+        if (input.sortRank !== undefined) {
+            const value = input.sortRank ?? 0;
+            if (value !== Number(row.sort_rank ?? 0)) {
+                assignments.push("sort_rank = ?");
+                params.push(value);
+            }
+        }
+        const normalizedConfig = input.config && input.config !== null
+            ? normalizeExplicitConfig(input.config, type)
+            : undefined;
+        const definitionChanged = assignments.length > 0;
+        if (definitionChanged) {
+            assignments.push("updated_at = ?");
+            params.push(updatedAt, id, userId);
+            await executor.execute(`UPDATE c_property_def SET ${assignments.join(", ")} WHERE id = ? AND user_id = ?`, params);
+        }
+        let configChanged = false;
+        if (input.config === null) {
+            configChanged = await clearPropertyConfig(executor, id, userId, updatedAt);
+        }
+        else if (normalizedConfig !== undefined) {
+            configChanged = await upsertPropertyConfig(executor, id, userId, normalizedConfig, updatedAt);
+        }
+        result = {
+            changed: definitionChanged || configChanged,
+            definitionChanged,
+            configChanged,
+        };
+    });
+    return result;
+}
+async function updatePropertyDef(db, input) {
+    const id = input.id.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let changed = false;
+    await db.writeTransaction(async (executor) => {
+        const row = await loadDefinitionById(executor, id, userId);
+        if (!row)
+            return;
+        const nextName = input.name === undefined
+            ? (normalizeOptionalString(row.name) ?? normalizeOptionalString(row.key) ?? "")
+            : (normalizeOptionalString(input.name) ?? "");
+        const nextDescription = input.description === undefined
+            ? normalizeOptionalString(row.description)
+            : normalizeOptionalString(input.description);
+        const nextIcon = input.icon === undefined
+            ? normalizeOptionalString(row.icon)
+            : normalizeOptionalString(input.icon);
+        const nextShowOnCard = input.showOnCard === undefined
+            ? Number(row.show_on_card ?? 0) === 1
+            : input.showOnCard === true;
+        const nextSortRank = input.sortRank === undefined
+            ? Number.isFinite(row.sort_rank)
+                ? Math.trunc(Number(row.sort_rank))
+                : 0
+            : (input.sortRank ?? 0);
+        if (nextName === (row.name ?? "") &&
+            nextDescription === normalizeOptionalString(row.description) &&
+            nextIcon === normalizeOptionalString(row.icon) &&
+            nextShowOnCard === (Number(row.show_on_card ?? 0) === 1) &&
+            nextSortRank === Number(row.sort_rank ?? 0)) {
+            return;
+        }
+        await executor.execute(`
+			UPDATE c_property_def
+			SET name = ?, description = ?, icon = ?, show_on_card = ?, sort_rank = ?, updated_at = ?
+			WHERE id = ? AND user_id = ?
+			`, [
+            nextName,
+            nextDescription,
+            nextIcon,
+            nextShowOnCard ? 1 : 0,
+            nextSortRank,
+            updatedAt,
+            id,
+            userId,
+        ]);
+        changed = true;
+    });
+    return changed;
+}
+async function softDeletePropertyDef(db, input) {
+    const id = input.id.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let result = {
+        definitionChanged: false,
+        configChanged: false,
+    };
+    await db.writeTransaction(async (executor) => {
+        const row = await executor.getOptional(`
+			SELECT id FROM c_property_def
+			WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+			LIMIT 1
+			`, [id, userId]);
+        if (!row)
+            return;
+        await executor.execute(`UPDATE c_property_def SET is_del = 1, updated_at = ? WHERE id = ? AND user_id = ?`, [updatedAt, id, userId]);
+        result = {
+            definitionChanged: true,
+            configChanged: await clearPropertyConfig(executor, id, userId, updatedAt),
+        };
+    });
+    return result;
+}
+export async function fetchPropertyCatalog(db, input) {
+    const userId = input.userId.trim();
+    const limit = normalizeLimit(input.limit, 1000, 5000);
+    if (limit <= 0)
+        return [];
+    return db.getAll(`
+		WITH ranked_property_defs AS (
+		  SELECT definition.*,
+		    ROW_NUMBER() OVER (
+		      PARTITION BY definition.key
+		      ORDER BY
+		        COALESCE(NULLIF(definition.updated_at, ''), NULLIF(definition.created_at, ''), definition.id) DESC,
+		        definition.id DESC
+		    ) AS key_rank
+		  FROM c_property_def AS definition
+		  WHERE definition.user_id = ?
+		    AND definition.key IS NOT NULL
+		    AND trim(definition.key) <> ''
+		    AND (definition.is_del IS NULL OR definition.is_del = 0)
+		)
+		SELECT ${propertyDefSelectList("ranked")}
+		FROM ranked_property_defs AS ranked
+		WHERE ranked.key_rank = 1
+		ORDER BY COALESCE(ranked.sort_rank, 0) ASC,
+		  COALESCE(NULLIF(ranked.created_at, ''), ranked.id) ASC,
+		  ranked.id ASC
+		LIMIT ?
+		`, [userId, limit]);
+}
+function addMigrationLabel(definition, value, active) {
+    const label = normalizePropertyOptionLabel(value);
+    if (!label)
+        throw new Error("PROPERTY_LEGACY_OPTION_LABEL_INVALID");
+    const identity = propertyOptionLabelKey(label);
+    const existing = definition.labels.get(identity);
+    if (existing) {
+        if (active)
+            existing.active = true;
+        return;
+    }
+    if (definition.labels.size >= PROPERTY_OPTION_LIMITS.items) {
+        throw new Error("PROPERTY_OPTION_LIMIT_EXCEEDED");
+    }
+    definition.labels.set(identity, { label, active });
+}
+function parseSavedViewFilterForMigration(raw) {
+    if (!raw || !raw.trim())
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    const result = savedViewFilterSchema.safeParse(parsed);
+    if (!result.success)
+        return undefined;
+    return result.data;
+}
+function rawMentionsAnyPropertyKey(raw, keys, prefix = "", suffix = "") {
+    if (!raw)
+        return false;
+    for (const key of keys) {
+        if (raw.includes(`${prefix}${key}${suffix}`))
+            return true;
+    }
+    return false;
+}
+function rawMentionsAnySavedViewPropertyField(raw, keys) {
+    if (!raw)
+        return false;
+    const keySet = new Set(keys);
+    for (const match of raw.matchAll(/"field"\s*:\s*("(?:\\.|[^"\\])*")/g)) {
+        const token = match[1];
+        if (!token)
+            continue;
+        try {
+            const field = JSON.parse(token);
+            if (typeof field === "string" &&
+                field.startsWith("prop.") &&
+                keySet.has(field.slice("prop.".length))) {
+                return true;
+            }
+        }
+        catch {
+            // The complete field string token is malformed, so it cannot identify a key.
+        }
+    }
+    return false;
+}
+function visitSavedViewFilterConditions(node, visit) {
+    if (!node)
+        return;
+    if (node.kind === "condition") {
+        visit(node);
+        return;
+    }
+    if (node.kind === "not") {
+        visitSavedViewFilterConditions(node.child, visit);
+        return;
+    }
+    for (const child of node.children)
+        visitSavedViewFilterConditions(child, visit);
+}
+function buildMigrationOptions(definition) {
+    definition.options = [...definition.labels.values()].map((entry, index) => ({
+        id: uuidv7(),
+        label: entry.label,
+        color: "gray",
+        sortRank: index,
+        archived: !entry.active,
+    }));
+    definition.optionByLabel = new Map(definition.options.map((option) => [propertyOptionLabelKey(option.label), option]));
+}
+function migratedOptionForLabel(definition, value) {
+    const label = normalizePropertyOptionLabel(value);
+    if (!label)
+        throw new Error("PROPERTY_LEGACY_OPTION_LABEL_INVALID");
+    const option = definition.optionByLabel.get(propertyOptionLabelKey(label));
+    if (!option)
+        throw new Error("PROPERTY_LEGACY_OPTION_NOT_PLANNED");
+    return option;
+}
+function canonicalOptionIds(ids, options) {
+    const byId = new Map(options.map((option) => [option.id, option]));
+    return [...new Set(ids)].sort((leftId, rightId) => {
+        const left = byId.get(leftId);
+        const right = byId.get(rightId);
+        if (!left || !right)
+            return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
+        return (left.sortRank - right.sortRank ||
+            (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    });
+}
+async function migrateLegacyPropertyOptions(db, input) {
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let result = {
+        definitionsMigrated: 0,
+        optionsCreated: 0,
+        notesUpdated: 0,
+        savedViewsUpdated: 0,
+    };
+    await db.writeTransaction(async (executor) => {
+        const rows = await executor.getAll(`
+			WITH ranked_property_defs AS (
+			  SELECT definition.*,
+			    ROW_NUMBER() OVER (
+			      PARTITION BY definition.key
+			      ORDER BY
+			        COALESCE(NULLIF(definition.updated_at, ''), NULLIF(definition.created_at, ''), definition.id) DESC,
+			        definition.id DESC
+			    ) AS key_rank
+			  FROM c_property_def AS definition
+			  WHERE definition.user_id = ?
+			    AND definition.type IN ('select', 'multi_select')
+			    AND (definition.is_del IS NULL OR definition.is_del = 0)
+			)
+			SELECT ${propertyDefSelectList("ranked")}
+			FROM ranked_property_defs AS ranked
+			WHERE ranked.key_rank = 1
+			ORDER BY ranked.key ASC, ranked.id ASC
+			`, [userId]);
+        const definitions = new Map();
+        for (const row of rows) {
+            if (!row.key || (row.type !== "select" && row.type !== "multi_select"))
+                continue;
+            const parsed = parsePropertyDefOptionsEnvelope(row.options);
+            if (parsed.status === "valid")
+                continue;
+            if (parsed.status === "invalid" || parsed.status === "unsupported") {
+                throw new Error("PROPERTY_OPTIONS_INVALID");
+            }
+            const definition = {
+                row,
+                type: row.type,
+                labels: new Map(),
+                options: [],
+                optionByLabel: new Map(),
+            };
+            for (const label of parsed.status === "legacy" ? parsed.labels : []) {
+                addMigrationLabel(definition, label, true);
+            }
+            definitions.set(row.key, definition);
+        }
+        if (definitions.size === 0)
+            return;
+        const noteRows = await executor.getAll(`
+			SELECT id, properties
+			FROM c_note
+			WHERE user_no = ? AND (is_del IS NULL OR is_del = 0)
+			ORDER BY id ASC
+			`, [userId]);
+        const parsedNotes = noteRows.map((row) => {
+            const properties = tryParseRawNoteProperties(row.properties);
+            if (properties === null) {
+                if (rawMentionsAnyPropertyKey(row.properties, definitions.keys(), '"', '"')) {
+                    throw new Error("NOTE_PROPERTIES_CORRUPT");
+                }
+                return { ...row, parsed: null };
+            }
+            for (const [key, definition] of definitions) {
+                if (!Object.hasOwn(properties, key) || properties[key] === null)
+                    continue;
+                const value = properties[key];
+                if (definition.type === "select") {
+                    if (typeof value !== "string")
+                        throw new Error("PROPERTY_LEGACY_VALUE_INVALID");
+                    addMigrationLabel(definition, value, false);
+                }
+                else {
+                    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+                        throw new Error("PROPERTY_LEGACY_VALUE_INVALID");
+                    }
+                    for (const item of value)
+                        addMigrationLabel(definition, item, false);
+                }
+            }
+            return { ...row, parsed: properties };
+        });
+        const savedViewRows = await executor.getAll(`
+			SELECT id, filter_json
+			FROM c_saved_view
+			WHERE user_id = ? AND (is_del IS NULL OR is_del = 0)
+			ORDER BY id ASC
+			`, [userId]);
+        const parsedViews = savedViewRows.map((row) => {
+            const filter = parseSavedViewFilterForMigration(row.filter_json);
+            if (filter === undefined) {
+                if (rawMentionsAnySavedViewPropertyField(row.filter_json, definitions.keys())) {
+                    throw new Error("SAVED_VIEW_FILTER_CORRUPT");
+                }
+                return { ...row, filter: null };
+            }
+            if (filter) {
+                visitSavedViewFilterConditions(filter.root, (condition) => {
+                    if (!condition.field.startsWith("prop.") || typeof condition.value !== "string") {
+                        return;
+                    }
+                    const definition = definitions.get(condition.field.slice("prop.".length));
+                    if (definition)
+                        addMigrationLabel(definition, condition.value, false);
+                });
+            }
+            return { ...row, filter };
+        });
+        for (const definition of definitions.values())
+            buildMigrationOptions(definition);
+        for (const note of parsedNotes) {
+            if (!note.parsed)
+                continue;
+            const next = Object.fromEntries(Object.entries(note.parsed));
+            let changed = false;
+            for (const [key, definition] of definitions) {
+                if (!Object.hasOwn(next, key) || next[key] === null)
+                    continue;
+                const value = next[key];
+                if (definition.type === "select") {
+                    const id = migratedOptionForLabel(definition, value).id;
+                    if (value !== id) {
+                        next[key] = id;
+                        changed = true;
+                    }
+                }
+                else {
+                    const ids = canonicalOptionIds(value.map((item) => migratedOptionForLabel(definition, item).id), definition.options);
+                    if (!Array.isArray(value) ||
+                        value.length !== ids.length ||
+                        value.some((item, index) => item !== ids[index])) {
+                        next[key] = ids;
+                        changed = true;
+                    }
+                }
+            }
+            if (changed) {
+                await executor.execute(`
+					UPDATE c_note SET properties = ?
+					WHERE id = ? AND user_no = ? AND (is_del IS NULL OR is_del = 0)
+					`, [serializeRawNoteProperties(next), note.id, userId]);
+                result.notesUpdated += 1;
+            }
+        }
+        for (const view of parsedViews) {
+            if (!view.filter)
+                continue;
+            let changed = false;
+            visitSavedViewFilterConditions(view.filter.root, (condition) => {
+                if (!condition.field.startsWith("prop.") || typeof condition.value !== "string") {
+                    return;
+                }
+                const definition = definitions.get(condition.field.slice("prop.".length));
+                if (!definition)
+                    return;
+                const id = migratedOptionForLabel(definition, condition.value).id;
+                if (condition.value !== id) {
+                    condition.value = id;
+                    changed = true;
+                }
+            });
+            if (changed) {
+                await executor.execute(`
+					UPDATE c_saved_view SET filter_json = ?
+					WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+					`, [JSON.stringify(view.filter), view.id, userId]);
+                result.savedViewsUpdated += 1;
+            }
+        }
+        for (const definition of definitions.values()) {
+            await executor.execute(`
+				UPDATE c_property_def SET options = ?, updated_at = ?
+				WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+				`, [
+                serializePropertyDefOptions(definition.options),
+                updatedAt,
+                definition.row.id,
+                userId,
+            ]);
+            result.definitionsMigrated += 1;
+            result.optionsCreated += definition.options.length;
+        }
+    });
+    return result;
+}
+function definitionStateForWrite(row) {
+    const type = requireStoredPropertyType(row.type);
+    const parsedConfig = parsePropertyDefConfigEnvelope(row.config_json);
+    let config;
+    if (parsedConfig.status === "empty") {
+        config = getDefaultPropertyDefConfig(type, "legacy");
+    }
+    else if (parsedConfig.status === "valid" && parsedConfig.config.type === type) {
+        config = parsedConfig.config;
+    }
+    else {
+        throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+    }
+    let options = [];
+    if (isOptionPropertyType(type))
+        options = stableOptionsFromRow(row);
+    return { row, type, config, options, optionsChanged: false };
+}
+const UUID_TOKEN_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function resolveOptionToken(state, value, allowedArchivedIds) {
+    if (typeof value !== "string")
+        throw new Error("PROPERTY_OPTION_VALUE_INVALID");
+    const token = value.trim();
+    if (!token)
+        throw new Error("PROPERTY_OPTION_VALUE_INVALID");
+    const byId = findPropertyOptionById(state.options, token);
+    if (byId) {
+        if (byId.archived && !allowedArchivedIds.has(byId.id)) {
+            throw new Error("PROPERTY_OPTION_ARCHIVED");
+        }
+        return byId.id;
+    }
+    const byLabel = findPropertyOptionByLabel(state.options, token);
+    if (byLabel) {
+        if (byLabel.archived)
+            throw new Error("PROPERTY_OPTION_ARCHIVED");
+        return byLabel.id;
+    }
+    if (UUID_TOKEN_PATTERN.test(token))
+        throw new Error("PROPERTY_OPTION_NOT_FOUND");
+    const isOpen = (state.type === "select" &&
+        state.config?.type === "select" &&
+        state.config.mode === "open") ||
+        (state.type === "multi_select" &&
+            state.config?.type === "multi_select" &&
+            state.config.mode === "open");
+    if (!isOpen)
+        throw new Error("PROPERTY_OPTION_NOT_FOUND");
+    const label = normalizePropertyOptionLabel(token);
+    if (!label)
+        throw new Error("PROPERTY_OPTION_LABEL_INVALID");
+    if (state.options.length >= PROPERTY_OPTION_LIMITS.items) {
+        throw new Error("PROPERTY_OPTION_LIMIT_EXCEEDED");
+    }
+    const option = createPropertyOption(label, nextOptionSortRank(state.options));
+    state.options = [...state.options, option];
+    state.optionsChanged = true;
+    return option.id;
+}
+function normalizeKnownPropertyValue(state, value, allowedArchivedIds) {
+    switch (state.type) {
+        case "text":
+        case "email":
+        case "phone": {
+            const normalized = coercePropertyValue(state.type, value);
+            if (typeof normalized !== "string")
+                throw new Error("PROPERTY_VALUE_INVALID");
+            return normalized;
+        }
+        case "checkbox": {
+            const normalized = coercePropertyValue("checkbox", value);
+            if (typeof normalized !== "boolean")
+                throw new Error("PROPERTY_VALUE_INVALID");
+            return normalized;
+        }
+        case "number": {
+            if (state.config?.type !== "number")
+                throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+            const normalized = normalizeNumberPropertyValue(value, state.config);
+            if (normalized === null)
+                throw new Error("PROPERTY_NUMBER_INVALID");
+            // Presets set by dinox-app (rating 0–5 integers, progress 0–1) bind here too.
+            const preset = parseNumberPropertyPreset(state.row.options);
+            if (!isNumberPropertyValueAllowed(normalized, preset)) {
+                throw new Error("PROPERTY_NUMBER_INVALID");
+            }
+            return normalized;
+        }
+        case "date": {
+            if (state.config?.type !== "date")
+                throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+            const normalized = normalizeDatePropertyValue(value, state.config.mode);
+            if (normalized === null)
+                throw new Error("PROPERTY_DATE_INVALID");
+            return normalized;
+        }
+        case "url": {
+            if (state.config?.type !== "url")
+                throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+            const normalized = normalizeUrlPropertyValue(value, state.config);
+            if (normalized === null)
+                throw new Error("PROPERTY_URL_INVALID");
+            return normalized;
+        }
+        case "select":
+        case "status":
+            return resolveOptionToken(state, value, allowedArchivedIds);
+        case "multi_select": {
+            if (state.config?.type !== "multi_select") {
+                throw new Error("PROPERTY_DEF_CONFIG_INVALID");
+            }
+            const values = Array.isArray(value) ? value : [value];
+            const ids = canonicalOptionIds(values.map((item) => resolveOptionToken(state, item, allowedArchivedIds)), state.options);
+            const config = state.config;
+            if (ids.length === 0)
+                throw new Error("PROPERTY_MULTI_SELECT_EMPTY");
+            if (config.maxSelections !== undefined && ids.length > config.maxSelections) {
+                throw new Error("PROPERTY_MULTI_SELECT_LIMIT_EXCEEDED");
+            }
+            return ids;
+        }
+        case "relation": {
+            const values = Array.isArray(value) ? value : [value];
+            const ids = [];
+            const seen = new Set();
+            for (const item of values) {
+                if (typeof item !== "string")
+                    throw new Error("PROPERTY_RELATION_INVALID");
+                const id = item.trim();
+                if (!id || id.length > 200)
+                    throw new Error("PROPERTY_RELATION_INVALID");
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                ids.push(id);
+            }
+            if (ids.length === 0)
+                throw new Error("PROPERTY_RELATION_EMPTY");
+            if (ids.length > NOTE_PROPERTY_LIMITS.arrayLength) {
+                throw new Error("PROPERTY_RELATION_LIMIT");
+            }
+            return ids;
+        }
+        case "files": {
+            const files = normalizeFilePropertyValue(value);
+            if (!files || files.length === 0)
+                throw new Error("PROPERTY_FILES_INVALID");
+            return files;
+        }
+        case "place": {
+            const place = normalizePlacePropertyValue(value);
+            if (!place)
+                throw new Error("PROPERTY_PLACE_INVALID");
+            return place;
+        }
+        case "unique_id": {
+            if (!isIssuedUniqueId(value))
+                throw new Error("PROPERTY_UNIQUE_ID_INVALID");
+            return value;
+        }
+        default:
+            throw new Error("PROPERTY_TYPE_NOT_ACTIVE");
+    }
+}
+async function loadDefinitionsByKeys(executor, userId, keys) {
+    const uniqueKeys = [...new Set(keys)];
+    if (uniqueKeys.length === 0)
+        return new Map();
+    const placeholders = uniqueKeys.map(() => "?").join(", ");
+    const rows = await executor.getAll(`
+		WITH ranked_property_defs AS (
+		  SELECT definition.*,
+		    ROW_NUMBER() OVER (
+		      PARTITION BY definition.key
+		      ORDER BY
+		        COALESCE(NULLIF(definition.updated_at, ''), NULLIF(definition.created_at, ''), definition.id) DESC,
+		        definition.id DESC
+		    ) AS key_rank
+		  FROM c_property_def AS definition
+		  WHERE definition.user_id = ?
+		    AND definition.key IN (${placeholders})
+		    AND (definition.is_del IS NULL OR definition.is_del = 0)
+		)
+		SELECT ${propertyDefSelectList("ranked")}
+		FROM ranked_property_defs AS ranked
+		WHERE ranked.key_rank = 1
+		`, [userId, ...uniqueKeys]);
+    return new Map(rows.filter((row) => row.key).map((row) => [row.key, row]));
+}
+async function normalizeValuesForDefinitions(executor, userId, values, persistOptionKeys, allowedArchivedByKey = new Map()) {
+    const definitions = await loadDefinitionsByKeys(executor, userId, Object.keys(values));
+    const normalizedEntries = [];
+    const optionUpdates = [];
+    for (const [key, value] of Object.entries(values)) {
+        const row = definitions.get(key);
+        if (!row) {
+            normalizedEntries.push([key, value]);
+            continue;
+        }
+        const state = definitionStateForWrite(row);
+        const normalized = normalizeKnownPropertyValue(state, value, allowedArchivedByKey.get(key) ?? new Set());
+        normalizedEntries.push([key, normalized]);
+        if (state.optionsChanged && persistOptionKeys.has(key))
+            optionUpdates.push(state);
+    }
+    return { values: Object.fromEntries(normalizedEntries), optionUpdates };
+}
+async function persistOptionUpdates(executor, updates, userId, updatedAt) {
+    for (const state of updates) {
+        await executor.execute(`
+			UPDATE c_property_def SET options = ?, updated_at = ?
+			WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+			`, [serializePropertyDefOptions(state.options), updatedAt, state.row.id, userId]);
+    }
+}
+async function readNotePropertiesForMutation(executor, noteId, userId) {
+    const row = await executor.getOptional(`
+		SELECT properties
+		FROM c_note
+		WHERE id = ? AND user_no = ? AND (is_del IS NULL OR is_del = 0)
+		LIMIT 1
+		`, [noteId, userId]);
+    if (!row)
+        throw new Error(`Note not found: ${noteId}`);
+    const properties = tryParseRawNoteProperties(row.properties);
+    if (properties === null)
+        throw new Error("NOTE_PROPERTIES_CORRUPT");
+    return properties;
+}
+async function writeNoteProperties(executor, noteId, userId, updatedAt, properties) {
+    await executor.execute(`
+		UPDATE c_note SET properties = ?, updated_at = ?
+		WHERE id = ? AND user_no = ? AND (is_del IS NULL OR is_del = 0)
+		`, [serializeRawNoteProperties(properties), updatedAt, noteId, userId]);
+}
+function currentOptionIdsByKey(current, keys) {
+    const result = new Map();
+    for (const key of keys) {
+        const value = current[key];
+        if (typeof value === "string") {
+            result.set(key, new Set([value]));
+        }
+        else if (Array.isArray(value)) {
+            result.set(key, new Set(value.filter((item) => typeof item === "string")));
+        }
+    }
+    return result;
+}
+async function assignMissingUniqueIds(executor, userId, current, values, updatedAt) {
+    const definitions = await loadDefinitionsByKeys(executor, userId, Object.keys(values));
+    const next = { ...values };
+    let changed = false;
+    for (const key of Object.keys(values)) {
+        const row = definitions.get(key);
+        if (!row || row.type !== "unique_id")
+            continue;
+        if (isIssuedUniqueId(current[key])) {
+            next[key] = current[key];
+            continue;
+        }
+        const config = parseUniqueIdPropertyConfig(row.options);
+        if (!config && row.options?.trim()) {
+            throw new Error("PROPERTY_UNIQUE_ID_CONFIG_INVALID");
+        }
+        const resolved = config ?? {
+            prefix: normalizeUniqueIdPrefix(undefined, row.name ?? row.key),
+            next: 1,
+        };
+        const issued = resolved.next;
+        next[key] = issued;
+        const serialized = serializeUniqueIdPropertyConfig({
+            prefix: resolved.prefix,
+            next: issued + 1,
+        });
+        await executor.execute(`
+			UPDATE c_property_def SET options = ?, updated_at = ?
+			WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+			`, [serialized, updatedAt, row.id, userId]);
+        row.options = serialized;
+        changed = true;
+    }
+    return { values: next, changed };
+}
+async function updateNoteProperties(db, input) {
+    const noteId = input.noteId.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let result = { noteChanged: false, definitionsChanged: false };
+    await db.writeTransaction(async (executor) => {
+        const current = await readNotePropertiesForMutation(executor, noteId, userId);
+        const values = Object.fromEntries(Object.entries(input.patch).filter((entry) => entry[1] !== null));
+        const issued = await assignMissingUniqueIds(executor, userId, current, values, updatedAt);
+        const normalized = await normalizeValuesForDefinitions(executor, userId, issued.values, new Set(Object.keys(issued.values)), currentOptionIdsByKey(current, Object.keys(issued.values)));
+        const normalizedPatch = { ...input.patch, ...normalized.values };
+        const mutation = mergeNotePropertiesPatch(current, normalizedPatch);
+        await persistOptionUpdates(executor, normalized.optionUpdates, userId, updatedAt);
+        if (mutation.changedKeys.length > 0) {
+            await writeNoteProperties(executor, noteId, userId, updatedAt, mutation.next);
+        }
+        result = {
+            noteChanged: mutation.changedKeys.length > 0,
+            definitionsChanged: normalized.optionUpdates.length > 0 || issued.changed,
+        };
+    });
+    return result;
+}
+async function fillEmptyNotePropertyValues(db, input) {
+    const noteId = input.noteId.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let mutationResult = {
+        result: { appliedKeys: [], skippedKeys: [] },
+        definitionsChanged: false,
+    };
+    await db.writeTransaction(async (executor) => {
+        const current = await readNotePropertiesForMutation(executor, noteId, userId);
+        const eligibleKeys = new Set(Object.keys(input.values).filter((key) => Object.hasOwn(current, key) && current[key] === null));
+        const eligibleValues = Object.fromEntries(Object.entries(input.values).filter(([key]) => eligibleKeys.has(key)));
+        const issued = await assignMissingUniqueIds(executor, userId, current, eligibleValues, updatedAt);
+        const normalized = await normalizeValuesForDefinitions(executor, userId, issued.values, eligibleKeys);
+        const mutation = mergeNotePropertiesPatch(current, normalized.values);
+        await persistOptionUpdates(executor, normalized.optionUpdates, userId, updatedAt);
+        if (mutation.changedKeys.length > 0) {
+            await writeNoteProperties(executor, noteId, userId, updatedAt, mutation.next);
+        }
+        mutationResult = {
+            result: {
+                appliedKeys: mutation.changedKeys,
+                skippedKeys: Object.keys(input.values).filter((key) => !eligibleKeys.has(key)),
+            },
+            definitionsChanged: normalized.optionUpdates.length > 0 || issued.changed,
+        };
+    });
+    return mutationResult;
+}
+async function updateNotePropertySlots(db, input) {
+    const result = await mutateNotePropertiesBlob(db, input, (current) => applyNotePropertySlotOperation(current, input.operation, input.keys));
+    return result.changedKeys.length > 0;
+}
+async function reorderNotePropertySlots(db, input) {
+    const noteId = input.noteId.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let changed = false;
+    await db.writeTransaction(async (executor) => {
+        const row = await executor.getOptional(`
+			SELECT properties
+			FROM c_note
+			WHERE id = ? AND user_no = ? AND (is_del IS NULL OR is_del = 0)
+			LIMIT 1
+			`, [noteId, userId]);
+        if (!row)
+            throw new Error("NOTE_NOT_FOUND");
+        const current = tryParseRawNoteProperties(row.properties);
+        if (!current)
+            throw new Error("NOTE_PROPERTIES_INVALID");
+        const visibleKeys = Object.keys(parseStoredNoteProperties(row.properties));
+        const visibleKeySet = new Set(visibleKeys);
+        if (input.orderedKeys.some((key) => !visibleKeySet.has(key))) {
+            throw new Error("NOTE_PROPERTY_ORDER_STALE");
+        }
+        const requested = new Set(input.orderedKeys);
+        const nextOrder = [
+            ...input.orderedKeys,
+            ...visibleKeys.filter((key) => !requested.has(key)),
+        ];
+        const currentKeys = Object.keys(current);
+        const nextVisibleKeys = new Set(nextOrder);
+        const nextKeys = [
+            ...nextOrder,
+            ...currentKeys.filter((key) => !nextVisibleKeys.has(key)),
+        ];
+        if (nextKeys.length === currentKeys.length &&
+            nextKeys.every((key, index) => key === currentKeys[index])) {
+            return;
+        }
+        const next = Object.fromEntries(nextKeys.map((key) => [key, current[key]]));
+        await writeNoteProperties(executor, noteId, userId, updatedAt, next);
+        changed = true;
+    });
+    return changed;
+}
+async function mutateNotePropertiesBlob(db, input, mutate) {
+    const noteId = input.noteId.trim();
+    const userId = input.userId.trim();
+    const updatedAt = input.updatedAt.trim();
+    let result = null;
+    await db.writeTransaction(async (executor) => {
+        const current = await readNotePropertiesForMutation(executor, noteId, userId);
+        result = mutate(current);
+        if (result.changedKeys.length > 0) {
+            await writeNoteProperties(executor, noteId, userId, updatedAt, result.next);
+        }
+    });
+    if (!result)
+        throw new Error("NOTE_PROPERTIES_MUTATION_FAILED");
+    return result;
+}