@shaxpir/duiduidui-models 1.9.13 → 1.9.14

package/dist/models/Collection.d.ts

@@ -0,0 +1,158 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CompactDateTime } from "@shaxpir/shaxpir-common";
+import { ShareSync } from '../repo';
+import { Conditions } from './Condition';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { UncertainValue } from './Progress';
+/**
+ * Display metadata for a Collection, used in the UI.
+ */
+export interface CollectionDisplay {
+    name: string;
+    description: string;
+    icon?: string;
+    sort_order: number;
+}
+/**
+ * A snapshot of a term's proficiency within this collection.
+ * Stored in term_scores map, keyed by termId.
+ */
+export interface CollectionTermScore {
+    text: string;
+    sense_rank: number;
+    theta: number;
+}
+/**
+ * The payload for a Collection document.
+ *
+ * A Collection represents a scoped subset of the corpus defined by filters,
+ * combined with a competency model tracking the user's mastery within that scope.
+ */
+export interface CollectionPayload {
+    collection_key: string;
+    conditions: Conditions;
+    display: CollectionDisplay;
+    proficiency: UncertainValue;
+    term_scores: {
+        [termId: string]: CollectionTermScore;
+    };
+    total_cards: number;
+    last_activity_utc: CompactDateTime | null;
+    is_visible: boolean;
+    is_builtin: boolean;
+}
+export interface CollectionBody extends ContentBody {
+    meta: ContentMeta;
+    payload: CollectionPayload;
+}
+/**
+ * Parameters for creating a new Collection.
+ */
+export interface CollectionCreateParams {
+    collectionKey: string;
+    conditions: Conditions;
+    display: CollectionDisplay;
+    isBuiltin?: boolean;
+    isVisible?: boolean;
+}
+export declare class Collection extends Content {
+    /**
+     * Generate a deterministic Collection ID from userId and collectionKey.
+     * The same user + collectionKey always produces the same ID.
+     */
+    static makeCollectionId(userId: ContentId, collectionKey: string): ContentId;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    /**
+     * Create a new Collection for a user.
+     */
+    static create(userId: ContentId, params: CollectionCreateParams): Collection;
+    get payload(): CollectionPayload;
+    get collectionKey(): string;
+    get conditions(): Conditions;
+    get display(): CollectionDisplay;
+    get name(): string;
+    get description(): string;
+    get icon(): string | undefined;
+    get sortOrder(): number;
+    get proficiency(): UncertainValue;
+    get proficiencyRating(): number;
+    get proficiencyRatingDeviation(): number;
+    get proficiencyVolatility(): number;
+    get termScores(): {
+        [termId: string]: CollectionTermScore;
+    };
+    /**
+     * Get the number of unique terms the user has reviewed in this collection.
+     */
+    get termsReviewedCount(): number;
+    /**
+     * Get the term score for a specific term, or undefined if not reviewed.
+     */
+    getTermScore(termId: string): CollectionTermScore | undefined;
+    get totalCards(): number;
+    get lastActivityUtc(): CompactDateTime | null;
+    get isVisible(): boolean;
+    get isBuiltin(): boolean;
+    /**
+     * Check if this collection has any proficiency data yet.
+     */
+    get hasProgress(): boolean;
+    /**
+     * Calculate the percentage of terms that are "mastered" (theta >= 0.8).
+     * Returns 0 if no terms have been reviewed.
+     */
+    get masteryPercentage(): number;
+    /**
+     * Calculate the percentage of total cards that have been reviewed.
+     * Returns 0 if total_cards is 0 or not set.
+     */
+    get reviewedPercentage(): number;
+    /**
+     * Get counts of terms by grade (based on theta ranges).
+     */
+    getGradeDistribution(): {
+        A: number;
+        B: number;
+        C: number;
+        D: number;
+        F: number;
+    };
+    /**
+     * Update the Glicko-2 proficiency rating.
+     */
+    setProficiency(value: UncertainValue): void;
+    /**
+     * Update or add a term score in the collection.
+     */
+    setTermScore(termId: string, score: CollectionTermScore): void;
+    /**
+     * Update just the theta value for an existing term score.
+     * Does nothing if the term doesn't exist in term_scores.
+     */
+    updateTermTheta(termId: string, theta: number): void;
+    /**
+     * Remove a term score from the collection.
+     */
+    removeTermScore(termId: string): void;
+    /**
+     * Update the cached total card count for this collection.
+     */
+    setTotalCards(count: number): void;
+    /**
+     * Update the last activity timestamp.
+     */
+    setLastActivityUtc(timestamp: CompactDateTime): void;
+    /**
+     * Update visibility of this collection.
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Update display metadata.
+     */
+    setDisplay(display: CollectionDisplay): void;
+    /**
+     * Update the condition definition.
+     * Note: Changing conditions on a builtin collection is not recommended.
+     */
+    setConditions(conditions: Conditions): void;
+}

