@someonegg/codex-hub 0.0.0-stage → 0.1.0

package/dist/server/server/repository/catalog-snapshot-store.js

@@ -0,0 +1,304 @@
+import { encodeStringTuple, opaqueIdForParts } from "../security/opaque-id.js";
+import { RefreshDiagnosticLogger, } from "./diagnostic-logger.js";
+import { RefreshCoordinator } from "./refresh-coordinator.js";
+import { TimelinePrefixRegistry, } from "./timeline-prefix-registry.js";
+export const DEFAULT_CATALOG_FRESHNESS_MS = 1_500;
+export const MAX_CATALOG_DIAGNOSTICS = 50;
+export class CatalogSnapshotStore {
+    freshnessMs;
+    now;
+    #coordinator = new RefreshCoordinator();
+    #diagnosticLogger;
+    #prefixes;
+    #sources;
+    #snapshot = null;
+    #aggregate = null;
+    #aggregateDiagnostics = new Map();
+    #lastDiscoveryAt = Number.NEGATIVE_INFINITY;
+    constructor(sources, freshnessMs = DEFAULT_CATALOG_FRESHNESS_MS, now = performance.now.bind(performance), dependencies = {}) {
+        this.freshnessMs = freshnessMs;
+        this.now = now;
+        assertUniqueSources(sources);
+        this.#diagnosticLogger = new RefreshDiagnosticLogger(dependencies.diagnosticLogger);
+        this.#sources = [...sources];
+        this.#prefixes = new TimelinePrefixRegistry(dependencies.timelinePrefixIndexBuilder);
+    }
+    async current() {
+        const snapshot = this.#snapshot;
+        if (snapshot !== null && this.now() - this.#lastDiscoveryAt < this.freshnessMs) {
+            return snapshot;
+        }
+        return this.#coordinator.run(() => this.#discover());
+    }
+    async refresh() {
+        return this.#coordinator.run(() => this.#discover());
+    }
+    async #discover() {
+        const snapshot = await this.#rebuild();
+        this.#lastDiscoveryAt = this.now();
+        return snapshot;
+    }
+    async #rebuild() {
+        const loadedSources = await Promise.all(this.#sources.map(async (source) => ({
+            descriptor: source.descriptor,
+            snapshot: await source.refresh(),
+        })));
+        const signature = aggregateSignature(loadedSources);
+        const previous = this.#snapshot;
+        if (previous?.signature === signature) {
+            this.#diagnosticLogger.update(loadedSources, this.#aggregateDiagnostics);
+            return previous;
+        }
+        const sourceDiagnostics = [];
+        for (const { snapshot } of loadedSources) {
+            if (sourceDiagnostics.length >= MAX_CATALOG_DIAGNOSTICS)
+                break;
+            for (const item of snapshot.diagnostics) {
+                if (sourceDiagnostics.length >= MAX_CATALOG_DIAGNOSTICS)
+                    break;
+                sourceDiagnostics.push({ ...item });
+            }
+        }
+        const linked = linkRelationships(loadedSources, this.#aggregate, MAX_CATALOG_DIAGNOSTICS - sourceDiagnostics.length);
+        const diagnostics = [...sourceDiagnostics, ...linked.diagnostics];
+        const normalizedSessions = linked.sessions;
+        const preparedPrefixes = this.#prefixes.prepare(normalizedSessions, linked.dirtyIds);
+        const snapshot = {
+            signature,
+            diagnostics,
+            sessions: preparedPrefixes.sessions,
+        };
+        preparedPrefixes.commit();
+        this.#aggregate = {
+            inputs: linked.inputs,
+            nativeBuckets: linked.nativeBuckets,
+            parentNativeDependents: linked.parentNativeDependents,
+            resolvedParents: linked.resolvedParents,
+            sessions: normalizedSessions,
+        };
+        this.#snapshot = snapshot;
+        this.#aggregateDiagnostics = linked.aggregateDiagnostics;
+        this.#diagnosticLogger.update(loadedSources, linked.aggregateDiagnostics);
+        return snapshot;
+    }
+}
+function assertUniqueSources(sources) {
+    for (const field of ["instanceKey", "sourceInstanceId"]) {
+        const keys = new Set();
+        for (const { descriptor } of sources) {
+            const key = descriptor[field];
+            if (!key.trim())
+                throw new Error(`Empty session source ${field}`);
+            if (keys.has(key)) {
+                const label = field === "instanceKey" ? "instance key" : field;
+                throw new Error(`Duplicate session source ${label}: ${key}`);
+            }
+            keys.add(key);
+        }
+    }
+}
+function aggregateSignature(sources) {
+    return JSON.stringify([...sources]
+        .sort((left, right) => left.descriptor.instanceKey.localeCompare(right.descriptor.instanceKey))
+        .map(({ descriptor, snapshot }) => ({
+        source: descriptor.instanceKey,
+        signature: snapshot.signature,
+    })));
+}
+function linkRelationships(sources, previous, diagnosticLimit) {
+    const diagnostics = [];
+    const aggregateDiagnostics = new Map();
+    const inputs = new Map();
+    const nativeBuckets = new Map();
+    const parentNativeDependents = new Map();
+    for (const { descriptor, snapshot } of sources) {
+        const localIds = new Set();
+        for (const entry of snapshot.sessions) {
+            if (localIds.has(entry.localId)) {
+                const diagnostic = {
+                    code: "duplicate_source_session_id",
+                    severity: "error",
+                    message: "A source returned duplicate stable session identities.",
+                    ordinal: null,
+                };
+                if (diagnostics.length < diagnosticLimit)
+                    diagnostics.push(diagnostic);
+                const group = aggregateDiagnostics.get(descriptor.sourceInstanceId) ?? [];
+                const sessionId = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+                if (group.length < MAX_CATALOG_DIAGNOSTICS &&
+                    !group.some((item) => item.sessionId === sessionId)) {
+                    group.push({ sessionId, diagnostic });
+                    aggregateDiagnostics.set(descriptor.sourceInstanceId, group);
+                }
+                continue;
+            }
+            localIds.add(entry.localId);
+            const id = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+            const input = {
+                descriptor,
+                id,
+                nativeSessionId: entry.nativeSessionId,
+                parentNativeSessionId: entry.parentNativeSessionId,
+                origin: entry.origin,
+                normalized: entry.normalized,
+            };
+            inputs.set(id, input);
+            if (entry.nativeSessionId !== null) {
+                const nativeKey = identityKey(descriptor.instanceKey, entry.nativeSessionId);
+                const bucket = nativeBuckets.get(nativeKey);
+                if (bucket === undefined)
+                    nativeBuckets.set(nativeKey, [id]);
+                else
+                    bucket.push(id);
+            }
+            if (entry.parentNativeSessionId !== null) {
+                const parentKey = identityKey(descriptor.instanceKey, entry.parentNativeSessionId);
+                const dependents = parentNativeDependents.get(parentKey);
+                if (dependents === undefined) {
+                    parentNativeDependents.set(parentKey, new Set([id]));
+                }
+                else {
+                    dependents.add(id);
+                }
+            }
+        }
+    }
+    const resolvedParents = new Map();
+    const children = new Map();
+    for (const item of inputs.values()) {
+        const parentId = item.parentNativeSessionId === null
+            ? null
+            : uniqueIdentity(nativeBuckets.get(identityKey(item.descriptor.instanceKey, item.parentNativeSessionId)));
+        resolvedParents.set(item.id, parentId);
+        if (parentId !== null) {
+            const childIds = children.get(parentId);
+            if (childIds === undefined)
+                children.set(parentId, [item.id]);
+            else
+                childIds.push(item.id);
+        }
+    }
+    const dirtyIds = findDirtyIds(inputs, nativeBuckets, parentNativeDependents, resolvedParents, previous);
+    const sessions = new Map();
+    for (const [id, item] of inputs) {
+        const cached = previous?.sessions.get(id);
+        if (cached !== undefined && !dirtyIds.has(id)) {
+            sessions.set(id, cached);
+            continue;
+        }
+        const source = item.normalized.session;
+        sessions.set(id, {
+            session: {
+                ...source,
+                id,
+                sourceId: item.nativeSessionId,
+                origin: {
+                    ...item.origin,
+                    sourceType: item.descriptor.sourceType,
+                    sourceInstanceId: item.descriptor.sourceInstanceId,
+                    agentName: item.descriptor.displayName,
+                },
+                isChild: item.parentNativeSessionId !== null,
+                parentId: resolvedParents.get(id) ?? null,
+                childIds: [...(children.get(id) ?? [])].sort(compareCodeUnits),
+            },
+            timeline: item.normalized.timeline,
+            toolDetails: item.normalized.toolDetails,
+            directiveDetails: item.normalized.directiveDetails,
+            internalDetails: item.normalized.internalDetails,
+            interaction: item.normalized.interaction ?? null,
+        });
+    }
+    return {
+        sessions,
+        diagnostics,
+        aggregateDiagnostics,
+        dirtyIds,
+        inputs,
+        nativeBuckets,
+        parentNativeDependents,
+        resolvedParents,
+    };
+}
+function findDirtyIds(inputs, nativeBuckets, parentNativeDependents, resolvedParents, previous) {
+    const dirty = new Set();
+    if (previous === null) {
+        for (const id of inputs.keys())
+            dirty.add(id);
+        return dirty;
+    }
+    for (const [id, input] of inputs) {
+        const oldInput = previous.inputs.get(id);
+        // SourceSessionEntry wrappers may be rebuilt on every refresh. The Codex
+        // adapter reuses unchanged immutable NormalizedSession objects, so identity
+        // is only a safe optimization hint: a new object means "recompute", never
+        // that the public revision must change. The final-view digest decides that.
+        if (oldInput === undefined || !sameSourceInput(oldInput, input)) {
+            dirty.add(id);
+        }
+        const oldParent = previous.resolvedParents.get(id) ?? null;
+        const newParent = resolvedParents.get(id) ?? null;
+        if (oldInput === undefined || oldParent !== newParent) {
+            dirty.add(id);
+            if (oldParent !== null && inputs.has(oldParent))
+                dirty.add(oldParent);
+            if (newParent !== null)
+                dirty.add(newParent);
+        }
+    }
+    for (const [id] of previous.inputs) {
+        if (inputs.has(id))
+            continue;
+        const oldParent = previous.resolvedParents.get(id) ?? null;
+        if (oldParent !== null && inputs.has(oldParent))
+            dirty.add(oldParent);
+    }
+    const identityKeys = new Set([...previous.nativeBuckets.keys(), ...nativeBuckets.keys()]);
+    for (const key of identityKeys) {
+        if (uniqueIdentity(previous.nativeBuckets.get(key)) === uniqueIdentity(nativeBuckets.get(key))) {
+            continue;
+        }
+        const dependents = new Set([
+            ...(previous.parentNativeDependents.get(key) ?? []),
+            ...(parentNativeDependents.get(key) ?? []),
+        ]);
+        for (const id of dependents) {
+            if (!inputs.has(id))
+                continue;
+            dirty.add(id);
+            const oldParent = previous.resolvedParents.get(id) ?? null;
+            const newParent = resolvedParents.get(id) ?? null;
+            if (oldParent !== null && inputs.has(oldParent))
+                dirty.add(oldParent);
+            if (newParent !== null)
+                dirty.add(newParent);
+        }
+    }
+    return dirty;
+}
+function sameSourceInput(left, right) {
+    return (left.normalized === right.normalized &&
+        left.nativeSessionId === right.nativeSessionId &&
+        left.parentNativeSessionId === right.parentNativeSessionId &&
+        sameOrigin(left.origin, right.origin) &&
+        left.descriptor.sourceType === right.descriptor.sourceType &&
+        left.descriptor.sourceInstanceId === right.descriptor.sourceInstanceId &&
+        left.descriptor.displayName === right.descriptor.displayName);
+}
+function sameOrigin(left, right) {
+    return (left.sourceType === right.sourceType &&
+        left.sourceInstanceId === right.sourceInstanceId &&
+        left.agentName === right.agentName &&
+        left.agentVersion === right.agentVersion &&
+        left.formatVersion === right.formatVersion);
+}
+function uniqueIdentity(bucket) {
+    return bucket?.length === 1 ? bucket[0] : null;
+}
+function identityKey(sourceKey, nativeId) {
+    return encodeStringTuple(sourceKey, nativeId);
+}
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+//# sourceMappingURL=catalog-snapshot-store.js.map

