@dereekb/openrouter 13.38.0 → 13.40.0

package/firebase/index.cjs.js

@@ -1,666 +0,0 @@
-'use strict';
-
-var util = require('@dereekb/util');
-var firebase = require('@dereekb/firebase');
-var arktype = require('arktype');
-var model = require('@dereekb/model');
-
-/**
- * Number of digits an {@link OpenRouterPromptVersionId} is padded to.
- *
- * Padding is what makes `orderBy(documentId())` on the subcollection return v2 before v10. Six digits
- * is far past any realistic version count while staying readable.
- */ var OPENROUTER_PROMPT_VERSION_ID_DIGITS = 6;
-/**
- * Converts a version number to its zero-padded document id.
- *
- * @param version - The version number.
- * @returns The document id.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterPromptVersionId(version) {
-    return String(version).padStart(OPENROUTER_PROMPT_VERSION_ID_DIGITS, '0');
-}
-/**
- * Reads the version number back out of a version document id.
- *
- * @param id - The document id.
- * @returns The version number, or NaN when the id is not a number.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterPromptVersionNumberFromId(id) {
-    return Number(id);
-}
-
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _call_super(_this, derived, args) {
-    derived = _get_prototype_of(derived);
-    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
-}
-function _class_call_check$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    return Constructor;
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _is_native_reflect_construct() {
-    try {
-        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-    } catch (_) {}
-    return (_is_native_reflect_construct = function() {
-        return !!result;
-    })();
-}
-/**
- * Identity for {@link OpenRouterPrompt} documents. Model type: `openRouterPrompt`, collection: `orp`.
- */ var openRouterPromptIdentity = firebase.firestoreModelIdentity('openRouterPrompt', 'orp');
-/**
- * Lifecycle state of an {@link OpenRouterPrompt}.
- */ exports.OpenRouterPromptState = void 0;
-(function(OpenRouterPromptState) {
-    /**
-     * Created but not yet servable. A caller resolving this prompt gets an error rather than a guess.
-     */ OpenRouterPromptState[OpenRouterPromptState["DRAFT"] = 0] = "DRAFT";
-    /**
-     * Servable.
-     */ OpenRouterPromptState[OpenRouterPromptState["ACTIVE"] = 1] = "ACTIVE";
-    /**
-     * Retired. Retained so historical runs stay explicable, but no longer servable.
-     */ OpenRouterPromptState[OpenRouterPromptState["ARCHIVED"] = 2] = "ARCHIVED";
-})(exports.OpenRouterPromptState || (exports.OpenRouterPromptState = {}));
-var OpenRouterPromptDocument = /*#__PURE__*/ function(AbstractFirestoreDocument) {
-    _inherits(OpenRouterPromptDocument, AbstractFirestoreDocument);
-    function OpenRouterPromptDocument() {
-        _class_call_check$1(this, OpenRouterPromptDocument);
-        return _call_super(this, OpenRouterPromptDocument, arguments);
-    }
-    _create_class(OpenRouterPromptDocument, [
-        {
-            key: "modelIdentity",
-            get: function get() {
-                return openRouterPromptIdentity;
-            }
-        }
-    ]);
-    return OpenRouterPromptDocument;
-}(firebase.AbstractFirestoreDocument);
-var openRouterPromptConverter = firebase.snapshotConverterFunctions({
-    fields: {
-        cat: firebase.firestoreDate({
-            saveDefaultAsNow: true
-        }),
-        uat: firebase.optionalFirestoreDate(),
-        n: firebase.firestoreString({
-            default: ''
-        }),
-        d: firebase.optionalFirestoreString(),
-        s: firebase.firestoreEnum({
-            default: exports.OpenRouterPromptState.DRAFT
-        }),
-        av: firebase.optionalFirestoreNumber(),
-        lv: firebase.firestoreNumber({
-            default: 0
-        }),
-        t: firebase.optionalFirestoreArray({
-            filterUnique: true,
-            dontStoreIfEmpty: true
-        })
-    }
-});
-/**
- * Returns the root Firestore collection reference for {@link OpenRouterPrompt} documents.
- *
- * @param context - The FirestoreContext used to resolve the collection.
- * @returns A typed CollectionReference for the openRouterPrompt collection.
- */ function openRouterPromptCollectionReference(context) {
-    return context.collection(openRouterPromptIdentity.collectionName);
-}
-/**
- * Creates the Firestore collection accessor for {@link OpenRouterPrompt} documents.
- *
- * @param firestoreContext - The FirestoreContext used to build the collection.
- * @returns An OpenRouterPromptFirestoreCollection.
- */ function openRouterPromptFirestoreCollection(firestoreContext) {
-    return firestoreContext.firestoreCollection({
-        modelIdentity: openRouterPromptIdentity,
-        converter: openRouterPromptConverter,
-        collection: openRouterPromptCollectionReference(firestoreContext),
-        makeDocument: function makeDocument(accessor, documentAccessor) {
-            return new OpenRouterPromptDocument(accessor, documentAccessor);
-        },
-        firestoreContext: firestoreContext
-    });
-}
-// MARK: OpenRouterPromptVersion
-/**
- * Identity for {@link OpenRouterPromptVersion} documents. Subcollection of {@link OpenRouterPrompt}.
- * Model type: `openRouterPromptVersion`, collection: `orpv`.
- */ var openRouterPromptVersionIdentity = firebase.firestoreModelIdentity(openRouterPromptIdentity, 'openRouterPromptVersion', 'orpv');
-/**
- * With a parent, unlike the other documents here: a version only ever exists in a subcollection under
- * the prompt it belongs to, so a holder of one — a collection-group query result especially — needs a
- * way back to that prompt without parsing the path.
- */ var OpenRouterPromptVersionDocument = /*#__PURE__*/ function(AbstractFirestoreDocumentWithParent) {
-    _inherits(OpenRouterPromptVersionDocument, AbstractFirestoreDocumentWithParent);
-    function OpenRouterPromptVersionDocument() {
-        _class_call_check$1(this, OpenRouterPromptVersionDocument);
-        return _call_super(this, OpenRouterPromptVersionDocument, arguments);
-    }
-    _create_class(OpenRouterPromptVersionDocument, [
-        {
-            key: "modelIdentity",
-            get: function get() {
-                return openRouterPromptVersionIdentity;
-            }
-        }
-    ]);
-    return OpenRouterPromptVersionDocument;
-}(firebase.AbstractFirestoreDocumentWithParent);
-var openRouterPromptVersionConverter = firebase.snapshotConverterFunctions({
-    fields: {
-        cat: firebase.firestoreDate({
-            saveDefaultAsNow: true
-        }),
-        v: firebase.firestoreNumber({
-            default: 0
-        }),
-        i: firebase.optionalFirestoreString(),
-        m: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        }),
-        c: firebase.optionalFirestorePassthroughJsonField(),
-        nt: firebase.optionalFirestoreString(),
-        by: firebase.optionalFirestoreString(),
-        lk: firebase.optionalFirestoreBoolean()
-    }
-});
-/**
- * Creates a factory that produces {@link OpenRouterPromptVersion} subcollection references for a given
- * {@link OpenRouterPromptDocument} parent.
- *
- * @param context - Firestore context to create subcollection references from.
- * @returns A factory function that creates collection references for a given prompt parent.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterPromptVersionCollectionReferenceFactory(context) {
-    return function(prompt) {
-        return context.subcollection(prompt.documentRef, openRouterPromptVersionIdentity.collectionName);
-    };
-}
-/**
- * Creates an {@link OpenRouterPromptVersionFirestoreCollectionFactory} bound to the given context.
- *
- * @param firestoreContext - Firestore context to bind the collection factory to.
- * @returns A factory that creates typed subcollections for version documents.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterPromptVersionFirestoreCollectionFactory(firestoreContext) {
-    var factory = openRouterPromptVersionCollectionReferenceFactory(firestoreContext);
-    return function(parent) {
-        return firestoreContext.firestoreCollectionWithParent({
-            modelIdentity: openRouterPromptVersionIdentity,
-            converter: openRouterPromptVersionConverter,
-            collection: factory(parent),
-            makeDocument: function makeDocument(accessor, documentAccessor) {
-                return new OpenRouterPromptVersionDocument(accessor, documentAccessor);
-            },
-            firestoreContext: firestoreContext,
-            parent: parent
-        });
-    };
-}
-/**
- * Creates a collection group reference for querying every {@link OpenRouterPromptVersion} across all
- * prompts.
- *
- * @param context - Firestore context to create the collection group reference from.
- * @returns A typed collection group.
- */ function openRouterPromptVersionCollectionReference(context) {
-    return context.collectionGroup(openRouterPromptVersionIdentity.collectionName);
-}
-/**
- * Creates a typed {@link OpenRouterPromptVersionFirestoreCollectionGroup} bound to the given context.
- *
- * @param firestoreContext - Firestore context to bind the collection group to.
- * @returns A typed Firestore collection group.
- */ function openRouterPromptVersionFirestoreCollectionGroup(firestoreContext) {
-    return firestoreContext.firestoreCollectionGroup({
-        modelIdentity: openRouterPromptVersionIdentity,
-        converter: openRouterPromptVersionConverter,
-        queryLike: openRouterPromptVersionCollectionReference(firestoreContext),
-        makeDocument: function makeDocument(accessor, documentAccessor) {
-            return new OpenRouterPromptVersionDocument(accessor, documentAccessor);
-        },
-        firestoreContext: firestoreContext
-    });
-}
-// MARK: OpenRouterRunTask
-/**
- * How long an OpenRouterRunTask lives before it is deleted, measured from `qat`.
- *
- * A design requirement rather than a tuning knob. NotificationTask already owns retrying, durable
- * persistence, and delayed execution, so a run task is a short-lived execution record — letting one
- * outlive a week would make it a second system of record with a second retention policy to reason about,
- * for no gain.
- *
- * Measured from `qat` rather than a per-task expiration field because there is nothing to configure:
- * a queued task runs essentially immediately, so its queue time IS its age. No field to forget to
- * write, no document excluded from the retention query for lacking one.
- */ var OPENROUTER_RUN_TASK_MAX_AGE = util.MS_IN_DAY * 7;
-/**
- * Identity for {@link OpenRouterRunTask} documents. Model type: `openRouterRunTask`, collection: `orrt`.
- */ var openRouterRunTaskIdentity = firebase.firestoreModelIdentity('openRouterRunTask', 'orrt');
-/**
- * State of an {@link OpenRouterRunTask}.
- */ exports.OpenRouterRunTaskState = void 0;
-(function(OpenRouterRunTaskState) {
-    /**
-     * Enqueued and waiting for a sweep to claim it.
-     */ OpenRouterRunTaskState[OpenRouterRunTaskState["QUEUED"] = 0] = "QUEUED";
-    /**
-     * Claimed by a sweep and executing.
-     *
-     * A `RUNNING` document whose lease has gone stale is reclaimable — that is what makes a crashed
-     * sweep recoverable instead of permanently stuck.
-     */ OpenRouterRunTaskState[OpenRouterRunTaskState["RUNNING"] = 1] = "RUNNING";
-    /**
-     * Finished successfully. `o` / `j` hold the result.
-     */ OpenRouterRunTaskState[OpenRouterRunTaskState["COMPLETE"] = 2] = "COMPLETE";
-    /**
-     * Finished unsuccessfully, with the retry budget spent. `e` holds why.
-     */ OpenRouterRunTaskState[OpenRouterRunTaskState["FAILED"] = 3] = "FAILED";
-    /**
-     * Paused mid-run waiting on a deferred tool result from another process.
-     *
-     * Resumable: the next sweep picks it up once `utr` carries the resolutions.
-     */ OpenRouterRunTaskState[OpenRouterRunTaskState["AWAITING_ASYNC_TOOLS"] = 4] = "AWAITING_ASYNC_TOOLS";
-})(exports.OpenRouterRunTaskState || (exports.OpenRouterRunTaskState = {}));
-/**
- * States a sweep considers claimable.
- *
- * `AWAITING_ASYNC_TOOLS` is in here alongside `QUEUED` because a task parked on a deferred tool whose
- * results have since arrived is runnable again; `isOpenRouterRunTaskClaimable` is what decides whether
- * the results actually did arrive.
- */ var OPENROUTER_RUN_TASK_CLAIMABLE_STATES = [
-    exports.OpenRouterRunTaskState.QUEUED,
-    exports.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS
-];
-/**
- * States a run task will never leave.
- */ var OPENROUTER_RUN_TASK_TERMINAL_STATES = [
-    exports.OpenRouterRunTaskState.COMPLETE,
-    exports.OpenRouterRunTaskState.FAILED
-];
-/**
- * Whether a state is terminal.
- *
- * @param state - The state to check.
- * @returns True when the run will not change state again.
- *
- * @__NO_SIDE_EFFECTS__
- */ function isOpenRouterRunTaskStateTerminal(state) {
-    return OPENROUTER_RUN_TASK_TERMINAL_STATES.includes(state);
-}
-var OpenRouterRunTaskDocument = /*#__PURE__*/ function(AbstractFirestoreDocument) {
-    _inherits(OpenRouterRunTaskDocument, AbstractFirestoreDocument);
-    function OpenRouterRunTaskDocument() {
-        _class_call_check$1(this, OpenRouterRunTaskDocument);
-        return _call_super(this, OpenRouterRunTaskDocument, arguments);
-    }
-    _create_class(OpenRouterRunTaskDocument, [
-        {
-            key: "modelIdentity",
-            get: function get() {
-                return openRouterRunTaskIdentity;
-            }
-        }
-    ]);
-    return OpenRouterRunTaskDocument;
-}(firebase.AbstractFirestoreDocument);
-var openRouterRunTaskConverter = firebase.snapshotConverterFunctions({
-    fields: {
-        s: firebase.firestoreEnum({
-            default: exports.OpenRouterRunTaskState.QUEUED
-        }),
-        qat: firebase.firestoreDate({
-            saveDefaultAsNow: true
-        }),
-        sat: firebase.optionalFirestoreDate(),
-        fat: firebase.optionalFirestoreDate(),
-        lat: firebase.optionalFirestoreDate(),
-        lo: firebase.optionalFirestoreString(),
-        at: firebase.firestoreNumber({
-            default: 0
-        }),
-        pk: firebase.firestoreString({
-            default: ''
-        }),
-        pv: firebase.firestoreNumber({
-            default: 0
-        }),
-        in: firebase.firestoreArray({}),
-        fp: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        }),
-        fa: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        }),
-        co: firebase.optionalFirestorePassthroughJsonField(),
-        o: firebase.optionalFirestoreString(),
-        j: firebase.optionalFirestorePassthroughJsonField(),
-        gi: firebase.optionalFirestoreArray({
-            filterUnique: true,
-            dontStoreIfEmpty: true
-        }),
-        u: firebase.optionalFirestorePassthroughJsonField(),
-        e: firebase.optionalFirestorePassthroughJsonField(),
-        msg: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        }),
-        ptc: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        }),
-        utr: firebase.optionalFirestoreArray({
-            dontStoreIfEmpty: true
-        })
-    }
-});
-/**
- * Returns the root Firestore collection reference for {@link OpenRouterRunTask} documents.
- *
- * @param context - The FirestoreContext used to resolve the collection.
- * @returns A typed CollectionReference for the openRouterRunTask collection.
- */ function openRouterRunTaskCollectionReference(context) {
-    return context.collection(openRouterRunTaskIdentity.collectionName);
-}
-/**
- * Creates the Firestore collection accessor for {@link OpenRouterRunTask} documents.
- *
- * @param firestoreContext - The FirestoreContext used to build the collection.
- * @returns An OpenRouterRunTaskFirestoreCollection.
- */ function openRouterRunTaskFirestoreCollection(firestoreContext) {
-    return firestoreContext.firestoreCollection({
-        modelIdentity: openRouterRunTaskIdentity,
-        converter: openRouterRunTaskConverter,
-        collection: openRouterRunTaskCollectionReference(firestoreContext),
-        makeDocument: function makeDocument(accessor, documentAccessor) {
-            return new OpenRouterRunTaskDocument(accessor, documentAccessor);
-        },
-        firestoreContext: firestoreContext
-    });
-}
-// MARK: Utility
-/**
- * Converts a stored version document into the resolved prompt the request builder consumes.
- *
- * @param promptKey - The prompt key the version belongs to.
- * @param version - The stored version.
- * @returns The resolved prompt.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterResolvedPromptForVersion(promptKey, version) {
-    var _version_c;
-    var _version_m;
-    return {
-        promptKey: promptKey,
-        version: version.v,
-        instructions: version.i,
-        messages: (_version_m = version.m) === null || _version_m === void 0 ? void 0 : _version_m.map(function(param) {
-            var r = param.r, c = param.c;
-            return {
-                role: r,
-                content: c
-            };
-        }),
-        config: (_version_c = version.c) !== null && _version_c !== void 0 ? _version_c : {}
-    };
-}
-/**
- * The document id of a version, from its number.
- *
- * Re-exported here so a caller reading a version does not need to reach for the id module separately.
- */ var openRouterPromptVersionDocumentId = openRouterPromptVersionId;
-
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-var updateOpenRouterPromptParamsType = /* @__PURE__ */ firebase.inferredTargetModelParamsType.merge(arktype.type({
-    'name?': model.clearable('string'),
-    'description?': model.clearable('string'),
-    'tags?': model.clearable('string[]'),
-    'state?': model.clearable('number'),
-    'activeVersion?': model.clearable('number')
-}));
-var openRouterPromptVersionMessageParamsType = /* @__PURE__ */ arktype.type({
-    role: "'user' | 'system' | 'assistant' | 'developer'",
-    content: 'string'
-});
-var createOpenRouterPromptVersionParamsType = /* @__PURE__ */ arktype.type({
-    prompt: 'string >= 1',
-    'instructions?': model.clearable('string'),
-    'messages?': model.clearable(openRouterPromptVersionMessageParamsType.array()),
-    'config?': model.clearable('object'),
-    'notes?': model.clearable('string'),
-    'activate?': model.clearable('boolean')
-});
-var updateOpenRouterPromptVersionParamsType = /* @__PURE__ */ firebase.inferredTargetModelParamsType.merge(arktype.type({
-    'instructions?': model.clearable('string'),
-    'messages?': model.clearable(openRouterPromptVersionMessageParamsType.array()),
-    'config?': model.clearable('object'),
-    'notes?': model.clearable('string')
-}));
-var readOpenRouterRunTaskParamsType = /* @__PURE__ */ arktype.type({
-    key: 'string >= 1'
-});
-var OPENROUTER_PROMPT_FUNCTION_TYPE_CONFIG_MAP = {};
-var OPENROUTER_PROMPT_MODEL_CRUD_FUNCTIONS_CONFIG = {
-    openRouterPrompt: [
-        'update',
-        'query'
-    ],
-    openRouterPromptVersion: [
-        'create',
-        'update'
-    ]
-};
-/**
- * Abstract class defining the callable OpenRouter prompt functions.
- */ var OpenRouterPromptModelFunctions = function OpenRouterPromptModelFunctions() {
-    _class_call_check(this, OpenRouterPromptModelFunctions);
-};
-/**
- * Client-side callable function map factory for OpenRouter prompt CRUD.
- */ var openRouterPromptModelFunctionMap = firebase.callModelFirebaseFunctionMapFactory(OPENROUTER_PROMPT_FUNCTION_TYPE_CONFIG_MAP, OPENROUTER_PROMPT_MODEL_CRUD_FUNCTIONS_CONFIG);
-
-/**
- * Query for the prompts in one lifecycle state.
- *
- * Needs no composite index, and is deliberately kept that way. Unordered, so pagination falls through to
- * Firestore's implicit `__name__` order — which for this model is the prompt's own readable key, already
- * the order a listing wants — and state is the only filter axis: pairing it with an `array-contains` on
- * `t` would buy a composite index for a collection measured in dozens of documents.
- *
- * @param params - The state to match.
- * @returns Firestore query constraints for the prompts in that state.
- *
- * @dbxModelFirebaseIndex
- * @dbxModelFirebaseIndexModel OpenRouterPrompt
- * @dbxModelFirebaseIndexScope COLLECTION
- * @dbxModelFirebaseIndexCategory admin
- */ function openRouterPromptsWithStateQuery(params) {
-    return [
-        firebase.where('s', '==', params.state)
-    ];
-}
-/**
- * Query for the run tasks a sweep may execute, oldest-queued first.
- *
- * Queue order is the ONLY order, and deliberately so. A priority column costs a second composite index
- * and buys a second failure mode: Firestore sorts `null` before every number, so one task written without
- * a priority jumps the entire queue. Delaying a run is `NotificationTask`'s job — it owns the delayed
- * firing — which leaves nothing for a priority here to express.
- *
- * @param params - The page limit.
- * @returns Firestore query constraints for the runnable page.
- *
- * @dbxModelFirebaseIndex
- * @dbxModelFirebaseIndexModel OpenRouterRunTask
- * @dbxModelFirebaseIndexScope COLLECTION
- * @dbxModelFirebaseIndexCategory sweep
- */ function openRouterRunTasksRunnableQuery(params) {
-    var pageLimit = params.limit;
-    return [
-        firebase.where('s', 'in', OPENROUTER_RUN_TASK_CLAIMABLE_STATES),
-        firebase.orderBy('qat', 'asc'),
-        firebase.limit(pageLimit)
-    ];
-}
-/**
- * Query for RUNNING run tasks whose lease has gone stale — crash recovery.
- *
- * Separate from {@link openRouterRunTasksRunnableQuery} because it needs a range filter on `lat`, and
- * Firestore allows the range filter on only one field, which the ordering must then lead with.
- *
- * The cutoff goes through `whereDateIsOnOrBefore` rather than a bare `where('lat', '<=', date)`:
- * `firestoreDate` persists an ISO8601 STRING, so comparing the field against a `Date` compares a string
- * to a timestamp and matches nothing — silently, with no error and an empty page, which reads exactly
- * like "no crashed sweeps to recover".
- *
- * @param params - The page limit and lease cutoff.
- * @returns Firestore query constraints for the reclaimable page.
- *
- * @dbxModelFirebaseIndex
- * @dbxModelFirebaseIndexModel OpenRouterRunTask
- * @dbxModelFirebaseIndexScope COLLECTION
- * @dbxModelFirebaseIndexCategory sweep
- */ function openRouterRunTasksReclaimableQuery(params) {
-    var pageLimit = params.limit, leaseCutoff = params.leaseCutoff;
-    return [
-        firebase.where('s', '==', exports.OpenRouterRunTaskState.RUNNING),
-        firebase.whereDateIsOnOrBefore('lat', leaseCutoff),
-        firebase.orderBy('lat', 'asc'),
-        firebase.limit(pageLimit)
-    ];
-}
-/**
- * Query for run tasks past their retention age, for deletion. Matches EVERY state, `RUNNING` included —
- * see {@link OPENROUTER_RUN_TASK_MAX_AGE} for why the ceiling is the whole requirement.
- *
- * Ordered by `qat` with no state filter, so it needs no composite index at all: a single-field range with
- * a matching order is served by Firestore's automatic single-field index.
- *
- * Firestore's NATIVE TTL policy cannot do this job, for the same reason the cutoff goes through
- * `whereDateIsOnOrBefore` rather than a bare `where('qat', '<=', date)`: `firestoreDate` persists an
- * ISO8601 STRING, and a TTL policy only deletes on a `Timestamp` field. Pointed at `qat` it would
- * silently never fire. The app-level sweep is the mechanism here, not a stopgap for one.
- *
- * @param params - The retention cutoff and page limit.
- * @returns Firestore query constraints for the expired page.
- *
- * @dbxModelFirebaseIndex
- * @dbxModelFirebaseIndexModel OpenRouterRunTask
- * @dbxModelFirebaseIndexScope COLLECTION
- * @dbxModelFirebaseIndexCategory cleanup
- */ function openRouterRunTasksExpiredQuery(params) {
-    var before = params.before, pageLimit = params.limit;
-    return [
-        firebase.whereDateIsOnOrBefore('qat', before),
-        firebase.orderBy('qat', 'asc'),
-        firebase.limit(pageLimit)
-    ];
-}
-
-exports.OPENROUTER_PROMPT_FUNCTION_TYPE_CONFIG_MAP = OPENROUTER_PROMPT_FUNCTION_TYPE_CONFIG_MAP;
-exports.OPENROUTER_PROMPT_MODEL_CRUD_FUNCTIONS_CONFIG = OPENROUTER_PROMPT_MODEL_CRUD_FUNCTIONS_CONFIG;
-exports.OPENROUTER_PROMPT_VERSION_ID_DIGITS = OPENROUTER_PROMPT_VERSION_ID_DIGITS;
-exports.OPENROUTER_RUN_TASK_CLAIMABLE_STATES = OPENROUTER_RUN_TASK_CLAIMABLE_STATES;
-exports.OPENROUTER_RUN_TASK_MAX_AGE = OPENROUTER_RUN_TASK_MAX_AGE;
-exports.OPENROUTER_RUN_TASK_TERMINAL_STATES = OPENROUTER_RUN_TASK_TERMINAL_STATES;
-exports.OpenRouterPromptDocument = OpenRouterPromptDocument;
-exports.OpenRouterPromptModelFunctions = OpenRouterPromptModelFunctions;
-exports.OpenRouterPromptVersionDocument = OpenRouterPromptVersionDocument;
-exports.OpenRouterRunTaskDocument = OpenRouterRunTaskDocument;
-exports.createOpenRouterPromptVersionParamsType = createOpenRouterPromptVersionParamsType;
-exports.isOpenRouterRunTaskStateTerminal = isOpenRouterRunTaskStateTerminal;
-exports.openRouterPromptCollectionReference = openRouterPromptCollectionReference;
-exports.openRouterPromptConverter = openRouterPromptConverter;
-exports.openRouterPromptFirestoreCollection = openRouterPromptFirestoreCollection;
-exports.openRouterPromptIdentity = openRouterPromptIdentity;
-exports.openRouterPromptModelFunctionMap = openRouterPromptModelFunctionMap;
-exports.openRouterPromptVersionCollectionReference = openRouterPromptVersionCollectionReference;
-exports.openRouterPromptVersionCollectionReferenceFactory = openRouterPromptVersionCollectionReferenceFactory;
-exports.openRouterPromptVersionConverter = openRouterPromptVersionConverter;
-exports.openRouterPromptVersionDocumentId = openRouterPromptVersionDocumentId;
-exports.openRouterPromptVersionFirestoreCollectionFactory = openRouterPromptVersionFirestoreCollectionFactory;
-exports.openRouterPromptVersionFirestoreCollectionGroup = openRouterPromptVersionFirestoreCollectionGroup;
-exports.openRouterPromptVersionId = openRouterPromptVersionId;
-exports.openRouterPromptVersionIdentity = openRouterPromptVersionIdentity;
-exports.openRouterPromptVersionMessageParamsType = openRouterPromptVersionMessageParamsType;
-exports.openRouterPromptVersionNumberFromId = openRouterPromptVersionNumberFromId;
-exports.openRouterPromptsWithStateQuery = openRouterPromptsWithStateQuery;
-exports.openRouterResolvedPromptForVersion = openRouterResolvedPromptForVersion;
-exports.openRouterRunTaskCollectionReference = openRouterRunTaskCollectionReference;
-exports.openRouterRunTaskConverter = openRouterRunTaskConverter;
-exports.openRouterRunTaskFirestoreCollection = openRouterRunTaskFirestoreCollection;
-exports.openRouterRunTaskIdentity = openRouterRunTaskIdentity;
-exports.openRouterRunTasksExpiredQuery = openRouterRunTasksExpiredQuery;
-exports.openRouterRunTasksReclaimableQuery = openRouterRunTasksReclaimableQuery;
-exports.openRouterRunTasksRunnableQuery = openRouterRunTasksRunnableQuery;
-exports.readOpenRouterRunTaskParamsType = readOpenRouterRunTaskParamsType;
-exports.updateOpenRouterPromptParamsType = updateOpenRouterPromptParamsType;
-exports.updateOpenRouterPromptVersionParamsType = updateOpenRouterPromptVersionParamsType;

package/firebase/index.cjs.mjs

@@ -1,2 +0,0 @@
-export * from './index.cjs.js';
-export { _default as default } from './index.cjs.default.js';

package/firebase-server/index.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./index.cjs.js').default;