package/dist/models/Collection.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+const shaxpir_common_1 = require("@shaxpir/shaxpir-common");
+const repo_1 = require("../repo");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Operation_1 = require("./Operation");
+class Collection extends Content_1.Content {
+    /**
+     * Generate a deterministic Collection ID from userId and collectionKey.
+     * The same user + collectionKey always produces the same ID.
+     */
+    static makeCollectionId(userId, collectionKey) {
+        return shaxpir_common_1.CachingHasher.makeMd5Base62Hash(`${ContentKind_1.ContentKind.COLLECTION}-${userId}-${collectionKey}`);
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    /**
+     * Create a new Collection for a user.
+     */
+    static create(userId, params) {
+        const now = shaxpir_common_1.ClockService.getClock().now();
+        const collectionId = Collection.makeCollectionId(userId, params.collectionKey);
+        return repo_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: collectionId,
+                kind: ContentKind_1.ContentKind.COLLECTION,
+                id: collectionId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                collection_key: params.collectionKey,
+                conditions: params.conditions,
+                display: params.display,
+                // Initial Glicko-2 proficiency - high uncertainty, no data yet
+                proficiency: {
+                    rating: 0, // Start at zero (no demonstrated skill)
+                    rating_deviation: 50, // High initial uncertainty
+                    volatility: 0.06 // Moderate initial volatility
+                },
+                // Empty term scores map - populated as user reviews cards
+                term_scores: {},
+                // Progress starts at zero
+                total_cards: 0,
+                last_activity_utc: null,
+                // Visibility defaults
+                is_visible: params.isVisible ?? true,
+                is_builtin: params.isBuiltin ?? false
+            }
+        });
+    }
+    // ============================================================
+    // Payload accessor
+    // ============================================================
+    get payload() {
+        this.checkDisposed("Collection.payload");
+        return this.doc.data.payload;
+    }
+    // ============================================================
+    // Identity getters
+    // ============================================================
+    get collectionKey() {
+        this.checkDisposed("Collection.collectionKey");
+        return this.payload.collection_key;
+    }
+    // ============================================================
+    // Condition definition getters
+    // ============================================================
+    get conditions() {
+        this.checkDisposed("Collection.conditions");
+        return this.payload.conditions;
+    }
+    // ============================================================
+    // Display metadata getters
+    // ============================================================
+    get display() {
+        this.checkDisposed("Collection.display");
+        return this.payload.display;
+    }
+    get name() {
+        this.checkDisposed("Collection.name");
+        return this.payload.display.name;
+    }
+    get description() {
+        this.checkDisposed("Collection.description");
+        return this.payload.display.description;
+    }
+    get icon() {
+        this.checkDisposed("Collection.icon");
+        return this.payload.display.icon;
+    }
+    get sortOrder() {
+        this.checkDisposed("Collection.sortOrder");
+        return this.payload.display.sort_order;
+    }
+    // ============================================================
+    // Proficiency getters
+    // ============================================================
+    get proficiency() {
+        this.checkDisposed("Collection.proficiency");
+        return shaxpir_common_1.Struct.clone(this.payload.proficiency);
+    }
+    get proficiencyRating() {
+        this.checkDisposed("Collection.proficiencyRating");
+        return this.payload.proficiency.rating;
+    }
+    get proficiencyRatingDeviation() {
+        this.checkDisposed("Collection.proficiencyRatingDeviation");
+        return this.payload.proficiency.rating_deviation;
+    }
+    get proficiencyVolatility() {
+        this.checkDisposed("Collection.proficiencyVolatility");
+        return this.payload.proficiency.volatility;
+    }
+    // ============================================================
+    // Term scores getters
+    // ============================================================
+    get termScores() {
+        this.checkDisposed("Collection.termScores");
+        return this.payload.term_scores;
+    }
+    /**
+     * Get the number of unique terms the user has reviewed in this collection.
+     */
+    get termsReviewedCount() {
+        this.checkDisposed("Collection.termsReviewedCount");
+        return Object.keys(this.payload.term_scores).length;
+    }
+    /**
+     * Get the term score for a specific term, or undefined if not reviewed.
+     */
+    getTermScore(termId) {
+        this.checkDisposed("Collection.getTermScore");
+        return this.payload.term_scores[termId];
+    }
+    // ============================================================
+    // Progress statistics getters
+    // ============================================================
+    get totalCards() {
+        this.checkDisposed("Collection.totalCards");
+        return this.payload.total_cards;
+    }
+    get lastActivityUtc() {
+        this.checkDisposed("Collection.lastActivityUtc");
+        return this.payload.last_activity_utc;
+    }
+    // ============================================================
+    // Visibility and type getters
+    // ============================================================
+    get isVisible() {
+        this.checkDisposed("Collection.isVisible");
+        return this.payload.is_visible;
+    }
+    get isBuiltin() {
+        this.checkDisposed("Collection.isBuiltin");
+        return this.payload.is_builtin;
+    }
+    // ============================================================
+    // Computed properties
+    // ============================================================
+    /**
+     * Check if this collection has any proficiency data yet.
+     */
+    get hasProgress() {
+        this.checkDisposed("Collection.hasProgress");
+        return Object.keys(this.payload.term_scores).length > 0;
+    }
+    /**
+     * Calculate the percentage of terms that are "mastered" (theta >= 0.8).
+     * Returns 0 if no terms have been reviewed.
+     */
+    get masteryPercentage() {
+        this.checkDisposed("Collection.masteryPercentage");
+        const scores = Object.values(this.payload.term_scores);
+        if (scores.length === 0)
+            return 0;
+        const mastered = scores.filter(s => s.theta >= 0.8).length;
+        return Math.round((mastered / scores.length) * 100);
+    }
+    /**
+     * Calculate the percentage of total cards that have been reviewed.
+     * Returns 0 if total_cards is 0 or not set.
+     */
+    get reviewedPercentage() {
+        this.checkDisposed("Collection.reviewedPercentage");
+        if (this.payload.total_cards === 0)
+            return 0;
+        const reviewed = Object.keys(this.payload.term_scores).length;
+        return Math.round((reviewed / this.payload.total_cards) * 100);
+    }
+    /**
+     * Get counts of terms by grade (based on theta ranges).
+     */
+    getGradeDistribution() {
+        this.checkDisposed("Collection.getGradeDistribution");
+        const scores = Object.values(this.payload.term_scores);
+        return {
+            A: scores.filter(s => s.theta >= 0.8).length,
+            B: scores.filter(s => s.theta >= 0.6 && s.theta < 0.8).length,
+            C: scores.filter(s => s.theta >= 0.4 && s.theta < 0.6).length,
+            D: scores.filter(s => s.theta >= 0.2 && s.theta < 0.4).length,
+            F: scores.filter(s => s.theta < 0.2).length
+        };
+    }
+    // ============================================================
+    // Mutators
+    // ============================================================
+    /**
+     * Update the Glicko-2 proficiency rating.
+     */
+    setProficiency(value) {
+        this.checkDisposed("Collection.setProficiency");
+        if (!shaxpir_common_1.Struct.equals(this.payload.proficiency, value)) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'proficiency', 'rating'], value.rating);
+            batch.setPathValue(['payload', 'proficiency', 'rating_deviation'], value.rating_deviation);
+            batch.setPathValue(['payload', 'proficiency', 'volatility'], value.volatility);
+            batch.commit();
+        }
+    }
+    /**
+     * Update or add a term score in the collection.
+     */
+    setTermScore(termId, score) {
+        this.checkDisposed("Collection.setTermScore");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'term_scores', termId], score);
+        batch.commit();
+    }
+    /**
+     * Update just the theta value for an existing term score.
+     * Does nothing if the term doesn't exist in term_scores.
+     */
+    updateTermTheta(termId, theta) {
+        this.checkDisposed("Collection.updateTermTheta");
+        if (this.payload.term_scores[termId]) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'term_scores', termId, 'theta'], theta);
+            batch.commit();
+        }
+    }
+    /**
+     * Remove a term score from the collection.
+     */
+    removeTermScore(termId) {
+        this.checkDisposed("Collection.removeTermScore");
+        if (this.payload.term_scores[termId]) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.removeValueAtPath(['payload', 'term_scores', termId]);
+            batch.commit();
+        }
+    }
+    /**
+     * Update the cached total card count for this collection.
+     */
+    setTotalCards(count) {
+        this.checkDisposed("Collection.setTotalCards");
+        if (this.payload.total_cards !== count) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'total_cards'], count);
+            batch.commit();
+        }
+    }
+    /**
+     * Update the last activity timestamp.
+     */
+    setLastActivityUtc(timestamp) {
+        this.checkDisposed("Collection.setLastActivityUtc");
+        if (this.payload.last_activity_utc !== timestamp) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'last_activity_utc'], timestamp);
+            batch.commit();
+        }
+    }
+    /**
+     * Update visibility of this collection.
+     */
+    setVisible(visible) {
+        this.checkDisposed("Collection.setVisible");
+        if (this.payload.is_visible !== visible) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'is_visible'], visible);
+            batch.commit();
+        }
+    }
+    /**
+     * Update display metadata.
+     */
+    setDisplay(display) {
+        this.checkDisposed("Collection.setDisplay");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'display', 'name'], display.name);
+        batch.setPathValue(['payload', 'display', 'description'], display.description);
+        batch.setPathValue(['payload', 'display', 'sort_order'], display.sort_order);
+        if (display.icon !== undefined) {
+            batch.setPathValue(['payload', 'display', 'icon'], display.icon);
+        }
+        batch.commit();
+    }
+    /**
+     * Update the condition definition.
+     * Note: Changing conditions on a builtin collection is not recommended.
+     */
+    setConditions(conditions) {
+        this.checkDisposed("Collection.setConditions");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'conditions'], conditions);
+        batch.commit();
+    }
+}
+exports.Collection = Collection;

