@statezero/core 0.2.38 → 0.2.40

package/dist/syncEngine/sync.js

@@ -0,0 +1,419 @@
+import { getAllEventReceivers } from "../core/eventReceivers.js";
+import { operationRegistry, OperationMembership } from "./stores/operation.js";
+import { initializeAllEventReceivers } from "../config.js";
+import { getEventReceiver } from "../core/eventReceivers.js";
+import { querysetStoreRegistry, QuerysetStoreRegistry, } from "./registries/querysetStoreRegistry.js";
+import { modelStoreRegistry, ModelStoreRegistry, } from "./registries/modelStoreRegistry.js";
+import { metricRegistry, MetricRegistry } from "./registries/metricRegistry.js";
+import { getModelClass, getConfig } from "../config.js";
+import { isNil } from "lodash-es";
+import { QuerysetStore } from "./stores/querysetStore.js";
+import { v7 as uuidv7 } from "uuid";
+export class EventPayload {
+    constructor(data) {
+        this.event = data.event;
+        this.model = data.model;
+        this.operation_id = data.operation_id;
+        this.pk_field_name = data.pk_field_name;
+        this.configKey = data.configKey;
+        // Parse PK fields to numbers in instances
+        this.instances = data.instances?.map(instance => {
+            if (instance && this.pk_field_name && instance[this.pk_field_name] != null) {
+                return {
+                    ...instance,
+                    [this.pk_field_name]: Number(instance[this.pk_field_name])
+                };
+            }
+            return instance;
+        }) || data.instances;
+        this._cachedInstances = null;
+    }
+    get modelClass() {
+        return getModelClass(this.model, this.configKey);
+    }
+    async getFullInstances() {
+        if (this.event === "delete") {
+            throw new Error("Cannot fetch full instances for delete operation bozo...");
+        }
+        if (isNil(this._cachedInstances)) {
+            this._cachedInstances = await this.modelClass.objects
+                .filter({
+                [`${this.modelClass.primaryKeyField}__in`]: this.instances.map((instance) => instance[this.modelClass.primaryKeyField]),
+            })
+                .fetch();
+        }
+        return this._cachedInstances;
+    }
+}
+export class SyncManager {
+    constructor() {
+        this.handleEvent = (event) => {
+            let payload = new EventPayload(event);
+            let isLocalOperation = operationRegistry.has(payload.operation_id);
+            // Always process metrics immediately (they're lightweight)
+            if (this.registries.has(MetricRegistry)) {
+                this.processMetrics(payload);
+            }
+            if (isLocalOperation) {
+                // Check if any querysets were marked MAYBE for this operation
+                // These need to be synced since we couldn't determine membership client-side
+                this.syncMaybeQuerysets(payload.operation_id);
+                return;
+            }
+            // Add to batch for queryset/model processing
+            const key = `${event.model}::${event.configKey}`;
+            const now = Date.now();
+            // If this is the first event in the batch, start max wait timer
+            if (this.eventBatch.size === 0) {
+                this.batchStartTime = now;
+                this.maxWaitTimer = setTimeout(() => {
+                    this.processBatch("maxWait");
+                }, this.maxWaitMs);
+            }
+            this.eventBatch.set(key, {
+                event: payload,
+                firstSeen: this.eventBatch.has(key)
+                    ? this.eventBatch.get(key).firstSeen
+                    : now,
+            });
+            // Reset debounce timer
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.processBatch("debounce");
+            }, this.debounceMs);
+        };
+        this.registries = new Map();
+        // Map of registries to model sets
+        this.followedModels = new Map();
+        // Map of querysets to keep synced
+        this.followAllQuerysets = true;
+        this.followedQuerysets = new Map();
+        this.periodicSyncTimer = null;
+        // Batching for event processing
+        this.eventBatch = new Map(); // model::configKey -> { event, firstSeen }
+        this.debounceTimer = null;
+        this.maxWaitTimer = null;
+        this.debounceMs = 100; // Wait for rapid events to settle
+        this.maxWaitMs = 2000; // Maximum time to hold events
+        this.batchStartTime = null;
+    }
+    withTimeout(promise, ms) {
+        // If no timeout specified, use 2x the periodic sync interval, or 30s as fallback
+        if (!ms) {
+            try {
+                const config = getConfig();
+                const intervalSeconds = config.periodicSyncIntervalSeconds;
+                ms = intervalSeconds ? intervalSeconds * 2000 : 30000; // 2x interval in ms, or 30s default
+            }
+            catch {
+                ms = 30000; // 30s fallback if no config
+            }
+        }
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Sync timeout after ${ms}ms`)), ms)),
+        ]);
+    }
+    /**
+     * Initialize event handlers for all event receivers
+     */
+    initialize() {
+        // Initialize all event receivers
+        initializeAllEventReceivers();
+        // Get all registered event receivers
+        const eventReceivers = getAllEventReceivers();
+        // Register the event handlers with each receiver
+        eventReceivers.forEach((receiver, configKey) => {
+            if (receiver) {
+                // Model events go to handleEvent
+                receiver.addModelEventHandler(this.handleEvent.bind(this));
+            }
+        });
+        this.startPeriodicSync();
+    }
+    startPeriodicSync() {
+        if (this.periodicSyncTimer)
+            return;
+        try {
+            const config = getConfig();
+            const intervalSeconds = config.periodicSyncIntervalSeconds;
+            // If null or undefined, don't start periodic sync
+            if (!intervalSeconds) {
+                console.log("[SyncManager] Periodic sync disabled (set to null)");
+                return;
+            }
+            const intervalMs = intervalSeconds * 1000;
+            this.periodicSyncTimer = setInterval(() => {
+                this.syncStaleQuerysets();
+            }, intervalMs);
+            console.log(`[SyncManager] Periodic sync started: ${intervalSeconds}s intervals`);
+        }
+        catch (error) {
+            // If no config, don't start periodic sync by default
+            console.log("[SyncManager] No config found, periodic sync disabled by default");
+        }
+    }
+    async syncStaleQuerysets() {
+        const querysetRegistry = this.registries.get(QuerysetStoreRegistry);
+        if (!querysetRegistry)
+            return;
+        // Generate operationId for this sync batch - querysets in same chain will coordinate
+        const operationId = `periodic-sync-${uuidv7()}`;
+        // Get dbSynced keys (followed querysets)
+        const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
+        // Collect all stores to sync
+        const storesToSync = [];
+        for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
+            const isFollowed = this.isStoreFollowed(querysetRegistry, semanticKey);
+            if (this.followAllQuerysets || isFollowed) {
+                storesToSync.push(store);
+            }
+        }
+        if (storesToSync.length > 0) {
+            console.log(`[SyncManager] Periodic sync: syncing ${storesToSync.length} stores`);
+            // Run all groupSync calls in parallel - they coordinate via shared promise cache
+            await Promise.all(storesToSync.map(store => querysetRegistry.groupSync(store.queryset, operationId, dbSyncedKeys)));
+        }
+        // Prune unreferenced model instances
+        this.pruneUnreferencedModels();
+    }
+    pruneUnreferencedModels() {
+        const modelRegistry = this.registries.get(ModelStoreRegistry);
+        const querysetRegistry = this.registries.get(QuerysetStoreRegistry);
+        if (!modelRegistry || !querysetRegistry)
+            return;
+        // Prune each model store
+        for (const [modelClass, store] of modelRegistry._stores.entries()) {
+            store.pruneUnreferencedInstances(querysetRegistry);
+        }
+    }
+    isStoreFollowed(registry, semanticKey) {
+        const followingQuerysets = registry.followingQuerysets.get(semanticKey);
+        if (!followingQuerysets)
+            return false;
+        return [...followingQuerysets].some((queryset) => {
+            return this.isQuerysetFollowed(queryset);
+        });
+    }
+    cleanup() {
+        if (this.periodicSyncTimer) {
+            clearInterval(this.periodicSyncTimer);
+            this.periodicSyncTimer = null;
+        }
+        // Clean up batch timers
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.maxWaitTimer) {
+            clearTimeout(this.maxWaitTimer);
+            this.maxWaitTimer = null;
+        }
+    }
+    followModel(registry, modelClass) {
+        const models = this.followedModels.get(registry) || new Set();
+        this.followedModels.set(registry, models);
+        if (models.has(modelClass))
+            return;
+        const alreadyFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
+        models.add(modelClass);
+        if (!alreadyFollowed) {
+            getEventReceiver(modelClass.configKey)?.subscribe(modelClass.modelName, this.handleEvent);
+        }
+    }
+    unfollowModel(registry, modelClass) {
+        const models = this.followedModels.get(registry);
+        if (!models)
+            return;
+        models.delete(modelClass);
+        const stillFollowed = [...this.followedModels.values()].some((set) => set.has(modelClass));
+        if (!stillFollowed) {
+            getEventReceiver(modelClass.configKey)?.unsubscribe(modelClass.modelName, this.handleEvent);
+        }
+    }
+    manageRegistry(registry) {
+        this.registries.set(registry.constructor, registry);
+        registry.setSyncManager(this);
+    }
+    removeRegistry(registry) {
+        this.registries.delete(registry.constructor);
+    }
+    /**
+     * Sync querysets that were marked MAYBE for a local operation.
+     * Called when a backend event arrives for an operation we initiated locally.
+     */
+    syncMaybeQuerysets(operationId) {
+        const states = operationRegistry.getQuerysetStates(operationId);
+        if (!states)
+            return;
+        const registry = this.registries.get(QuerysetStoreRegistry);
+        if (!registry)
+            return;
+        const storesToSync = [];
+        for (const [semanticKey, membership] of states.entries()) {
+            if (membership === OperationMembership.MAYBE) {
+                const store = registry._stores.get(semanticKey);
+                if (store) {
+                    storesToSync.push(store);
+                }
+            }
+        }
+        if (storesToSync.length === 0)
+            return;
+        console.log(`[SyncManager] Syncing ${storesToSync.length} MAYBE querysets for local operation ${operationId}`);
+        const syncOperationId = `maybe-sync-${uuidv7()}`;
+        const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
+        Promise.all(storesToSync.map(store => registry.groupSync(store.queryset, syncOperationId, dbSyncedKeys)));
+    }
+    processBatch(reason = "unknown") {
+        if (this.eventBatch.size === 0)
+            return;
+        // Clear timers
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.maxWaitTimer) {
+            clearTimeout(this.maxWaitTimer);
+            this.maxWaitTimer = null;
+        }
+        const events = Array.from(this.eventBatch.values()).map((item) => item.event);
+        const waitTime = Date.now() - this.batchStartTime;
+        this.eventBatch.clear();
+        this.batchStartTime = null;
+        console.log(`[SyncManager] Processing batch of ${events.length} events (reason: ${reason}, waited: ${waitTime}ms)`);
+        // Group events by model for efficient processing
+        const eventsByModel = new Map();
+        events.forEach((event) => {
+            const key = `${event.model}::${event.configKey}`;
+            if (!eventsByModel.has(key)) {
+                eventsByModel.set(key, []);
+            }
+            eventsByModel.get(key).push(event);
+        });
+        // Process each model's events as a batch
+        eventsByModel.forEach((modelEvents, modelKey) => {
+            const event = modelEvents[0]; // Use first event as representative
+            if (this.registries.has(QuerysetStoreRegistry)) {
+                this.processQuerysetsBatch(event, modelEvents);
+            }
+            if (this.registries.has(ModelStoreRegistry)) {
+                this.processModels(event);
+            }
+        });
+    }
+    isQuerysetFollowed(queryset) {
+        const activeSemanticKeys = new Set([...this.followedQuerysets].map((qs) => qs.semanticKey));
+        let current = queryset;
+        while (current) {
+            if (activeSemanticKeys.has(current.semanticKey)) {
+                return true;
+            }
+            current = current.__parent;
+        }
+        return false;
+    }
+    processQuerysetsBatch(representativeEvent, allEvents) {
+        const registry = this.registries.get(QuerysetStoreRegistry);
+        // Collect all stores that need syncing for this model
+        const storesToSync = [];
+        for (const [semanticKey, store] of registry._stores.entries()) {
+            if (store.modelClass.modelName === representativeEvent.model &&
+                store.modelClass.configKey === representativeEvent.configKey) {
+                if (this.followAllQuerysets) {
+                    storesToSync.push(store);
+                    continue;
+                }
+                const followingQuerysets = registry.followingQuerysets.get(semanticKey);
+                if (followingQuerysets) {
+                    const shouldSync = [...followingQuerysets].some((queryset) => {
+                        return this.isQuerysetFollowed(queryset);
+                    });
+                    if (shouldSync) {
+                        storesToSync.push(store);
+                    }
+                }
+            }
+        }
+        if (storesToSync.length === 0)
+            return;
+        // Sync all relevant stores for this model
+        console.log(`[SyncManager] Syncing ${storesToSync.length} queryset stores for ${representativeEvent.model}`);
+        // Generate operationId for this batch - querysets in same chain will coordinate
+        const operationId = `remote-event-${uuidv7()}`;
+        // Get dbSynced keys (followed querysets)
+        const dbSyncedKeys = new Set([...this.followedQuerysets].map(qs => qs.semanticKey));
+        // Run all groupSync calls in parallel - they coordinate via shared promise cache
+        Promise.all(storesToSync.map(store => registry.groupSync(store.queryset, operationId, dbSyncedKeys)));
+    }
+    processMetrics(event) {
+        const registry = this.registries.get(MetricRegistry);
+        for (const [key, entry] of registry._stores.entries()) {
+            // Check if the store has a queryset with the model class AND correct backend
+            if (entry.queryset &&
+                entry.queryset.modelClass.modelName === event.model &&
+                entry.queryset.modelClass.configKey === event.configKey) {
+                if (this.followAllQuerysets) {
+                    entry.store.sync();
+                    continue;
+                }
+                // Check if this queryset (or any parent) is being followed
+                if (this.isQuerysetFollowed(entry.queryset)) {
+                    console.log(`syncing metric store for key: ${key}`);
+                    entry.store.sync();
+                }
+            }
+        }
+    }
+    processModels(event) {
+        const registry = this.registries.get(ModelStoreRegistry);
+        if (!registry)
+            return;
+        const modelStore = registry.getStore(event.modelClass);
+        if (!modelStore)
+            return;
+        // Get PKs from the event
+        const eventPks = new Set((event.instances || [])
+            .filter(inst => inst && inst[event.pk_field_name] != null)
+            .map(inst => inst[event.pk_field_name]));
+        if (eventPks.size === 0)
+            return;
+        // Get PKs that are already in the model store's ground truth
+        const groundTruthPks = new Set(modelStore.groundTruthPks);
+        // Get PKs that are top-level in ANY queryset for this model (not just followed ones)
+        const querysetRegistry = this.registries.get(QuerysetStoreRegistry);
+        const topLevelQuerysetPks = new Set();
+        if (querysetRegistry) {
+            for (const [semanticKey, store] of querysetRegistry._stores.entries()) {
+                // Check ALL querysets for this model (permanent and temporary)
+                if (store.modelClass.modelName === event.model &&
+                    store.modelClass.configKey === event.configKey) {
+                    // Get this queryset's ground truth PKs (top-level instances)
+                    // Don't use render() as it applies operations - we just want ground truth
+                    store.groundTruthPks.forEach(pk => topLevelQuerysetPks.add(pk));
+                }
+            }
+        }
+        // Find PKs that are:
+        // 1. In the event
+        // 2. Already in ground truth (we're tracking them)
+        // 3. NOT top-level in any queryset (they're only nested/included)
+        const pksToSync = [];
+        eventPks.forEach(pk => {
+            if (groundTruthPks.has(pk) && !topLevelQuerysetPks.has(pk)) {
+                pksToSync.push(pk);
+            }
+        });
+        if (pksToSync.length > 0) {
+            console.log(`[SyncManager] Syncing ${pksToSync.length} nested-only PKs for ${event.model}: ${pksToSync}`);
+            modelStore.sync(pksToSync);
+        }
+    }
+}
+const syncManager = new SyncManager();
+syncManager.manageRegistry(querysetStoreRegistry);
+syncManager.manageRegistry(modelStoreRegistry);
+syncManager.manageRegistry(metricRegistry);
+export { syncManager };

package/dist/testing.d.ts

@@ -0,0 +1,63 @@
+export function createTestConfig({ apiUrl, backendKey, generatedTypesDir, generatedActionsDir, getAuthHeaders, testAuthUserId, testAuthHeaders, testAuthHeaderName, eventsType, fileRootURL, fileUploadMode, }: {
+    apiUrl: any;
+    backendKey?: string | undefined;
+    generatedTypesDir?: string | undefined;
+    generatedActionsDir: any;
+    getAuthHeaders: any;
+    testAuthUserId: any;
+    testAuthHeaders: any;
+    testAuthHeaderName?: string | undefined;
+    eventsType?: string | undefined;
+    fileRootURL: any;
+    fileUploadMode: any;
+}): {
+    config: {
+        backendConfigs: {
+            [backendKey]: {
+                API_URL: any;
+                GENERATED_TYPES_DIR: string;
+                getAuthHeaders: () => any;
+                events: {
+                    type: string;
+                };
+            };
+        };
+    };
+    testHeaders: {
+        setSeeding(enabled: any): void;
+        setReset(enabled: any): void;
+        setAuthUserId(userId: any): void;
+        withSeeding(fn: any): any;
+        withReset(fn: any): any;
+        withAuthUserId(userId: any, fn: any): any;
+    };
+};
+export function setupTestStateZero({ apiUrl, backendKey, generatedTypesDir, generatedActionsDir, getAuthHeaders, testAuthUserId, testAuthHeaders, testAuthHeaderName, eventsType, fileRootURL, fileUploadMode, getModelClass, adapters, }: {
+    apiUrl: any;
+    backendKey?: string | undefined;
+    generatedTypesDir?: string | undefined;
+    generatedActionsDir: any;
+    getAuthHeaders: any;
+    testAuthUserId: any;
+    testAuthHeaders: any;
+    testAuthHeaderName: any;
+    eventsType?: string | undefined;
+    fileRootURL: any;
+    fileUploadMode: any;
+    getModelClass: any;
+    adapters: any;
+}): {
+    setSeeding(enabled: any): void;
+    setReset(enabled: any): void;
+    setAuthUserId(userId: any): void;
+    withSeeding(fn: any): any;
+    withReset(fn: any): any;
+    withAuthUserId(userId: any, fn: any): any;
+};
+export function createActionMocker(actionRegistry: any): {
+    mock(actionName: any, handler: any, backendKey?: string): void;
+    restore(actionName: any, backendKey?: string): void;
+    restoreAll(): void;
+};
+export function seedRemote(testHeaders: any, seedFn: any): Promise<any>;
+export function resetRemote(testHeaders: any, resetFn: any): Promise<any>;

package/dist/testing.js

@@ -0,0 +1,175 @@
+import { setupStateZero } from "./setup.js";
+function _normalizeHeaders(headers) {
+    return headers && typeof headers === "object" ? { ...headers } : {};
+}
+function _withFlag(state, key, fn) {
+    const previous = state[key];
+    state[key] = true;
+    try {
+        const result = fn();
+        if (result && typeof result.then === "function") {
+            return result.finally(() => {
+                state[key] = previous;
+            });
+        }
+        state[key] = previous;
+        return result;
+    }
+    catch (error) {
+        state[key] = previous;
+        throw error;
+    }
+}
+export function createTestConfig({ apiUrl, backendKey = "default", generatedTypesDir = "./src/models/", generatedActionsDir, getAuthHeaders, testAuthUserId, testAuthHeaders, testAuthHeaderName = "X-TEST-USER-ID", eventsType = "none", fileRootURL, fileUploadMode, }) {
+    const state = {
+        seeding: false,
+        reset: false,
+        authUserId: undefined,
+    };
+    const testHeaders = {
+        setSeeding(enabled) {
+            state.seeding = Boolean(enabled);
+        },
+        setReset(enabled) {
+            state.reset = Boolean(enabled);
+        },
+        setAuthUserId(userId) {
+            state.authUserId = userId;
+        },
+        withSeeding(fn) {
+            return _withFlag(state, "seeding", fn);
+        },
+        withReset(fn) {
+            return _withFlag(state, "reset", fn);
+        },
+        withAuthUserId(userId, fn) {
+            const previous = state.authUserId;
+            state.authUserId = userId;
+            try {
+                const result = fn();
+                if (result && typeof result.then === "function") {
+                    return result.finally(() => {
+                        state.authUserId = previous;
+                    });
+                }
+                state.authUserId = previous;
+                return result;
+            }
+            catch (error) {
+                state.authUserId = previous;
+                throw error;
+            }
+        },
+    };
+    const wrappedGetAuthHeaders = () => {
+        const headers = _normalizeHeaders(getAuthHeaders ? getAuthHeaders() : {});
+        const extraAuthHeaders = typeof testAuthHeaders === "function"
+            ? testAuthHeaders()
+            : testAuthHeaders;
+        if (extraAuthHeaders && typeof extraAuthHeaders === "object") {
+            Object.assign(headers, extraAuthHeaders);
+        }
+        const activeUserId = state.authUserId ?? testAuthUserId;
+        if (activeUserId !== undefined && activeUserId !== null) {
+            headers[testAuthHeaderName] = String(activeUserId);
+        }
+        if (state.seeding) {
+            headers["X-TEST-SEEDING"] = "1";
+        }
+        if (state.reset) {
+            headers["X-TEST-RESET"] = "1";
+        }
+        return headers;
+    };
+    const backendConfig = {
+        API_URL: apiUrl,
+        GENERATED_TYPES_DIR: generatedTypesDir,
+        getAuthHeaders: wrappedGetAuthHeaders,
+        events: { type: eventsType },
+    };
+    if (generatedActionsDir) {
+        backendConfig.GENERATED_ACTIONS_DIR = generatedActionsDir;
+    }
+    if (fileRootURL) {
+        backendConfig.fileRootURL = fileRootURL;
+    }
+    if (fileUploadMode) {
+        backendConfig.fileUploadMode = fileUploadMode;
+    }
+    const config = {
+        backendConfigs: {
+            [backendKey]: backendConfig,
+        },
+    };
+    return { config, testHeaders };
+}
+export function setupTestStateZero({ apiUrl, backendKey = "default", generatedTypesDir = "./src/models/", generatedActionsDir, getAuthHeaders, testAuthUserId, testAuthHeaders, testAuthHeaderName, eventsType = "none", fileRootURL, fileUploadMode, getModelClass, adapters, }) {
+    const { config, testHeaders } = createTestConfig({
+        apiUrl,
+        backendKey,
+        generatedTypesDir,
+        generatedActionsDir,
+        getAuthHeaders,
+        testAuthUserId,
+        testAuthHeaders,
+        testAuthHeaderName,
+        eventsType,
+        fileRootURL,
+        fileUploadMode,
+    });
+    setupStateZero(config, getModelClass, adapters);
+    return testHeaders;
+}
+export function createActionMocker(actionRegistry) {
+    const original = new Map();
+    function resolveRegistry(backendKey) {
+        if (!actionRegistry) {
+            throw new Error("actionRegistry is required");
+        }
+        return actionRegistry[backendKey] || actionRegistry;
+    }
+    return {
+        mock(actionName, handler, backendKey = "default") {
+            const registry = resolveRegistry(backendKey);
+            if (!registry || !registry[actionName]) {
+                throw new Error(`Action '${actionName}' not found in registry`);
+            }
+            const key = `${backendKey}:${actionName}`;
+            if (!original.has(key)) {
+                original.set(key, registry[actionName]);
+            }
+            registry[actionName] = handler;
+        },
+        restore(actionName, backendKey = "default") {
+            const registry = resolveRegistry(backendKey);
+            const key = `${backendKey}:${actionName}`;
+            if (!original.has(key)) {
+                return;
+            }
+            registry[actionName] = original.get(key);
+            original.delete(key);
+        },
+        restoreAll() {
+            for (const [key, fn] of original.entries()) {
+                const [backendKey, actionName] = key.split(":");
+                const registry = resolveRegistry(backendKey);
+                if (registry && actionName in registry) {
+                    registry[actionName] = fn;
+                }
+            }
+            original.clear();
+        },
+    };
+}
+export async function seedRemote(testHeaders, seedFn) {
+    if (!testHeaders || typeof testHeaders.withSeeding !== "function") {
+        throw new Error("seedRemote requires testHeaders from createTestConfig/setupTestStateZero");
+    }
+    return testHeaders.withSeeding(seedFn);
+}
+export async function resetRemote(testHeaders, resetFn) {
+    if (!testHeaders || typeof testHeaders.withReset !== "function") {
+        throw new Error("resetRemote requires testHeaders from createTestConfig/setupTestStateZero");
+    }
+    return testHeaders.withReset(resetFn);
+}

package/dist/vue-entry.d.ts

@@ -0,0 +1,15 @@
+import { ModelAdaptor } from './adaptors/vue/index.js';
+import { QuerySetAdaptor } from './adaptors/vue/index.js';
+import { MetricAdaptor } from './adaptors/vue/index.js';
+import { useQueryset } from './adaptors/vue/index.js';
+import { querysets } from './adaptors/vue/index.js';
+import { LayoutRenderer } from './adaptors/vue/index.js';
+import { AlertElement } from './adaptors/vue/index.js';
+import { LabelElement } from './adaptors/vue/index.js';
+import { DividerElement } from './adaptors/vue/index.js';
+import { DisplayElement } from './adaptors/vue/index.js';
+import { GroupElement } from './adaptors/vue/index.js';
+import { TabsElement } from './adaptors/vue/index.js';
+import { ErrorBlock } from './adaptors/vue/index.js';
+import { createDefaultComponents } from './adaptors/vue/index.js';
+export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor, useQueryset, querysets, LayoutRenderer, AlertElement, LabelElement, DividerElement, DisplayElement, GroupElement, TabsElement, ErrorBlock, createDefaultComponents };

package/dist/vue-entry.js

@@ -0,0 +1,7 @@
+import { ModelAdaptor, QuerySetAdaptor, MetricAdaptor, useQueryset, querysets } from './adaptors/vue/index.js';
+import { LayoutRenderer, AlertElement, LabelElement, DividerElement, DisplayElement, GroupElement, TabsElement, ErrorBlock, createDefaultComponents } from './adaptors/vue/index.js';
+export { 
+// Reactivity
+ModelAdaptor, QuerySetAdaptor, MetricAdaptor, useQueryset, querysets, 
+// Layout components
+LayoutRenderer, AlertElement, LabelElement, DividerElement, DisplayElement, GroupElement, TabsElement, ErrorBlock, createDefaultComponents };