@dinoxx/dinox-cli 2.1.1 → 2.3.0

package/dist/vendor/electron/shared/note-properties.js

@@ -0,0 +1,982 @@
+// Generated by scripts/sync-electron-domain.ts from dinox-electron/packages/shared/src/note-properties.ts. Do not edit manually.
+/**
+ * Note Properties domain types + pure helpers.
+ *
+ * Property values live on `c_note.properties` as a JSON map (key -> value), while
+ * `c_property_def` provides the account-owned semantic catalog (key/name/type/
+ * options). Unknown keys remain readable and degrade to untyped text.
+ *
+ * This module is pure (no DB, no React) so it can be shared by the main-process
+ * command handlers and the renderer UI.
+ */
+export const NOTE_PROPERTY_LIMITS = {
+    keyLength: 64,
+    textLength: 2000,
+    arrayLength: 50,
+    mutationKeys: 100,
+};
+// ── Property types ──────────────────────────────────────────
+/** Property types with a stable value contract and public editing support. */
+export const ACTIVE_PROPERTY_TYPES = [
+    'text',
+    'number',
+    'date',
+    'select',
+    'multi_select',
+    'status',
+    'url',
+    'email',
+    'phone',
+    'checkbox',
+    'files',
+    'relation',
+    'unique_id',
+    'place',
+];
+/** Types whose storage format is locked but not yet editable. None remain. */
+export const RESERVED_PROPERTY_TYPES = [];
+export const PROPERTY_OPTION_COLORS = [
+    'gray',
+    'red',
+    'orange',
+    'yellow',
+    'green',
+    'blue',
+    'purple',
+    'pink',
+];
+export const STATUS_PROPERTY_GROUPS = ['todo', 'in_progress', 'complete'];
+export const DEFAULT_STATUS_OPTION_INPUTS = [
+    { label: '未开始', color: 'gray', group: 'todo' },
+    { label: '进行中', color: 'blue', group: 'in_progress' },
+    { label: '已完成', color: 'green', group: 'complete' },
+];
+export const PROPERTY_OPTION_LIMITS = {
+    items: 200,
+    labelLength: 120,
+};
+export const PROPERTY_OPTION_LABEL_MAX_LENGTH = PROPERTY_OPTION_LIMITS.labelLength;
+export const PROPERTY_NUMBER_PRECISION_MAX = 12;
+export const PROPERTY_DEF_CONFIG_KEY_PREFIX = 'property_def.config.v1.';
+export function buildPropertyDefConfigKey(definitionId) {
+    const id = definitionId.trim();
+    if (!id)
+        throw new Error('INVALID_PROPERTY_DEF_ID');
+    return `${PROPERTY_DEF_CONFIG_KEY_PREFIX}${id}`;
+}
+export function isPropertyDefSource(value) {
+    return value === 'manual' || value === 'ai';
+}
+// ── Validation / sanitization ───────────────────────────────
+const MAX_PROPERTY_KEY_LENGTH = NOTE_PROPERTY_LIMITS.keyLength;
+const MAX_PROPERTY_TEXT_LENGTH = NOTE_PROPERTY_LIMITS.textLength;
+const MAX_PROPERTY_ARRAY_LENGTH = NOTE_PROPERTY_LIMITS.arrayLength;
+/**
+ * Property key validity: non-empty, <=64 chars, no newlines/tabs. A key is one
+ * flat name. Field refs keep a single `prop.` prefix and take the remainder as
+ * that name, so dots inside the name stay part of the name. `__proto__` is
+ * reserved because common object validators cannot round-trip it safely.
+ */
+export function isPropertyKeyValid(key) {
+    if (typeof key !== 'string')
+        return false;
+    const trimmed = key.trim();
+    if (!trimmed || trimmed !== key)
+        return false;
+    if (trimmed.length > MAX_PROPERTY_KEY_LENGTH)
+        return false;
+    if (trimmed === '__proto__')
+        return false;
+    if (/[\n\r\t]/.test(trimmed))
+        return false;
+    return true;
+}
+const FILE_PROPERTY_RESOURCE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UNIQUE_ID_PREFIX_MAX_LENGTH = 12;
+export function isFilePropertyPathValid(path) {
+    return (typeof path === 'string' &&
+        path.length > 0 &&
+        path.length <= 1024 &&
+        !/[\\\x00-\x1f:]/.test(path) &&
+        path.split('/').every((part) => part.length > 0 && part !== '.' && part !== '..'));
+}
+export function isFilePropertyRef(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.resourceId === 'string' &&
+        FILE_PROPERTY_RESOURCE_ID.test(value.resourceId) &&
+        (value.path === undefined || isFilePropertyPathValid(value.path)));
+}
+/** Reject a malformed file list instead of dropping attachments. An empty list is `[]`. */
+export function normalizeFilePropertyValue(value) {
+    if (!Array.isArray(value) ||
+        value.length > MAX_PROPERTY_ARRAY_LENGTH ||
+        !value.every(isFilePropertyRef)) {
+        return null;
+    }
+    const refs = [];
+    const identities = new Set();
+    const paths = new Set();
+    for (const item of value) {
+        const resourceId = item.resourceId.toLowerCase();
+        const identity = JSON.stringify([resourceId, item.path ?? null]);
+        if (identities.has(identity))
+            continue;
+        if (item.path && paths.has(item.path))
+            return null;
+        identities.add(identity);
+        if (item.path)
+            paths.add(item.path);
+        refs.push({ resourceId, ...(item.path ? { path: item.path } : {}) });
+    }
+    return refs;
+}
+export function normalizePlacePropertyValue(value) {
+    if (!isRecord(value) || typeof value.resourceId === 'string')
+        return null;
+    const lat = typeof value.lat === 'number' ? value.lat : Number.NaN;
+    const lon = typeof value.lon === 'number' ? value.lon : Number.NaN;
+    if (!Number.isFinite(lat) || !Number.isFinite(lon))
+        return null;
+    if (lat < -90 || lat > 90 || lon < -180 || lon > 180)
+        return null;
+    const name = typeof value.name === 'string' ? value.name.trim().slice(0, 200) : '';
+    return name ? { lat, lon, name } : { lat, lon };
+}
+export function isPlacePropertyValue(value) {
+    return normalizePlacePropertyValue(value) !== null;
+}
+export function formatPlaceProperty(value) {
+    const name = value.name?.trim();
+    if (name)
+        return name;
+    return `${value.lat.toFixed(5)}, ${value.lon.toFixed(5)}`;
+}
+export function normalizeUniqueIdPrefix(raw, fallbackName) {
+    const cleaned = (raw ?? '')
+        .toUpperCase()
+        .replace(/[^A-Z0-9]/g, '')
+        .slice(0, UNIQUE_ID_PREFIX_MAX_LENGTH);
+    if (cleaned)
+        return cleaned;
+    const fromName = (fallbackName ?? '')
+        .toUpperCase()
+        .replace(/[^A-Z0-9]/g, '')
+        .slice(0, 8);
+    return fromName || 'ID';
+}
+export function isIssuedUniqueId(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1 && Number.isSafeInteger(value);
+}
+export function parseUniqueIdPropertyConfig(raw) {
+    if (!raw?.trim())
+        return undefined;
+    try {
+        const config = JSON.parse(raw);
+        if (!isRecord(config) || config.version !== 1 || !isRecord(config.uniqueId))
+            return undefined;
+        const prefix = normalizeUniqueIdPrefix(typeof config.uniqueId.prefix === 'string' ? config.uniqueId.prefix : undefined);
+        const nextRaw = Number(config.uniqueId.next);
+        const next = Number.isInteger(nextRaw) && nextRaw >= 1 ? nextRaw : 1;
+        return { prefix, next };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function serializeUniqueIdPropertyConfig(config) {
+    return JSON.stringify({
+        version: 1,
+        uniqueId: {
+            prefix: normalizeUniqueIdPrefix(config.prefix),
+            next: Number.isInteger(config.next) && config.next >= 1 ? config.next : 1,
+        },
+    });
+}
+export function formatUniqueIdProperty(value, config) {
+    if (!isIssuedUniqueId(value))
+        return '';
+    const prefix = config?.prefix?.trim();
+    return prefix ? `${prefix}-${value}` : String(value);
+}
+function isStatusPropertyGroup(value) {
+    return (typeof value === 'string' &&
+        STATUS_PROPERTY_GROUPS.includes(value));
+}
+function sameFilePropertyRefs(left, right) {
+    return (left.length === right.length &&
+        left.every((item, index) => item.resourceId === right[index]?.resourceId && item.path === right[index]?.path));
+}
+function samePlaceProperty(left, right) {
+    return left.lat === right.lat && left.lon === right.lon && left.name === right.name;
+}
+function sanitizePropertyValue(value) {
+    if (typeof value === 'string') {
+        return value.length > MAX_PROPERTY_TEXT_LENGTH
+            ? value.slice(0, MAX_PROPERTY_TEXT_LENGTH)
+            : value;
+    }
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'boolean')
+        return value;
+    const place = normalizePlacePropertyValue(value);
+    if (place)
+        return place;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return null;
+        if (value.some((item) => item !== null && typeof item === 'object')) {
+            const files = normalizeFilePropertyValue(value);
+            return files && files.length > 0 ? files : null;
+        }
+        const items = value
+            .filter((item) => typeof item === 'string')
+            .map((item) => item.length > MAX_PROPERTY_TEXT_LENGTH ? item.slice(0, MAX_PROPERTY_TEXT_LENGTH) : item)
+            .filter((item) => item.trim().length > 0)
+            .slice(0, MAX_PROPERTY_ARRAY_LENGTH);
+        return items.length > 0 ? items : null;
+    }
+    return null;
+}
+// ── Parse / serialize the note properties JSON ──────────────
+function copyOwnProperties(source) {
+    return Object.fromEntries(Object.entries(source));
+}
+function setOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+/**
+ * Strictly parse the raw JSON object. `null` means the stored value is present
+ * but malformed or uses an unsupported top-level shape.
+ */
+export function tryParseRawNoteProperties(raw) {
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    return copyOwnProperties(parsed);
+}
+/** Forgiving read projection used by UI/read paths; malformed storage appears empty. */
+export function parseRawNoteProperties(raw) {
+    return tryParseRawNoteProperties(raw) ?? {};
+}
+/** Parse the supported three-state view; unknown values are omitted from the UI. */
+export function parseStoredNoteProperties(raw) {
+    const result = {};
+    for (const [key, value] of Object.entries(parseRawNoteProperties(raw))) {
+        if (!isPropertyKeyValid(key))
+            continue;
+        if (value === null) {
+            setOwnProperty(result, key, null);
+            continue;
+        }
+        const sanitized = sanitizePropertyValue(value);
+        if (sanitized !== null) {
+            setOwnProperty(result, key, typeof sanitized === 'string' && !sanitized.trim() ? null : sanitized);
+            continue;
+        }
+        if (Array.isArray(value) && value.every((item) => typeof item === 'string')) {
+            setOwnProperty(result, key, null);
+        }
+    }
+    return result;
+}
+/** Read only committed values; declared-but-empty slots are intentionally omitted. */
+export function parseNoteProperties(raw) {
+    const stored = parseStoredNoteProperties(raw);
+    return Object.fromEntries(Object.entries(stored).filter((entry) => entry[1] !== null));
+}
+/** Serialize persisted values + empty slots; an empty object normalizes to NULL. */
+export function serializeStoredNoteProperties(properties) {
+    return serializeRawNoteProperties(properties);
+}
+/** Serialize a lossless raw property object; an empty object normalizes to NULL. */
+export function serializeRawNoteProperties(properties) {
+    const keys = Object.keys(properties);
+    if (keys.length === 0)
+        return null;
+    return JSON.stringify(properties);
+}
+/** Serialize the non-empty value view. */
+export function serializeNoteProperties(properties) {
+    return serializeStoredNoteProperties(properties);
+}
+function propertyValueEquals(a, b) {
+    if (isPlacePropertyValue(b)) {
+        const place = normalizePlacePropertyValue(a);
+        return place !== null && samePlaceProperty(place, b);
+    }
+    if (Array.isArray(b) && b.length > 0 && b.every(isFilePropertyRef)) {
+        const files = normalizeFilePropertyValue(a);
+        return files !== null && sameFilePropertyRefs(files, b);
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((item, i) => item === b[i]);
+    }
+    return a === b;
+}
+/**
+ * Legacy value merge: null removes a key, non-null values overwrite, and all
+ * unrelated JSON entries are preserved. Returns the list of changed keys.
+ */
+export function mergeNotePropertiesPatch(current, patch) {
+    const next = copyOwnProperties(current);
+    const changedKeys = [];
+    for (const [key, value] of Object.entries(patch)) {
+        if (!isPropertyKeyValid(key))
+            continue;
+        if (value === null) {
+            if (Object.hasOwn(next, key)) {
+                delete next[key];
+                changedKeys.push(key);
+            }
+            continue;
+        }
+        const sanitized = sanitizePropertyValue(value);
+        if (sanitized === null)
+            continue;
+        const existing = next[key];
+        if (Object.hasOwn(next, key) && propertyValueEquals(existing, sanitized)) {
+            continue;
+        }
+        setOwnProperty(next, key, sanitized);
+        changedKeys.push(key);
+    }
+    return { next, changedKeys };
+}
+/**
+ * Fill only fields that are still explicitly declared as empty. Missing fields
+ * and fields with any current value are skipped, allowing AI/review flows to
+ * avoid overwriting a concurrent user edit in the same transaction.
+ */
+export function fillEmptyNoteProperties(current, values) {
+    const next = copyOwnProperties(current);
+    const changedKeys = [];
+    const skippedKeys = [];
+    for (const [key, value] of Object.entries(values)) {
+        if (!isPropertyKeyValid(key))
+            continue;
+        const sanitized = sanitizePropertyValue(value);
+        if (sanitized === null)
+            continue;
+        if (!Object.hasOwn(next, key) || next[key] !== null) {
+            skippedKeys.push(key);
+            continue;
+        }
+        setOwnProperty(next, key, sanitized);
+        changedKeys.push(key);
+    }
+    return { next, changedKeys, skippedKeys };
+}
+/**
+ * Apply an explicit field-slot operation: declare adds only missing slots, clear
+ * makes every target explicitly empty, and remove deletes the slot entirely.
+ */
+export function applyNotePropertySlotOperation(current, operation, keys) {
+    const next = copyOwnProperties(current);
+    const changedKeys = [];
+    const seen = new Set();
+    for (const key of keys) {
+        if (!isPropertyKeyValid(key) || seen.has(key))
+            continue;
+        seen.add(key);
+        if (operation === 'remove') {
+            if (Object.hasOwn(next, key)) {
+                delete next[key];
+                changedKeys.push(key);
+            }
+            continue;
+        }
+        if (operation === 'declare') {
+            if (!Object.hasOwn(next, key)) {
+                setOwnProperty(next, key, null);
+                changedKeys.push(key);
+            }
+            continue;
+        }
+        if (!Object.hasOwn(next, key) || next[key] !== null) {
+            setOwnProperty(next, key, null);
+            changedKeys.push(key);
+        }
+    }
+    return { next, changedKeys };
+}
+const TRUE_STRINGS = new Set(['true', '1', 'yes', '是']);
+const FALSE_STRINGS = new Set(['false', '0', 'no', '否']);
+const ISO_DATE_PREFIX_PATTERN = /^([+-]?\d{4,6})-(\d{2})-(\d{2})(?:$|[Tt\s])/;
+function hasValidCalendarDatePrefix(value) {
+    const match = ISO_DATE_PREFIX_PATTERN.exec(value);
+    if (!match)
+        return true;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (!Number.isInteger(year) || month < 1 || month > 12 || day < 1)
+        return false;
+    const daysInMonth = [
+        31,
+        year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+    ];
+    return day <= (daysInMonth[month - 1] ?? 0);
+}
+/** Normalize accepted date input and reject ISO-like strings with impossible calendar dates. */
+export function normalizeDateValueToIso(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed || !hasValidCalendarDatePrefix(trimmed))
+            return null;
+        const date = new Date(trimmed);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    return null;
+}
+/** Normalize a configured date value without conflating a calendar date with an instant. */
+export function normalizeDatePropertyValue(value, mode) {
+    if (mode === 'datetime')
+        return normalizeDateValueToIso(value);
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        const plainDateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed);
+        if (plainDateMatch) {
+            return hasValidCalendarDatePrefix(trimmed) ? trimmed : null;
+        }
+    }
+    return normalizeDateValueToIso(value)?.slice(0, 10) ?? null;
+}
+function decimalPlaces(value) {
+    const [coefficient = '', exponentText = '0'] = Math.abs(value).toString().toLowerCase().split('e');
+    const fractionLength = coefficient.includes('.') ? coefficient.length - coefficient.indexOf('.') - 1 : 0;
+    const exponent = Number(exponentText);
+    return Math.max(0, fractionLength - exponent);
+}
+/** Validate a number against its semantic constraints without rounding the stored value. */
+export function normalizeNumberPropertyValue(value, config) {
+    const normalized = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim()
+            ? Number(value.trim())
+            : Number.NaN;
+    if (!Number.isFinite(normalized))
+        return null;
+    if (config.min !== undefined && normalized < config.min)
+        return null;
+    if (config.max !== undefined && normalized > config.max)
+        return null;
+    if (config.precision !== undefined && decimalPlaces(normalized) > config.precision)
+        return null;
+    if (config.step !== undefined) {
+        const base = config.min ?? 0;
+        const quotient = (normalized - base) / config.step;
+        const nearest = Math.round(quotient);
+        const tolerance = Number.EPSILON * Math.max(1, Math.abs(quotient)) * 8;
+        if (Math.abs(quotient - nearest) > tolerance)
+            return null;
+    }
+    return normalized;
+}
+/** Validate and canonicalize an absolute URL under the definition's allowed schemes. */
+export function normalizeUrlPropertyValue(value, config) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.username || parsed.password)
+        return null;
+    const scheme = parsed.protocol.slice(0, -1);
+    const allowedSchemes = config?.schemes ?? ['http', 'https'];
+    if ((scheme !== 'http' && scheme !== 'https') || !allowedSchemes.includes(scheme)) {
+        return null;
+    }
+    return parsed.href;
+}
+/**
+ * Coerce a candidate value into the legal shape for a target type; returns null
+ * when it cannot be coerced. Only does shape coercion — the select-option
+ * whitelist belongs to the validation/policy layer.
+ */
+export function coercePropertyValue(type, value) {
+    switch (type) {
+        case 'text':
+        case 'url':
+        case 'email':
+        case 'phone': {
+            if (typeof value === 'string') {
+                const trimmed = value.trim();
+                return trimmed ? sanitizePropertyValue(trimmed) : null;
+            }
+            if (typeof value === 'number' && Number.isFinite(value))
+                return String(value);
+            if (typeof value === 'boolean')
+                return String(value);
+            return null;
+        }
+        case 'number': {
+            if (typeof value === 'number' && Number.isFinite(value))
+                return value;
+            if (typeof value === 'string') {
+                const parsed = Number(value.trim());
+                return Number.isFinite(parsed) && value.trim() !== '' ? parsed : null;
+            }
+            return null;
+        }
+        case 'date': {
+            return normalizeDateValueToIso(value);
+        }
+        case 'select':
+        case 'status': {
+            if (typeof value === 'string') {
+                const trimmed = value.trim();
+                return trimmed ? sanitizePropertyValue(trimmed) : null;
+            }
+            return null;
+        }
+        case 'checkbox': {
+            if (typeof value === 'boolean')
+                return value;
+            if (typeof value === 'number')
+                return value !== 0;
+            if (typeof value === 'string') {
+                const lowered = value.trim().toLowerCase();
+                if (TRUE_STRINGS.has(lowered))
+                    return true;
+                if (FALSE_STRINGS.has(lowered))
+                    return false;
+            }
+            return null;
+        }
+        case 'multi_select':
+        case 'relation': {
+            const array = Array.isArray(value)
+                ? value
+                : typeof value === 'string' && value.trim()
+                    ? [value]
+                    : null;
+            if (!array || array.some((item) => item !== null && typeof item === 'object'))
+                return null;
+            return sanitizePropertyValue(array);
+        }
+        case 'files': {
+            const files = normalizeFilePropertyValue(value);
+            return files && files.length > 0 ? files : null;
+        }
+        case 'place':
+            return normalizePlacePropertyValue(value);
+        case 'unique_id': {
+            if (isIssuedUniqueId(value))
+                return value;
+            if (typeof value === 'string') {
+                const match = /^([A-Z0-9]{1,12}-)?(\d+)$/i.exec(value.trim());
+                if (!match)
+                    return null;
+                const parsed = Number(match[2]);
+                return isIssuedUniqueId(parsed) ? parsed : null;
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+/** UI display value -> chip text (arrays joined with "、"). */
+export function formatPropertyValue(value) {
+    if (isPlacePropertyValue(value))
+        return formatPlaceProperty(value);
+    if (Array.isArray(value)) {
+        if (value.length > 0 && value.every(isFilePropertyRef)) {
+            return value.map((item) => item.path || item.resourceId).join('、');
+        }
+        return value.join('、');
+    }
+    if (typeof value === 'boolean')
+        return value ? '✓' : '✗';
+    return String(value);
+}
+/** Infer a type from the value shape when the catalog is missing (orphan keys). */
+export function inferPropertyTypeFromValue(value) {
+    if (isPlacePropertyValue(value))
+        return 'place';
+    if (Array.isArray(value)) {
+        return value.length > 0 && value.every(isFilePropertyRef) ? 'files' : 'multi_select';
+    }
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'boolean')
+        return 'checkbox';
+    return 'text';
+}
+const KNOWN_PROPERTY_TYPES = new Set([
+    ...ACTIVE_PROPERTY_TYPES,
+    ...RESERVED_PROPERTY_TYPES,
+]);
+export function isPropertyType(value) {
+    return typeof value === 'string' && KNOWN_PROPERTY_TYPES.has(value);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function isPropertyOptionColor(value) {
+    return (typeof value === 'string' &&
+        PROPERTY_OPTION_COLORS.includes(value));
+}
+/** Normalize the user-visible option identity used for display and uniqueness. */
+export function normalizePropertyOptionLabel(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.normalize('NFKC').trim();
+    if (!normalized || normalized.length > PROPERTY_OPTION_LABEL_MAX_LENGTH)
+        return null;
+    return normalized;
+}
+/** Case-insensitive uniqueness key. Callers should reject an empty result. */
+export function propertyOptionLabelKey(value) {
+    return normalizePropertyOptionLabel(value)?.toLowerCase() ?? '';
+}
+export function findPropertyOptionById(options, id) {
+    return options.find((option) => option.id === id);
+}
+export function findPropertyOptionByLabel(options, label) {
+    const key = propertyOptionLabelKey(label);
+    return key ? options.find((option) => propertyOptionLabelKey(option.label) === key) : undefined;
+}
+function normalizePropertyOption(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== 'string' || !value.id.trim() || value.id.trim() !== value.id)
+        return null;
+    const label = normalizePropertyOptionLabel(value.label);
+    if (!label || !isPropertyOptionColor(value.color))
+        return null;
+    if (!Number.isSafeInteger(value.sortRank) || typeof value.archived !== 'boolean')
+        return null;
+    if (value.group !== undefined && !isStatusPropertyGroup(value.group))
+        return null;
+    return {
+        id: value.id,
+        label,
+        color: value.color,
+        sortRank: value.sortRank,
+        archived: value.archived,
+        ...(isStatusPropertyGroup(value.group) ? { group: value.group } : {}),
+    };
+}
+/** Validate, deduplicate, and put options in their canonical `(sortRank,id)` order. */
+export function normalizePropertyOptions(values) {
+    if (values.length > PROPERTY_OPTION_LIMITS.items)
+        return undefined;
+    const options = [];
+    const ids = new Set();
+    const labelKeys = new Set();
+    for (const value of values) {
+        const option = normalizePropertyOption(value);
+        if (!option)
+            return undefined;
+        const labelKey = propertyOptionLabelKey(option.label);
+        if (ids.has(option.id) || labelKeys.has(labelKey))
+            return undefined;
+        ids.add(option.id);
+        labelKeys.add(labelKey);
+        options.push(option);
+    }
+    return options.sort((left, right) => left.sortRank - right.sortRank || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+}
+/** Parse both the stable v1 envelope and legacy label arrays without conflating them. */
+export function parsePropertyDefOptionsEnvelope(raw) {
+    if (!raw || !raw.trim())
+        return { status: 'empty' };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { status: 'invalid' };
+    }
+    if (Array.isArray(parsed)) {
+        const labels = [];
+        const seen = new Set();
+        for (const item of parsed) {
+            const label = normalizePropertyOptionLabel(item);
+            if (!label)
+                return { status: 'invalid' };
+            const labelKey = propertyOptionLabelKey(label);
+            if (seen.has(labelKey))
+                continue;
+            if (labels.length >= PROPERTY_OPTION_LIMITS.items)
+                return { status: 'invalid' };
+            seen.add(labelKey);
+            labels.push(label);
+        }
+        return { status: 'legacy', labels };
+    }
+    if (!isRecord(parsed))
+        return { status: 'invalid' };
+    if (parsed.version !== 1) {
+        return Object.hasOwn(parsed, 'version')
+            ? { status: 'unsupported', version: parsed.version }
+            : { status: 'invalid' };
+    }
+    if (!Array.isArray(parsed.items))
+        return { status: 'invalid' };
+    const options = normalizePropertyOptions(parsed.items);
+    return options ? { status: 'valid', options } : { status: 'invalid' };
+}
+/** Read only migrated stable options. Legacy labels remain migration-only data. */
+export function parsePropertyDefOptions(raw) {
+    const parsed = parsePropertyDefOptionsEnvelope(raw);
+    return parsed.status === 'valid' ? parsed.options : undefined;
+}
+/** Read legacy label options for the explicit migration command only. */
+export function parseLegacyPropertyDefOptions(raw) {
+    const parsed = parsePropertyDefOptionsEnvelope(raw);
+    return parsed.status === 'legacy' ? parsed.labels : undefined;
+}
+export function serializePropertyDefOptions(options) {
+    const normalized = normalizePropertyOptions(options);
+    if (!normalized)
+        throw new Error('INVALID_PROPERTY_OPTIONS');
+    const envelope = { version: 1, items: normalized };
+    return JSON.stringify(envelope);
+}
+function optionalFiniteNumber(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const candidate = value[key];
+    return typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : null;
+}
+function optionalConfigText(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const candidate = value[key];
+    if (typeof candidate !== 'string')
+        return null;
+    const normalized = candidate.normalize('NFKC').trim();
+    return normalized && normalized.length <= 120 ? normalized : null;
+}
+const FALLBACK_ISO_4217_CODES = new Set('AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BRL BSD BTN BWP BYN BZD CAD CDF CHF CLP CNY COP CRC CUC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SLL SOS SRD SSP STN SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VUV WST XAF XCD XCG XDR XOF XPF XSU YER ZAR ZMW ZWG ZWL'.split(' '));
+const ISO_4217_CODES = (() => {
+    const supportedValuesOf = Intl.supportedValuesOf;
+    if (typeof supportedValuesOf === 'function') {
+        try {
+            return new Set([...FALLBACK_ISO_4217_CODES, ...supportedValuesOf.call(Intl, 'currency')]);
+        }
+        catch {
+            // Older runtimes fall back to the embedded ISO list.
+        }
+    }
+    return FALLBACK_ISO_4217_CODES;
+})();
+/** Validate and canonicalize a structured property-definition config object. */
+export function normalizePropertyDefConfig(value) {
+    if (!isRecord(value) || value.version !== 1)
+        return undefined;
+    switch (value.type) {
+        case 'date':
+            return value.mode === 'date' || value.mode === 'datetime'
+                ? { version: 1, type: 'date', mode: value.mode }
+                : undefined;
+        case 'number': {
+            if (value.format !== 'number' && value.format !== 'percent' && value.format !== 'currency') {
+                return undefined;
+            }
+            const precision = optionalFiniteNumber(value, 'precision');
+            const min = optionalFiniteNumber(value, 'min');
+            const max = optionalFiniteNumber(value, 'max');
+            const step = optionalFiniteNumber(value, 'step');
+            const currency = optionalConfigText(value, 'currency');
+            const unit = optionalConfigText(value, 'unit');
+            const normalizedCurrency = currency?.toUpperCase();
+            if (precision === null ||
+                min === null ||
+                max === null ||
+                step === null ||
+                currency === null ||
+                unit === null ||
+                (precision !== undefined &&
+                    (!Number.isSafeInteger(precision) ||
+                        precision < 0 ||
+                        precision > PROPERTY_NUMBER_PRECISION_MAX)) ||
+                (step !== undefined && step <= 0) ||
+                (min !== undefined && max !== undefined && min > max) ||
+                (normalizedCurrency !== undefined && !ISO_4217_CODES.has(normalizedCurrency)) ||
+                (value.format === 'currency' && currency === undefined)) {
+                return undefined;
+            }
+            return {
+                version: 1,
+                type: 'number',
+                format: value.format,
+                ...(precision === undefined ? {} : { precision }),
+                ...(normalizedCurrency === undefined ? {} : { currency: normalizedCurrency }),
+                ...(unit === undefined ? {} : { unit }),
+                ...(min === undefined ? {} : { min }),
+                ...(max === undefined ? {} : { max }),
+                ...(step === undefined ? {} : { step }),
+            };
+        }
+        case 'select':
+            return value.mode === 'open' || value.mode === 'closed'
+                ? { version: 1, type: 'select', mode: value.mode }
+                : undefined;
+        case 'multi_select': {
+            if (value.mode !== 'open' && value.mode !== 'closed')
+                return undefined;
+            const maxSelections = optionalFiniteNumber(value, 'maxSelections');
+            if (maxSelections === null ||
+                (maxSelections !== undefined &&
+                    (!Number.isSafeInteger(maxSelections) ||
+                        maxSelections < 1 ||
+                        maxSelections > NOTE_PROPERTY_LIMITS.arrayLength))) {
+                return undefined;
+            }
+            return {
+                version: 1,
+                type: 'multi_select',
+                mode: value.mode,
+                ...(maxSelections === undefined ? {} : { maxSelections }),
+            };
+        }
+        case 'url': {
+            if (!Object.hasOwn(value, 'schemes'))
+                return { version: 1, type: 'url' };
+            if (!Array.isArray(value.schemes) || value.schemes.length === 0)
+                return undefined;
+            if (value.schemes.some((scheme) => scheme !== 'http' && scheme !== 'https')) {
+                return undefined;
+            }
+            const selected = new Set(value.schemes);
+            const schemes = ['http', 'https'].filter((scheme) => selected.has(scheme));
+            return { version: 1, type: 'url', schemes };
+        }
+        default:
+            return undefined;
+    }
+}
+/** Parse a companion config without hiding malformed or future-version rows. */
+export function parsePropertyDefConfigEnvelope(raw) {
+    if (!raw || !raw.trim())
+        return { status: 'empty' };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { status: 'invalid' };
+    }
+    if (isRecord(parsed) && parsed.version !== 1 && Object.hasOwn(parsed, 'version')) {
+        return { status: 'unsupported', version: parsed.version };
+    }
+    const config = normalizePropertyDefConfig(parsed);
+    return config ? { status: 'valid', config } : { status: 'invalid' };
+}
+/** Parse only an explicit valid companion config; other states return undefined. */
+export function parsePropertyDefConfig(raw) {
+    const parsed = parsePropertyDefConfigEnvelope(raw);
+    return parsed.status === 'valid' ? parsed.config : undefined;
+}
+/** Option definitions stay open so unmatched input can create options inline. */
+export function getDefaultPropertyDefConfig(type, _defaults = 'legacy') {
+    switch (type) {
+        case 'date':
+            return { version: 1, type: 'date', mode: 'date' };
+        case 'number':
+            return { version: 1, type: 'number', format: 'number' };
+        case 'select':
+            return { version: 1, type: 'select', mode: 'open' };
+        case 'multi_select':
+            return { version: 1, type: 'multi_select', mode: 'open' };
+        case 'url':
+            return { version: 1, type: 'url', schemes: ['http', 'https'] };
+        default:
+            return undefined;
+    }
+}
+export function resolvePropertyDefConfig(type, raw) {
+    const parsed = parsePropertyDefConfigEnvelope(raw);
+    if (parsed.status === 'empty')
+        return getDefaultPropertyDefConfig(type, 'legacy');
+    return parsed.status === 'valid' && parsed.config.type === type ? parsed.config : undefined;
+}
+export function serializePropertyDefConfig(config) {
+    const normalized = normalizePropertyDefConfig(config);
+    if (!normalized)
+        throw new Error('INVALID_PROPERTY_DEF_CONFIG');
+    return JSON.stringify(normalized);
+}
+/** Map a raw c_property_def row into the domain object (unknown type -> text). */
+export function mapPropertyDef(record) {
+    const rawType = record.type ?? 'text';
+    const type = (KNOWN_PROPERTY_TYPES.has(rawType) ? rawType : 'text');
+    const parsedOptions = parsePropertyDefOptionsEnvelope(record.options);
+    const parsedConfig = parsePropertyDefConfigEnvelope(record.config_json);
+    const hasOptionSemantics = type === 'select' || type === 'multi_select' || type === 'status';
+    const parsedUniqueId = type === 'unique_id' ? parseUniqueIdPropertyConfig(record.options) : undefined;
+    const uniqueIdInvalid = type === 'unique_id' && Boolean(record.options?.trim()) && parsedUniqueId === undefined;
+    const explicitConfigMatches = parsedConfig.status === 'valid' && parsedConfig.config.type === type;
+    return {
+        id: record.id ?? '',
+        key: record.key ?? '',
+        name: record.name || record.key || '',
+        type,
+        options: hasOptionSemantics && parsedOptions.status === 'valid' ? parsedOptions.options : undefined,
+        ...(type === 'unique_id'
+            ? {
+                uniqueId: parsedUniqueId ?? {
+                    prefix: normalizeUniqueIdPrefix(undefined, record.name || record.key),
+                    next: 1,
+                },
+            }
+            : {}),
+        config: parsedConfig.status === 'empty'
+            ? getDefaultPropertyDefConfig(type, 'legacy')
+            : explicitConfigMatches
+                ? parsedConfig.config
+                : undefined,
+        configInvalid: parsedConfig.status === 'invalid' ||
+            parsedConfig.status === 'unsupported' ||
+            (parsedConfig.status === 'valid' && !explicitConfigMatches),
+        optionsMigrationPending: hasOptionSemantics &&
+            (parsedOptions.status === 'empty' || parsedOptions.status === 'legacy'),
+        optionsInvalid: uniqueIdInvalid ||
+            (hasOptionSemantics &&
+                (parsedOptions.status === 'invalid' || parsedOptions.status === 'unsupported')),
+        description: record.description || undefined,
+        icon: record.icon || undefined,
+        showOnCard: Number(record.show_on_card ?? 0) === 1,
+        source: isPropertyDefSource(record.source) ? record.source : 'manual',
+        sortRank: Number(record.sort_rank ?? 0),
+    };
+}