@dereekb/openrouter 13.37.0

package/firebase/index.cjs.js

@@ -0,0 +1,666 @@
+'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

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

package/firebase/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";