@steve31415/baselib 3.33.0 → 3.33.2

package/dist/llm/providers/gemini.js

@@ -15,21 +15,47 @@ function classifyFinish(finishReason) {
         return 'complete';
     return 'other';
 }
-/** Recursively strip fields that Gemini's API doesn't support (e.g. additionalProperties). */
-function stripUnsupportedSchemaFields(schema) {
-    if (Array.isArray(schema)) {
-        return schema.map(stripUnsupportedSchemaFields);
-    }
-    if (schema !== null && typeof schema === 'object') {
-        const result = {};
-        for (const [key, value] of Object.entries(schema)) {
-            if (key === 'additionalProperties')
-                continue;
-            result[key] = stripUnsupportedSchemaFields(value);
+/**
+ * Transform a portable JSON schema into the dialect Gemini's `responseSchema`
+ * accepts — an OpenAPI-subset proto, not full JSON Schema:
+ * - `additionalProperties` is dropped (Gemini rejects it).
+ * - A `type` array (JSON Schema's union; usually the nullable union
+ *   `['string', 'null']`) becomes one `type`, or an `anyOf` of single types
+ *   for a multi-type union, plus `nullable: true` when `'null'` was a member.
+ *   The proto's `type` holds a single value, so an array is rejected with a
+ *   400 before the model runs ("Proto field is not repeating, cannot start
+ *   list"; verified live on 3.5 Flash-Lite, 3.6 Flash and 3.1 Pro, 2026-10-09).
+ * Returns a deep copy — the caller's schema object is reused across failover
+ * attempts.
+ */
+function toGeminiSchema(schema) {
+    if (Array.isArray(schema))
+        return schema.map(toGeminiSchema);
+    if (schema === null || typeof schema !== 'object')
+        return schema;
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'additionalProperties')
+            continue;
+        // Only a keyword `type` is ever an array: a property named `type` (an
+        // entry of a `properties` map) has a schema object as its value.
+        if (key === 'type' && Array.isArray(value)) {
+            Object.assign(result, singleGeminiType(value));
+            continue;
         }
-        return result;
+        result[key] = toGeminiSchema(value);
     }
-    return schema;
+    return result;
+}
+/** A JSON Schema type array as Gemini's single `type` / `anyOf` plus `nullable`. */
+function singleGeminiType(types) {
+    const nonNull = types.filter((type) => type !== 'null');
+    if (nonNull.length === 0)
+        return { type: 'null' };
+    const nullable = nonNull.length < types.length ? { nullable: true } : {};
+    if (nonNull.length === 1)
+        return { type: nonNull[0], ...nullable };
+    return { anyOf: nonNull.map((type) => ({ type })), ...nullable };
 }
 export const geminiProvider = {
     name: 'gemini',
@@ -50,7 +76,7 @@ export const geminiProvider = {
         }
         if (request.jsonSchema) {
             generationConfig.responseMimeType = 'application/json';
-            generationConfig.responseSchema = stripUnsupportedSchemaFields(request.jsonSchema.schema);
+            generationConfig.responseSchema = toGeminiSchema(request.jsonSchema.schema);
         }
         // Gemini thinking models reason before answering; the reasoning tokens
         // count against maxOutputTokens. `effort` (pre-gated and clamped in

package/dist/llm/providers/openai.js

@@ -38,7 +38,7 @@ function makeNullable(propSchema) {
  * Outputs mode requires: every object must set `additionalProperties: false`
  * and list ALL of its properties in `required`. Callers author one portable
  * schema; this keeps the OpenAI-specific dialect local to this adapter,
- * mirroring the Gemini adapter's `stripUnsupportedSchemaFields` and the
+ * mirroring the Gemini adapter's `toGeminiSchema` and the
  * Anthropic adapter's `toAnthropicStrictSchema` (which closes objects but keeps
  * optional fields optional). Returns a deep copy — the
  * caller's schema object is never mutated (it is reused across failover attempts).

package/dist/sync-browser/client.d.ts

@@ -217,6 +217,12 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     private observeStall;
+    /** The sleep half of `observeStall`, also run by every event-driven entry
+     * that starts, ends or splits the accounting (outage start and end, an
+     * `online` event, a hide): a wake can reach the page as one of those
+     * events before any timer runs, and the sleep must land on the right side
+     * of it (reader, 2026-10-11). */
+    private observeClockJump;
     private setTimer;
     private setRepeating;
     private isHidden;

package/dist/sync-browser/client.js

@@ -382,20 +382,27 @@ export class SyncClient {
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     observeStall(dueMono) {
+        this.observeClockJump();
         const mono = this.monoNow();
-        const offset = this.now() - mono;
-        const visible = !this.isHidden();
-        if (visible && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
-            this.counters.stalledMs += offset - this.clockOffset;
-        }
-        this.clockOffset = offset;
-        if (visible && mono - dueMono >= STALL_MIN_MS) {
+        if (!this.isHidden() && mono - dueMono >= STALL_MIN_MS) {
             const from = Math.max(dueMono, this.stallCoveredUntil, this.visibleSinceMono);
             if (mono > from)
                 this.counters.stalledMs += mono - from;
             this.stallCoveredUntil = mono;
         }
     }
+    /** The sleep half of `observeStall`, also run by every event-driven entry
+     * that starts, ends or splits the accounting (outage start and end, an
+     * `online` event, a hide): a wake can reach the page as one of those
+     * events before any timer runs, and the sleep must land on the right side
+     * of it (reader, 2026-10-11). */
+    observeClockJump() {
+        const offset = this.now() - this.monoNow();
+        if (!this.isHidden() && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
+            this.counters.stalledMs += offset - this.clockOffset;
+        }
+        this.clockOffset = offset;
+    }
     setTimer(callback, delayMs) {
         const dueMono = this.monoNow() + delayMs;
         return this.options.runtime.setTimeout(() => {
@@ -439,8 +446,9 @@ export class SyncClient {
         if (this.halted || this.disposed || this.hiddenSince !== null)
             return;
         this.finishReturnWindow();
-        // A device that slept and then hid the page: the sleep counts as hidden.
-        this.rebaselineClocks();
+        // A device that slept with the page visible and hid it on waking: the
+        // sleep counts as stalled, before the hidden spell starts.
+        this.observeClockJump();
         this.hiddenSince = this.now();
         this.spellCounters = this.snapshot();
         this.hiddenSocketFailed = false;
@@ -483,6 +491,7 @@ export class SyncClient {
     onOnline() {
         if (this.halted || this.disposed)
             return;
+        this.observeClockJump();
         if (this.isHidden()) {
             if (this.socket === null) {
                 this.cancelBackgroundTick();
@@ -966,6 +975,10 @@ export class SyncClient {
     startOutage(closeCode, wasClean = false) {
         if (this.outageStartedAt !== null)
             return;
+        // A sleep or freeze that ended in this close happened before the outage
+        // began (durationMs starts now): keep it out of the outage's stalledMs.
+        this.observeClockJump();
+        this.stallCoveredUntil = Math.max(this.stallCoveredUntil, this.monoNow());
         this.outageStartedAt = this.options.runtime.now();
         this.outageEscalated = false;
         this.outageCloseCode = closeCode;
@@ -1300,6 +1313,7 @@ export class SyncClient {
     }
     onSyncEstablished() {
         if (this.outageStartedAt !== null) {
+            this.observeClockJump();
             const durationMs = Math.max(0, this.options.runtime.now() - this.outageStartedAt);
             // Failures are only counted (and the ladder only runs) while visible,
             // and the count restarts on each return, so `attempts` is what the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.33.0",
+  "version": "3.33.2",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",