package/dist/models/Condition.d.ts

@@ -47,11 +47,12 @@ export interface ComponentCondition extends BaseCondition {
     mode: 'any' | 'all';
 }
 export type AnyCondition = TagCondition | GradeCondition | ThetaCondition | TemporalCondition | CountCondition | StarredCondition | DifficultyCondition | HasTermCondition | ComponentCondition;
-export interface ConditionFilters {
+export interface Conditions {
     all?: AnyCondition[];
     any?: AnyCondition[];
     none?: AnyCondition[];
 }
+export type ConditionFilters = Conditions;
 export declare const Condition: {
     tag: (name: string) => TagCondition;
     grade: (grade: "A" | "B" | "C" | "D" | "F") => GradeCondition;
@@ -89,44 +90,44 @@ export declare const Condition: {
     /**
      * Check if starred condition is required (in 'all' section)
      */
-    requiresStarred: (filters?: ConditionFilters) => boolean;
+    requiresStarred: (conditions?: Conditions) => boolean;
     /**
      * Check if starred condition is optional (in 'any' section)
      */
-    allowsStarred: (filters?: ConditionFilters) => boolean;
+    allowsStarred: (conditions?: Conditions) => boolean;
     /**
      * Check if starred condition is excluded (in 'none' section)
      */
-    excludesStarred: (filters?: ConditionFilters) => boolean;
+    excludesStarred: (conditions?: Conditions) => boolean;
     /**
      * Check if starred condition exists anywhere in filters
      */
-    hasStarred: (filters?: ConditionFilters) => boolean;
+    hasStarred: (conditions?: Conditions) => boolean;
     /**
      * Check if a specific tag is required (in 'all' section)
      */
-    requiresTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    requiresTag: (conditions: Conditions | undefined, tag: string) => boolean;
     /**
      * Check if a specific tag is optional (in 'any' section)
      */
-    allowsTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    allowsTag: (conditions: Conditions | undefined, tag: string) => boolean;
     /**
      * Check if a specific tag is excluded (in 'none' section)
      */
-    excludesTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    excludesTag: (conditions: Conditions | undefined, tag: string) => boolean;
     /**
      * Check if a specific grade is required (in 'all' section)
      */
-    requiresGrade: (filters: ConditionFilters | undefined, grade: "A" | "B" | "C" | "D" | "F") => boolean;
+    requiresGrade: (conditions: Conditions | undefined, grade: "A" | "B" | "C" | "D" | "F") => boolean;
     /**
      * Check if any condition of a specific type exists in filters
      */
-    hasConditionType: (filters: ConditionFilters | undefined, type: string) => boolean;
+    hasConditionType: (conditions: Conditions | undefined, type: string) => boolean;
     /**
      * Validate filters for logical inconsistencies
      * Returns an array of error messages, empty if valid
      */
-    validate: (filters?: ConditionFilters) => string[];
+    validate: (conditions?: Conditions) => string[];
     hasStarredInAll: (filters?: ConditionFilters) => boolean;
     hasStarredInAny: (filters?: ConditionFilters) => boolean;
     hasStarredInNone: (filters?: ConditionFilters) => boolean;

package/dist/models/Condition.js

@@ -49,84 +49,84 @@ exports.Condition = {
     /**
      * Check if starred condition is required (in 'all' section)
      */
-    requiresStarred: (filters) => {
-        return !!(filters?.all?.some(c => c.type === 'starred' && c.value === true));
+    requiresStarred: (conditions) => {
+        return !!(conditions?.all?.some(c => c.type === 'starred' && c.value === true));
     },
     /**
      * Check if starred condition is optional (in 'any' section)
      */
-    allowsStarred: (filters) => {
-        return !!(filters?.any?.some(c => c.type === 'starred' && c.value === true));
+    allowsStarred: (conditions) => {
+        return !!(conditions?.any?.some(c => c.type === 'starred' && c.value === true));
     },
     /**
      * Check if starred condition is excluded (in 'none' section)
      */
-    excludesStarred: (filters) => {
-        return !!(filters?.none?.some(c => c.type === 'starred' && c.value === true));
+    excludesStarred: (conditions) => {
+        return !!(conditions?.none?.some(c => c.type === 'starred' && c.value === true));
     },
     /**
      * Check if starred condition exists anywhere in filters
      */
-    hasStarred: (filters) => {
-        return exports.Condition.requiresStarred(filters) ||
-            exports.Condition.allowsStarred(filters) ||
-            exports.Condition.excludesStarred(filters);
+    hasStarred: (conditions) => {
+        return exports.Condition.requiresStarred(conditions) ||
+            exports.Condition.allowsStarred(conditions) ||
+            exports.Condition.excludesStarred(conditions);
     },
     /**
      * Check if a specific tag is required (in 'all' section)
      */
-    requiresTag: (filters, tag) => {
-        return !!(filters?.all?.some(c => c.type === 'tag' && c.tag === tag));
+    requiresTag: (conditions, tag) => {
+        return !!(conditions?.all?.some(c => c.type === 'tag' && c.tag === tag));
     },
     /**
      * Check if a specific tag is optional (in 'any' section)
      */
-    allowsTag: (filters, tag) => {
-        return !!(filters?.any?.some(c => c.type === 'tag' && c.tag === tag));
+    allowsTag: (conditions, tag) => {
+        return !!(conditions?.any?.some(c => c.type === 'tag' && c.tag === tag));
     },
     /**
      * Check if a specific tag is excluded (in 'none' section)
      */
-    excludesTag: (filters, tag) => {
-        return !!(filters?.none?.some(c => c.type === 'tag' && c.tag === tag));
+    excludesTag: (conditions, tag) => {
+        return !!(conditions?.none?.some(c => c.type === 'tag' && c.tag === tag));
     },
     /**
      * Check if a specific grade is required (in 'all' section)
      */
-    requiresGrade: (filters, grade) => {
-        return !!(filters?.all?.some(c => c.type === 'grade' && c.grade === grade));
+    requiresGrade: (conditions, grade) => {
+        return !!(conditions?.all?.some(c => c.type === 'grade' && c.grade === grade));
     },
     /**
      * Check if any condition of a specific type exists in filters
      */
-    hasConditionType: (filters, type) => {
-        return !!(filters?.all?.some(c => c.type === type) ||
-            filters?.any?.some(c => c.type === type) ||
-            filters?.none?.some(c => c.type === type));
+    hasConditionType: (conditions, type) => {
+        return !!(conditions?.all?.some(c => c.type === type) ||
+            conditions?.any?.some(c => c.type === type) ||
+            conditions?.none?.some(c => c.type === type));
     },
     /**
      * Validate filters for logical inconsistencies
      * Returns an array of error messages, empty if valid
      */
-    validate: (filters) => {
-        if (!filters)
+    validate: (conditions) => {
+        if (!conditions)
             return [];
         const errors = [];
         // Check for contradictory starred conditions
-        if (exports.Condition.requiresStarred(filters) && exports.Condition.excludesStarred(filters)) {
+        if (exports.Condition.requiresStarred(conditions) && exports.Condition.excludesStarred(conditions)) {
             errors.push('Cannot require starred items and exclude starred items at the same time');
         }
         // Check for contradictory tags
-        const allTags = filters.all?.filter(c => c.type === 'tag').map(c => c.tag) || [];
-        const noneTags = filters.none?.filter(c => c.type === 'tag').map(c => c.tag) || [];
+        const allTags = conditions.all?.filter(c => c.type === 'tag').map(c => c.tag) || [];
+        const noneTags = conditions.none?.filter(c => c.type === 'tag').map(c => c.tag) || [];
         allTags.forEach(tag => {
             if (noneTags.includes(tag)) {
                 errors.push(`Tag "${tag}" cannot be both required and excluded`);
             }
         });
         // Check for contradictory grades
-        const allGrades = filters.all?.filter(c => c.type === 'grade').map(c => c.grade) || [];
-        const noneGrades = filters.none?.filter(c => c.type === 'grade').map(c => c.grade) || [];
+        const allGrades = conditions.all?.filter(c => c.type === 'grade').map(c => c.grade) || [];
+        const noneGrades = conditions.none?.filter(c => c.type === 'grade').map(c => c.grade) || [];
         allGrades.forEach(grade => {
             if (noneGrades.includes(grade)) {
                 errors.push(`Grade "${grade}" cannot be both required and excluded`);
@@ -137,24 +137,24 @@ exports.Condition = {
             errors.push(`Cannot require multiple grades: ${allGrades.join(', ')} - an item can only have one grade`);
         }
         // Check for contradictory has_term conditions
-        const requiresTerm = filters.all?.some(c => c.type === 'has_term' && c.value === true);
-        const excludesTerm = filters.all?.some(c => c.type === 'has_term' && c.value === false);
+        const requiresTerm = conditions.all?.some(c => c.type === 'has_term' && c.value === true);
+        const excludesTerm = conditions.all?.some(c => c.type === 'has_term' && c.value === false);
         if (requiresTerm && excludesTerm) {
             errors.push('Cannot require both has_term and no_term');
         }
         // Check for implicit term requirements conflicting with no_term
         const termDependentTypes = ['grade', 'theta', 'starred', 'temporal', 'count'];
-        const hasTermDependentInAll = filters.all?.some(c => termDependentTypes.includes(c.type));
-        const hasTermDependentInAny = filters.any?.some(c => termDependentTypes.includes(c.type));
+        const hasTermDependentInAll = conditions.all?.some(c => termDependentTypes.includes(c.type));
+        const hasTermDependentInAny = conditions.any?.some(c => termDependentTypes.includes(c.type));
         if (excludesTerm && hasTermDependentInAll) {
-            const conflictingTypes = filters.all
+            const conflictingTypes = conditions.all
                 ?.filter(c => termDependentTypes.includes(c.type))
                 .map(c => c.type)
                 .join(', ');
             errors.push(`Conditions [${conflictingTypes}] require a term record, but has_term is false`);
         }
         if (excludesTerm && hasTermDependentInAny) {
-            const conflictingTypes = filters.any
+            const conflictingTypes = conditions.any
                 ?.filter(c => termDependentTypes.includes(c.type))
                 .map(c => c.type)
                 .join(', ');

package/dist/models/Content.d.ts

@@ -2,6 +2,7 @@ import { Doc } from '@shaxpir/sharedb/lib/client';
 import { CompactDateTime, MultiTime } from '@shaxpir/shaxpir-common';
 import { ShareSync } from '../repo';
 import { BillingPayload } from './Billing';
+import { CollectionPayload } from './Collection';
 import { ContentKind } from './ContentKind';
 import { DevicePayload } from './Device';
 import { ImagePayload } from './Image';
@@ -37,7 +38,7 @@ export interface ContentMeta {
     created_at: MultiTime;
     updated_at: MultiTime;
 }
-export type ContentPayload = BillingPayload | DevicePayload | ImagePayload | MetricPayload | ProfilePayload | ProgressPayload | SessionPayload | SocialPayload | TermPayload | UserPayload | WorkspacePayload;
+export type ContentPayload = BillingPayload | CollectionPayload | DevicePayload | ImagePayload | MetricPayload | ProfilePayload | ProgressPayload | SessionPayload | SocialPayload | TermPayload | UserPayload | WorkspacePayload;
 export declare abstract class Content extends Model {
     static ID_LENGTH: number;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);

package/dist/models/ContentKind.d.ts

@@ -1,5 +1,6 @@
 export declare enum ContentKind {
     BILLING = "billing",
+    COLLECTION = "collection",
     DEVICE = "device",
     METRIC = "metric",
     PROFILE = "profile",

package/dist/models/ContentKind.js

@@ -6,6 +6,7 @@ var ContentKind;
     // No models yet for these, but they're definitely coming
     ContentKind["BILLING"] = "billing";
     // These are all the current Content subclasses
+    ContentKind["COLLECTION"] = "collection";
     ContentKind["DEVICE"] = "device";
     ContentKind["METRIC"] = "metric";
     ContentKind["PROFILE"] = "profile";

package/dist/models/Device.d.ts

@@ -2,7 +2,7 @@ import { Doc } from '@shaxpir/sharedb/lib/client';
 import { CompactDateTime } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-import { ConditionFilters } from './Condition';
+import { Conditions } from './Condition';
 import { BuiltInDbState, DatabaseVersion } from '../util/Database';
 import { SearchHistory, SearchState } from './SearchState';
 export interface LastSync {
@@ -34,7 +34,7 @@ export interface DevicePayload {
     chinese_font?: string;
     raw_search_text?: string;
     star_filter?: boolean;
-    conditions?: ConditionFilters;
+    conditions?: Conditions;
     download_queue?: DownloadQueueItem[];
     upload_queue?: UploadQueueItem[];
     builtin_db?: BuiltInDbState;

package/dist/models/SearchState.d.ts

@@ -1,4 +1,4 @@
-import { ConditionFilters } from './Condition';
+import { Conditions } from './Condition';
 /**
  * Represents the data portion of a search state.
  * This is the shareable/persistable part of a search - it excludes
@@ -12,7 +12,7 @@ import { ConditionFilters } from './Condition';
 export interface SearchState {
     query?: string;
     senseRank?: number;
-    conditions?: ConditionFilters;
+    conditions?: Conditions;
 }
 /**
  * Maximum number of entries in the search history stack.

package/dist/models/Session.d.ts

@@ -1,7 +1,7 @@
 import { Doc } from '@shaxpir/sharedb/lib/client';
 import { MultiTime } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
-import { ConditionFilters } from './Condition';
+import { Conditions } from './Condition';
 import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
 import { Review } from './Review';
 import { UncertainValue } from './Progress';
@@ -12,7 +12,7 @@ export interface SessionConfig {
     };
     selection?: {
         difficulty_ramp?: number;
-        filters?: ConditionFilters;
+        filters?: Conditions;
         strategy?: {
             name: string;
             constants?: Record<string, any>;

package/dist/models/Workspace.d.ts

@@ -3,7 +3,7 @@ import { CompactDate, CompactDateTime, MultiTime } from "@shaxpir/shaxpir-common
 import { ShareSync } from '../repo';
 import { ArrayView } from './ArrayView';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-import { ConditionFilters } from './Condition';
+import { Conditions } from './Condition';
 import { Session } from './Session';
 export interface JourneyEntry {
     key: string;
@@ -16,7 +16,7 @@ export interface WorkspacePayload {
     journey: {
         [key: string]: CompactDateTime;
     };
-    global_conditions: ConditionFilters;
+    global_conditions: Conditions;
     uploaded_avatars: ContentId[];
     default_voice?: VoicePreference;
 }
@@ -30,7 +30,7 @@ export declare class Workspace extends Content {
     private _uploadedAvatarsView;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
     get payload(): WorkspacePayload;
-    getGlobalConditions(): ConditionFilters;
+    getGlobalConditions(): Conditions;
     static makeWorkspaceId(userId: ContentId): ContentId;
     /**
      * Validate that a WorkspacePayload has all required fields.
@@ -46,7 +46,7 @@ export declare class Workspace extends Content {
     hasJourneyDate(journeyKey: string): boolean;
     getJourneyDate(journeyKey: string): CompactDateTime;
     setJourneyDate(journeyKey: string, journeyDate: CompactDateTime): void;
-    setGlobalConditions(filters: ConditionFilters): void;
+    setGlobalConditions(conditions: Conditions): void;
     get defaultVoice(): VoicePreference;
     setDefaultVoice(value: VoicePreference): void;
 }

package/dist/models/Workspace.js

@@ -130,10 +130,10 @@ class Workspace extends Content_1.Content {
         batch.setPathValue(['payload', 'journey', journeyKey], journeyDate);
         batch.commit();
     }
-    setGlobalConditions(filters) {
+    setGlobalConditions(conditions) {
         this.checkDisposed("Workspace.setGlobalConditions");
         const batch = new Operation_1.BatchOperation(this);
-        batch.setPathValue(['payload', 'global_conditions'], filters);
+        batch.setPathValue(['payload', 'global_conditions'], conditions);
         batch.commit();
     }
     get defaultVoice() {

package/dist/models/index.d.ts

@@ -2,6 +2,7 @@ export * from './ArrayView';
 export * from './BayesianScore';
 export * from './Billing';
 export * from './ChangeModel';
+export * from './Collection';
 export * from './Condition';
 export * from './Content';
 export * from './ContentKind';

package/dist/models/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./ArrayView"), exports);
 __exportStar(require("./BayesianScore"), exports);
 __exportStar(require("./Billing"), exports);
 __exportStar(require("./ChangeModel"), exports);
+__exportStar(require("./Collection"), exports);
 __exportStar(require("./Condition"), exports);
 __exportStar(require("./Content"), exports);
 __exportStar(require("./ContentKind"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.9.13",
+  "version": "1.9.14",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"