package/dist/server/server/repository/diagnostic-logger.js

@@ -0,0 +1,70 @@
+import { opaqueIdForParts } from "../security/opaque-id.js";
+const stderrLogger = {
+    log(record) {
+        console.error("Session diagnostic", record);
+    },
+};
+/** Refresh-only state: bounded by the current sources and sessions. */
+export class RefreshDiagnosticLogger {
+    logger;
+    #sources = new Map();
+    constructor(logger = stderrLogger) {
+        this.logger = logger;
+    }
+    update(sources, aggregates = new Map()) {
+        const next = new Map();
+        for (const { descriptor, snapshot } of sources) {
+            const sourceId = descriptor.sourceInstanceId;
+            const previous = this.#sources.get(sourceId);
+            if (previous?.snapshot === snapshot) {
+                next.set(sourceId, previous);
+                continue;
+            }
+            const diagnostics = new Map();
+            const record = (key, items, scope, sessionId) => {
+                const prior = previous?.diagnostics.get(key);
+                if (prior?.reference === items) {
+                    diagnostics.set(key, prior);
+                    return;
+                }
+                const signatures = new Set();
+                for (const item of items.slice(0, 50)) {
+                    const signature = JSON.stringify([item.severity, item.code, item.message, item.ordinal]);
+                    if (!signatures.has(signature) && !prior?.signatures.has(signature)) {
+                        try {
+                            this.logger.log({
+                                sourceInstanceId: sourceId,
+                                sessionId,
+                                scope,
+                                severity: item.severity,
+                                code: item.code,
+                                message: item.message,
+                                ordinal: item.ordinal,
+                            });
+                        }
+                        catch {
+                            /* Logging must never affect reading or management. */
+                        }
+                    }
+                    signatures.add(signature);
+                }
+                diagnostics.set(key, { reference: items, signatures });
+            };
+            record("source", snapshot.diagnostics, "source", null);
+            const ids = new Set();
+            for (const entry of snapshot.sessions) {
+                const sessionId = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+                if (ids.has(entry.localId))
+                    continue;
+                record(`session:${sessionId}`, entry.normalized.session.diagnostics, "session", sessionId);
+                ids.add(entry.localId);
+            }
+            for (const { sessionId, diagnostic } of aggregates.get(sourceId) ?? []) {
+                record(`aggregate:${sessionId}`, [diagnostic], "aggregate", sessionId);
+            }
+            next.set(sourceId, { snapshot, diagnostics });
+        }
+        this.#sources = next;
+    }
+}
+//# sourceMappingURL=diagnostic-logger.js.map

package/dist/server/server/repository/opaque-cursor.js

@@ -0,0 +1,79 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+const SIGNATURE_BYTES = 24;
+const SIGNATURE_CHARS = 32;
+const MAX_CURSOR_CHARS = 16_384;
+export class OpaqueCursorCodec {
+    key;
+    constructor(key = randomBytes(32)) {
+        this.key = key;
+    }
+    encodeTimeline(sessionId, ordinal, prefix) {
+        return this.#encode({ v: 1, s: sessionId, o: ordinal, p: prefix });
+    }
+    decodeTimeline(cursor) {
+        return this.#decode(cursor, isTimelineCursorPayload);
+    }
+    #encode(value) {
+        const payload = Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+        const signature = createHmac("sha256", this.key)
+            .update(payload, "utf8")
+            .digest()
+            .subarray(0, SIGNATURE_BYTES)
+            .toString("base64url");
+        return `${payload}.${signature}`;
+    }
+    #decode(cursor, validate) {
+        if (cursor.length === 0 || cursor.length > MAX_CURSOR_CHARS) {
+            return { kind: "malformed" };
+        }
+        const parts = cursor.split(".");
+        if (parts.length !== 2)
+            return { kind: "malformed" };
+        const [payload, encodedSignature] = parts;
+        if (!payload ||
+            !encodedSignature ||
+            !BASE64URL.test(payload) ||
+            !BASE64URL.test(encodedSignature) ||
+            encodedSignature.length !== SIGNATURE_CHARS) {
+            return { kind: "malformed" };
+        }
+        let value;
+        try {
+            value = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+        }
+        catch {
+            return { kind: "malformed" };
+        }
+        if (!validate(value))
+            return { kind: "malformed" };
+        const signature = Buffer.from(encodedSignature, "base64url");
+        const expected = createHmac("sha256", this.key)
+            .update(payload, "utf8")
+            .digest()
+            .subarray(0, SIGNATURE_BYTES);
+        if (signature.byteLength !== expected.byteLength || !timingSafeEqual(signature, expected)) {
+            return { kind: "untrusted" };
+        }
+        return { kind: "valid", value };
+    }
+}
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+function isTimelineCursorPayload(value) {
+    return (isRecord(value) &&
+        hasOnlyKeys(value, ["v", "s", "o", "p"]) &&
+        value.v === 1 &&
+        typeof value.s === "string" &&
+        isOrdinal(value.o) &&
+        typeof value.p === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOrdinal(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function hasOnlyKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.length && keys.every((key) => key in value);
+}
+//# sourceMappingURL=opaque-cursor.js.map

package/dist/server/server/repository/refresh-coordinator.js

@@ -0,0 +1,14 @@
+export class RefreshCoordinator {
+    #inFlight = null;
+    run(refresh) {
+        if (this.#inFlight !== null)
+            return this.#inFlight;
+        const pending = refresh().finally(() => {
+            if (this.#inFlight === pending)
+                this.#inFlight = null;
+        });
+        this.#inFlight = pending;
+        return pending;
+    }
+}
+//# sourceMappingURL=refresh-coordinator.js.map

package/dist/server/server/repository/session-queries.js

@@ -0,0 +1,151 @@
+import { OpaqueCursorCodec } from "./opaque-cursor.js";
+const DEFAULT_ITEM_LIMIT = 100;
+const MAX_ITEM_LIMIT = 300;
+export const MAX_ITEM_PAGE_BYTES = 4 * 1024 * 1024;
+export class RepositoryQueryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class SessionQueries {
+    cursors;
+    constructor(cursors = new OpaqueCursorCodec()) {
+        this.cursors = cursors;
+    }
+    session(snapshot, id) {
+        const versioned = snapshot.sessions.get(id);
+        return versioned?.normalized.session ?? null;
+    }
+    items(snapshot, id, query) {
+        validateItemQuery(query);
+        const versioned = snapshot.sessions.get(id);
+        if (versioned === undefined)
+            return null;
+        const requestedBoundary = this.#resolveReadBoundary(id, versioned, query.cursor);
+        const { normalized } = versioned;
+        const after = requestedBoundary.throughOrdinal;
+        let start = 0;
+        let end = normalized.timeline.length;
+        while (start < end) {
+            const middle = start + Math.floor((end - start) / 2);
+            if (normalized.timeline[middle].ordinal <= after)
+                start = middle + 1;
+            else
+                end = middle;
+        }
+        const limit = query.limit ?? DEFAULT_ITEM_LIMIT;
+        const items = [];
+        let itemBytes = 0;
+        for (let index = start; index < normalized.timeline.length && items.length < limit; index++) {
+            const item = normalized.timeline[index];
+            const bytes = Buffer.byteLength(JSON.stringify(item), "utf8") + (items.length > 0 ? 1 : 0);
+            if (items.length > 0 && itemBytes + bytes > MAX_ITEM_PAGE_BYTES)
+                break;
+            items.push(item);
+            itemBytes += bytes;
+        }
+        const boundary = items.length === 0
+            ? requestedBoundary
+            : versioned.timelinePrefixIndex.boundaryAt(normalized.timeline, items.at(-1).ordinal);
+        return {
+            context: this.#readContext(id, versioned, boundary),
+            items,
+        };
+    }
+    updates(snapshot, id, cursor) {
+        const versioned = snapshot.sessions.get(id);
+        if (versioned === undefined)
+            return null;
+        const boundary = this.#resolveReadBoundary(id, versioned, cursor);
+        return this.#readContext(id, versioned, boundary);
+    }
+    toolDetail(snapshot, id, itemId, query) {
+        const versioned = snapshot.sessions.get(id);
+        if (versioned === undefined)
+            return null;
+        const boundary = this.#resolveReadBoundary(id, versioned, query.cursor);
+        const detail = itemDetail(versioned.normalized, itemId, "tool", versioned.normalized.toolDetails, boundary.throughOrdinal);
+        if (detail === null)
+            return null;
+        return { detail };
+    }
+    directiveDetail(snapshot, id, itemId, query) {
+        const versioned = snapshot.sessions.get(id);
+        if (versioned === undefined)
+            return null;
+        const boundary = this.#resolveReadBoundary(id, versioned, query.cursor);
+        const detail = itemDetail(versioned.normalized, itemId, "directive", versioned.normalized.directiveDetails, boundary.throughOrdinal);
+        if (detail === null)
+            return null;
+        return { detail };
+    }
+    internalDetail(snapshot, id, itemId, query) {
+        const versioned = snapshot.sessions.get(id);
+        if (versioned === undefined)
+            return null;
+        const boundary = this.#resolveReadBoundary(id, versioned, query.cursor);
+        const detail = itemDetail(versioned.normalized, itemId, "internal", versioned.normalized.internalDetails, boundary.throughOrdinal);
+        if (detail === null)
+            return null;
+        return { detail };
+    }
+    #resolveReadBoundary(id, versioned, cursor) {
+        const { normalized, timelinePrefixIndex } = versioned;
+        if (cursor === undefined)
+            return timelinePrefixIndex.boundaryAt(normalized.timeline, 0);
+        const cursorResult = this.cursors.decodeTimeline(cursor);
+        if (cursorResult.kind === "malformed") {
+            throw new RepositoryQueryError("invalid_query", "cursor is malformed");
+        }
+        if (cursorResult.kind === "untrusted") {
+            throw new RepositoryQueryError("timeline_changed", "The timeline cursor is no longer valid; reload this session");
+        }
+        const decoded = cursorResult.value;
+        if (decoded.s !== id)
+            throw new RepositoryQueryError("invalid_query", "cursor belongs to another session");
+        const boundary = timelinePrefixIndex.boundaryAt(normalized.timeline, decoded.o);
+        if (boundary === null ||
+            boundary.throughOrdinal !== decoded.o ||
+            !timelinePrefixIndex.matches(normalized.timeline, boundary, decoded.p)) {
+            throw new RepositoryQueryError("timeline_changed", "The loaded timeline is no longer a prefix of this session");
+        }
+        return boundary;
+    }
+    #readContext(id, versioned, boundary) {
+        return {
+            session: versioned.normalized.session,
+            cursor: this.cursors.encodeTimeline(id, boundary.throughOrdinal, boundary.timelinePrefixRevision),
+            hasMore: boundary.throughOrdinal < (versioned.normalized.timeline.at(-1)?.ordinal ?? 0),
+        };
+    }
+}
+const itemIndexes = new WeakMap();
+function indexedItem(normalized, itemId) {
+    let index = itemIndexes.get(normalized);
+    if (!index) {
+        index = new Map(normalized.timeline.map((item) => [item.id, item]));
+        itemIndexes.set(normalized, index);
+    }
+    return index.get(itemId);
+}
+function itemDetail(normalized, itemId, kind, details, throughOrdinal) {
+    const item = indexedItem(normalized, itemId);
+    if (item?.kind !== kind)
+        return null;
+    const detail = details.get(itemId);
+    if (detail === undefined)
+        return null;
+    if (item.ordinal > throughOrdinal) {
+        throw new RepositoryQueryError("invalid_query", "cursor does not confirm the requested item");
+    }
+    return detail;
+}
+function validateItemQuery(query) {
+    if (query.limit !== undefined &&
+        (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > MAX_ITEM_LIMIT)) {
+        throw new RepositoryQueryError("invalid_query", `limit must be between 1 and ${MAX_ITEM_LIMIT}`);
+    }
+}
+//# sourceMappingURL=session-queries.js.map

package/dist/server/server/repository/session-query-criteria.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-query-criteria.js.map