ua-outages 0.1.0 → 0.2.0

package/src/client.ts

@@ -18,7 +18,7 @@ import type {
   RegionSchedule,
   Street,
 } from './types.js'
-import { mapLimit } from './util.js'
+import { abortable, mapLimit } from './util.js'
 
 export interface OutageClientOptions extends HttpOptions {
   /** How long fetched schedules are reused, default 5 min. 0 disables the cache. */
@@ -38,6 +38,8 @@ export interface HealthCheckOptions {
   staleAfterHours?: number
   /** Parallel requests, default 6 */
   concurrency?: number
+  /** Cancels the check: no further regions are fetched and the call rejects with the signal's reason */
+  signal?: AbortSignal
 }
 
 export interface HealthReport {
@@ -60,7 +62,9 @@ export class OutageClient {
   private readonly ctx: ProviderContext
   private readonly providers: ReadonlyMap<RegionId, Provider>
   private readonly cacheTtlMs: number
-  private readonly cache = new Map<RegionId, { at: number; value: Promise<RegionSchedule> }>()
+  private readonly cache = new Map<RegionId, { at: number; seq: number; value: Promise<RegionSchedule> }>()
+  /** Fetches started, so a slower older one never replaces a newer one in the cache */
+  private seq = 0
   private readonly searchCache = new Map<string, { at: number; value: Promise<unknown[]> }>()
 
   constructor(opts: OutageClientOptions = {}) {
@@ -90,22 +94,45 @@ export class OutageClient {
 
   // --- schedules ---
 
-  /** All groups of a region. */
-  async getSchedules(region: RegionId, opts: { fresh?: boolean } = {}): Promise<RegionSchedule> {
+  /**
+   * All groups of a region.
+   *
+   * `signal` cancels the call: it rejects with the signal's reason right away and sends no
+   * further requests to the operator (the one in flight is aborted too).
+   */
+  async getSchedules(region: RegionId, opts: ScheduleOptions = {}): Promise<RegionSchedule> {
     const p = this.provider(region)
+    const { signal } = opts
+    signal?.throwIfAborted()
     const hit = this.cache.get(region)
     const now = Date.now()
-    if (!opts.fresh && hit && now - hit.at < this.cacheTtlMs) return hit.value
-    const value = p.getSchedules(this.ctx)
+    if (!opts.fresh && hit && now - hit.at < this.cacheTtlMs) return abortable(hit.value, signal)
+    const value = p.getSchedules(this.context(signal))
+    const entry = { at: now, seq: ++this.seq, value }
     if (this.cacheTtlMs > 0) {
-      this.cache.set(region, { at: now, value })
-      value.catch(() => this.cache.delete(region))
+      if (signal) {
+        // a cancellable call isn't shared while it runs, so another caller never inherits its
+        // cancellation; what it fetched is cached once it arrives, unless a fetch started later
+        // already is
+        value.then(
+          () => {
+            if ((this.cache.get(region)?.seq ?? 0) < entry.seq) this.cache.set(region, entry)
+          },
+          () => {},
+        )
+      } else {
+        this.cache.set(region, entry)
+        value.catch(() => {
+          if (this.cache.get(region) === entry) this.cache.delete(region)
+        })
+      }
     }
-    return value
+    // a provider may wait on work it shares with other calls: the caller still leaves at once
+    return abortable(value, signal)
   }
 
   /** One group. Accepts loose spellings: "3.1", "GPV3.1", "черга 3.1". */
-  async getSchedule(region: RegionId, group: string, opts: { fresh?: boolean } = {}): Promise<GroupSchedule> {
+  async getSchedule(region: RegionId, group: string, opts: ScheduleOptions = {}): Promise<GroupSchedule> {
     const id = normalizeGroup(group)
     const all = await this.getSchedules(region, opts)
     const days = id ? all.schedules[id] : undefined
@@ -128,16 +155,26 @@ export class OutageClient {
     region: RegionId,
     query: string,
     opts: SearchOptions & { district?: string } = {},
+  ): Promise<City[]> {
+    return this.searchCitiesIn(this.ctx, region, query, opts)
+  }
+
+  private async searchCitiesIn(
+    ctx: ProviderContext,
+    region: RegionId,
+    query: string,
+    opts: SearchOptions & { district?: string },
   ): Promise<City[]> {
     const p = this.provider(region)
     if (!p.searchCities) return []
     const found = await this.rankedSearch(
+      ctx,
       region,
       'settlement',
       query,
       'cities',
       !!p.remoteSearch?.cities,
-      (q) => p.searchCities!(this.ctx, q),
+      (q) => p.searchCities!(ctx, q),
       opts.district ? MAX_CANDIDATES : (opts.limit ?? DEFAULT_LIMIT),
     )
     if (!opts.district) return found
@@ -156,17 +193,27 @@ export class OutageClient {
     region: RegionId,
     query: string,
     opts: SearchOptions & { city?: City } = {},
+  ): Promise<Street[]> {
+    return this.searchStreetsIn(this.ctx, region, query, opts)
+  }
+
+  private async searchStreetsIn(
+    ctx: ProviderContext,
+    region: RegionId,
+    query: string,
+    opts: SearchOptions & { city?: City },
   ): Promise<Street[]> {
     const p = this.addressProvider(region)
     if (p.searchCities && !opts.city)
       throw new OutageError('not-found', `${p.info.name}: pick a city first`, { region })
     return this.rankedSearch(
+      ctx,
       region,
       'street',
       query,
       `streets:${opts.city?.id ?? ''}`,
       !!p.remoteSearch?.streets,
-      (q) => p.searchStreets!(this.ctx, q, opts.city),
+      (q) => p.searchStreets!(ctx, q, opts.city),
       opts.limit ?? DEFAULT_LIMIT,
     )
   }
@@ -187,9 +234,9 @@ export class OutageClient {
   async prefetch(region: RegionId, opts: { city?: City } = {}): Promise<void> {
     const p = this.provider(region)
     if (p.searchCities && !p.remoteSearch?.cities)
-      await this.candidates(region, 'cities', '', false, (q) => p.searchCities!(this.ctx, q))
+      await this.candidates(this.ctx, region, 'cities', '', false, (q) => p.searchCities!(this.ctx, q))
     if (opts.city && p.searchStreets && !p.remoteSearch?.streets)
-      await this.candidates(region, `streets:${opts.city.id}`, '', false, (q) =>
+      await this.candidates(this.ctx, region, `streets:${opts.city.id}`, '', false, (q) =>
         p.searchStreets!(this.ctx, q, opts.city),
       )
   }
@@ -199,24 +246,35 @@ export class OutageClient {
    * or settlement can't be picked with confidence, throws `not-found` listing the suggestions.
    */
   async findGroup(region: RegionId, address: AddressQuery): Promise<GroupMatch> {
+    return this.findGroupIn(this.ctx, region, address)
+  }
+
+  private async findGroupIn(
+    ctx: ProviderContext,
+    region: RegionId,
+    address: AddressQuery,
+  ): Promise<GroupMatch> {
     const direct = this.provider(region)
-    if (direct.lookupAddress) return direct.lookupAddress(this.ctx, address)
+    if (direct.lookupAddress) return direct.lookupAddress(ctx, address)
     const p = this.addressProvider(region)
 
     let city: City | undefined
     if (p.searchCities) {
       if (!address.city)
         throw new OutageError('not-found', `${p.info.name}: specify a city or village`, { region })
-      const cities = await this.searchCities(region, address.city, { limit: 10, district: address.district })
+      const cities = await this.searchCitiesIn(ctx, region, address.city, {
+        limit: 10,
+        district: address.district,
+      })
       city = choose(address.city, cities, 'city', region, (c) =>
         c.district ? `${c.name} (${c.district})` : c.name,
       )
     }
 
-    const streets = await this.searchStreets(region, address.street, { city, limit: 10 })
+    const streets = await this.searchStreetsIn(ctx, region, address.street, { city, limit: 10 })
     const street = choose(address.street, streets, 'street', region, (s) => s.name)
 
-    const houses = await p.searchHouses!(this.ctx, street, address.house)
+    const houses = await p.searchHouses!(ctx, street, address.house)
     const want = normalizeHouse(address.house)
     const house = houses.find((h) => normalizeHouse(h.number) === want)
     if (!house)
@@ -230,7 +288,7 @@ export class OutageClient {
         }`,
         { region },
       )
-    return p.groupOf!(this.ctx, house, street, city)
+    return p.groupOf!(ctx, house, street, city)
   }
 
   /**
@@ -239,6 +297,7 @@ export class OutageClient {
    * query alone finds little, so a typo in one part of the name still lands.
    */
   private async rankedSearch<T extends { id: string; name: string }>(
+    ctx: ProviderContext,
     region: RegionId,
     kind: NameKind,
     query: string,
@@ -248,13 +307,17 @@ export class OutageClient {
     limit: number,
   ): Promise<(T & { score: number })[]> {
     if (!query.trim()) return []
-    let pool = await this.candidates(region, scope, query, remote, fetch)
+    let pool = await this.candidates(ctx, region, scope, query, remote, fetch)
     let ranked = rankByName(query, pool, (t) => t.name, kind)
     // a typo defeats the operator's substring search: retry with fragments of the word
     if (remote && (ranked[0]?.score ?? 0) < 0.9) {
       const extra = await Promise.all(
         searchFragments(query, kind).map((f) =>
-          this.candidates(region, scope, f, true, fetch).catch(() => []),
+          this.candidates(ctx, region, scope, f, true, fetch).catch(() => {
+            // a cancelled lookup stops here; any other failure of a fragment is just no extra hits
+            ctx.signal?.throwIfAborted()
+            return []
+          }),
         ),
       )
       const seen = new Map(pool.map((t) => [t.id, t]))
@@ -267,6 +330,7 @@ export class OutageClient {
 
   /** Candidate lists, cached briefly: whole directories per scope, server results per term. */
   private candidates<T>(
+    ctx: ProviderContext,
     region: RegionId,
     scope: string,
     query: string,
@@ -275,11 +339,19 @@ export class OutageClient {
   ): Promise<T[]> {
     const key = `${region}|${scope}|${remote ? query.trim().toLowerCase() : ''}`
     const hit = this.searchCache.get(key)
-    if (hit && Date.now() - hit.at < Math.max(this.cacheTtlMs, 60_000)) return hit.value as Promise<T[]>
+    if (hit && Date.now() - hit.at < Math.max(this.cacheTtlMs, 60_000))
+      return abortable(hit.value as Promise<T[]>, ctx.signal)
     const value = fetch(query)
-    if (this.searchCache.size > 500) this.searchCache.clear()
-    this.searchCache.set(key, { at: Date.now(), value })
-    value.catch(() => this.searchCache.delete(key))
+    const store = () => {
+      if (this.searchCache.size > 500) this.searchCache.clear()
+      this.searchCache.set(key, { at: Date.now(), value })
+    }
+    // a cancellable lookup isn't shared while it runs, so no other caller inherits its cancellation
+    if (ctx.signal) value.then(store, () => {})
+    else {
+      store()
+      value.catch(() => this.searchCache.delete(key))
+    }
     return value
   }
 
@@ -292,17 +364,25 @@ export class OutageClient {
   async healthCheck(opts: HealthCheckOptions = {}): Promise<HealthReport> {
     const ids = opts.regions ?? [...this.providers.keys()]
     const staleMs = (opts.staleAfterHours ?? 72) * 3600_000
-    const results = await mapLimit(ids, opts.concurrency ?? 6, async (id): Promise<RegionHealth> => {
-      const health = await this.checkRegion(id, staleMs)
-      const p = this.provider(id)
-      if (!opts.address || !p.sampleAddress || !p.info.capabilities.addressSearch) return health
-      try {
-        const m = await this.findGroup(id, p.sampleAddress)
-        return { ...health, address: { ok: true, group: m.group } }
-      } catch (e) {
-        return { ...health, address: { ok: false, message: (e as Error).message } }
-      }
-    })
+    const { signal } = opts
+    const results = await mapLimit(
+      ids,
+      opts.concurrency ?? 6,
+      async (id): Promise<RegionHealth> => {
+        const health = await this.checkRegion(id, staleMs, signal)
+        const p = this.provider(id)
+        if (!opts.address || !p.sampleAddress || !p.info.capabilities.addressSearch) return health
+        signal?.throwIfAborted()
+        try {
+          const m = await abortable(this.findGroupIn(this.context(signal), id, p.sampleAddress), signal)
+          return { ...health, address: { ok: true, group: m.group } }
+        } catch (e) {
+          if (signal?.aborted) throw signal.reason
+          return { ...health, address: { ok: false, message: (e as Error).message } }
+        }
+      },
+      signal,
+    )
     return {
       checkedAt: this.ctx.now().toISOString(),
       ok: results.every((r) => r.status !== 'error' && (r.address?.ok ?? true)),
@@ -310,7 +390,7 @@ export class OutageClient {
     }
   }
 
-  private async checkRegion(region: RegionId, staleMs: number): Promise<RegionHealth> {
+  private async checkRegion(region: RegionId, staleMs: number, signal?: AbortSignal): Promise<RegionHealth> {
     const info = this.provider(region).info
     // e.g. operators that publish the schedule only as an image: nothing to check
     if (!info.capabilities.schedule)
@@ -324,11 +404,12 @@ export class OutageClient {
       }
     const started = performance.now()
     try {
-      const s = await this.getSchedules(region, { fresh: true })
+      const s = await this.getSchedules(region, { fresh: true, signal })
       const latencyMs = Math.round(performance.now() - started)
       const base = { region, latencyMs, groups: s.groups.length, updatedAt: s.updatedAt }
       const hasData = Object.values(s.schedules).some((days) =>
-        days.some((d) => d.intervals.length > 0 || d.status === 'no-outages'),
+        // anything the operator published counts, a day without outages included
+        days.some((d) => d.status !== 'unknown'),
       )
       if (!s.groups.length || !hasData)
         return { ...base, status: 'empty', message: 'No schedule published right now' }
@@ -336,6 +417,7 @@ export class OutageClient {
         return { ...base, status: 'stale', message: `Last updated ${s.updatedAt}` }
       return { ...base, status: 'ok' }
     } catch (e) {
+      if (signal?.aborted) throw signal.reason
       // e.g. a region that publishes only an image the SDK can't read
       if (e instanceof OutageError && e.code === 'unsupported')
         return { region, status: 'empty', latencyMs: 0, groups: 0, updatedAt: null, message: e.message }
@@ -352,6 +434,11 @@ export class OutageClient {
 
   // --- internals ---
 
+  /** Provider context for one call; with a signal, its requests stop when the call is cancelled */
+  private context(signal?: AbortSignal): ProviderContext {
+    return signal ? { ...this.ctx, http: this.ctx.http.withSignal(signal), signal } : this.ctx
+  }
+
   private provider(id: RegionId): Provider {
     const p = this.providers.get(id)
     if (!p) throw new OutageError('unsupported', `Unknown region "${id}"`, { region: id })
@@ -407,6 +494,13 @@ const CONFIDENT = 0.7
 /** …and only when the runner-up is further behind than this */
 const TIE = 0.025
 
+export interface ScheduleOptions {
+  /** Skip the cache and fetch from the operator */
+  fresh?: boolean
+  /** Cancels the call: it rejects with the signal's reason and sends no further requests */
+  signal?: AbortSignal
+}
+
 export interface SearchOptions {
   /** Max results, default 10 */
   limit?: number

package/src/http.ts

@@ -1,6 +1,7 @@
 import { OutageError } from './errors.js'
 import { httpsFetchWithCa } from './https-fetch.js'
 import type { RegionId } from './types.js'
+import { abortable } from './util.js'
 
 export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>
 
@@ -41,6 +42,9 @@ const BLOCK_MARKERS = [
   'Attention Required!',
 ]
 
+/** A bot-protection page rather than the operator's content. Challenge pages are small; real pages may embed the same scripts, so size matters. */
+const isChallenge = (body: string) => body.length < 20_000 && BLOCK_MARKERS.some((m) => body.includes(m))
+
 export class Http {
   private readonly fetchImpl: FetchLike
   private readonly customFetch: boolean
@@ -48,6 +52,8 @@ export class Http {
   private readonly timeoutMs: number
   private readonly userAgent: string
   private readonly retries: number
+  /** Set on copies made by `withSignal`: every request through them stops when it aborts */
+  private signal?: AbortSignal
 
   constructor(opts: HttpOptions = {}) {
     this.fetchImpl = opts.fetch ?? ((input, init) => globalThis.fetch(input, init))
@@ -57,6 +63,17 @@ export class Http {
     this.retries = opts.retries ?? 1
   }
 
+  /**
+   * The same client (settings, connections) whose requests all stop when `signal` aborts:
+   * none starts after that, and the one in flight is cancelled. `undefined` gives an unbound copy.
+   */
+  withSignal(signal: AbortSignal | undefined): Http {
+    const copy = Object.create(Http.prototype) as Http
+    Object.assign(copy, this)
+    copy.signal = signal
+    return copy
+  }
+
   async text(url: string, opts: RequestOptions = {}): Promise<string> {
     return (await this.raw(url, opts)).body
   }
@@ -67,11 +84,11 @@ export class Http {
     opts: RequestOptions = {},
   ): Promise<{ body: string; headers: Headers; status: number }> {
     const res = await this.request(url, opts)
+    const signal = this.signal
     const body = opts.encoding
-      ? new TextDecoder(opts.encoding).decode(await res.arrayBuffer())
-      : await res.text()
-    // challenge pages are small; real pages may embed the same scripts, so size matters
-    if (body.length < 20_000 && BLOCK_MARKERS.some((m) => body.includes(m)))
+      ? new TextDecoder(opts.encoding).decode(await abortable(res.arrayBuffer(), signal))
+      : await abortable(res.text(), signal)
+    if (isChallenge(body))
       throw new OutageError('blocked', `Bot protection answered instead of ${host(url)}`, {
         region: opts.region,
         url,
@@ -88,7 +105,8 @@ export class Http {
   /** Binary body with the response headers (e.g. Last-Modified of an image) */
   async file(url: string, opts: RequestOptions = {}): Promise<{ bytes: Uint8Array; headers: Headers }> {
     const res = await this.request(url, opts)
-    return { bytes: new Uint8Array(await res.arrayBuffer()), headers: res.headers }
+    const bytes = await abortable(res.arrayBuffer(), this.signal)
+    return { bytes: new Uint8Array(bytes), headers: res.headers }
   }
 
   async json<T = unknown>(url: string, opts: RequestOptions = {}): Promise<T> {
@@ -112,6 +130,7 @@ export class Http {
   }
 
   private async request(url: string, opts: RequestOptions): Promise<Response> {
+    const signal = this.signal
     const headers: Record<string, string> = {
       'User-Agent': this.userAgent,
       Accept: 'application/json, text/html;q=0.9, */*;q=0.8',
@@ -127,16 +146,23 @@ export class Http {
 
     const fetchImpl = opts.ca && !this.customFetch ? this.fetchWithCa(opts.ca) : this.fetchImpl
     for (let attempt = 0; ; attempt++) {
+      // a cancelled call sends nothing more, retries included
+      signal?.throwIfAborted()
+      const timeout = AbortSignal.timeout(this.timeoutMs)
       let res: Response
       try {
-        res = await fetchImpl(url, {
-          method: opts.method ?? (body ? 'POST' : 'GET'),
-          headers,
-          body,
-          signal: AbortSignal.timeout(this.timeoutMs),
-          redirect: 'follow',
-        })
+        res = await abortable(
+          fetchImpl(url, {
+            method: opts.method ?? (body ? 'POST' : 'GET'),
+            headers,
+            body,
+            signal: signal ? withTimeout(signal, timeout) : timeout,
+            redirect: 'follow',
+          }),
+          signal,
+        )
       } catch (cause) {
+        if (signal?.aborted) throw signal.reason
         if (attempt < this.retries) continue
         const timedOut = (cause as Error)?.name === 'TimeoutError'
         throw new OutageError(
@@ -146,6 +172,17 @@ export class Http {
         )
       }
       if (res.ok || opts.acceptStatus?.includes(res.status)) return res
+      // a bot check often comes as a 503: look before retrying, and never ask it twice
+      const errorBody = await abortable(res.text(), signal).catch(() => {
+        if (signal?.aborted) throw signal.reason
+        return ''
+      })
+      if (isChallenge(errorBody))
+        throw new OutageError('blocked', `Bot protection answered instead of ${host(url)}`, {
+          region: opts.region,
+          url,
+          status: res.status,
+        })
       if (res.status >= 500 && attempt < this.retries) continue
       throw new OutageError(
         res.status === 403 || res.status === 429 ? 'blocked' : 'http',
@@ -156,6 +193,30 @@ export class Http {
   }
 }
 
+/**
+ * Aborts on the caller's signal or the per-request timeout: `AbortSignal.any`, which Node 20 has
+ * only from 20.3. The fallback's listeners go away when either fires, and the timeout always
+ * fires, so a caller's signal shared by many requests doesn't collect them.
+ */
+function withTimeout(caller: AbortSignal, timeout: AbortSignal): AbortSignal {
+  if (typeof AbortSignal.any === 'function') return AbortSignal.any([timeout, caller])
+  const ctrl = new AbortController()
+  if (caller.aborted) ctrl.abort(caller.reason)
+  else if (timeout.aborted) ctrl.abort(timeout.reason)
+  else {
+    const onCaller = () => ctrl.abort(caller.reason)
+    const onTimeout = () => ctrl.abort(timeout.reason)
+    const cleanup = () => {
+      caller.removeEventListener('abort', onCaller)
+      timeout.removeEventListener('abort', onTimeout)
+    }
+    caller.addEventListener('abort', onCaller, { once: true })
+    timeout.addEventListener('abort', onTimeout, { once: true })
+    ctrl.signal.addEventListener('abort', cleanup, { once: true })
+  }
+  return ctrl.signal
+}
+
 function host(url: string) {
   try {
     return new URL(url).host

package/src/index.ts

@@ -1,5 +1,11 @@
 export { OutageClient } from './client.js'
-export type { HealthCheckOptions, HealthReport, OutageClientOptions, SearchOptions } from './client.js'
+export type {
+  HealthCheckOptions,
+  HealthReport,
+  OutageClientOptions,
+  ScheduleOptions,
+  SearchOptions,
+} from './client.js'
 export { OutageError, isOutageError } from './errors.js'
 export { fuzzyScore, rankByName } from './fuzzy.js'
 export type { NameKind } from './fuzzy.js'

package/src/providers/gpv.ts

@@ -63,6 +63,16 @@ export function parseGpvDays(
     for (const [rawGroup, cells] of Object.entries(groups)) {
       const group = normalizeGroup(rawGroup)
       if (!group || !cells || typeof cells !== 'object') continue
+      // a group without cells says nothing about its day: unknown, not "power on all day"
+      const hours = Object.keys(cells).filter((k) => /^\d+$/.test(k))
+      if (!hours.length) {
+        ;(out[group] ??= []).push({ date, status: 'unknown', intervals: [] })
+        continue
+      }
+      // a cell value nobody has seen is reported, not read as "on"
+      const odd = hours.map((k) => String(cells[k]).toLowerCase()).find((v) => v !== 'yes' && !HALF[v])
+      if (odd !== undefined)
+        throw new OutageError('parse', `GPV: unknown cell value "${odd}" in ${rawGroup}`, { region })
       ;(out[group] ??= []).push(makeDay(date, gpvCellsToSlots(cells)))
     }
   }

package/src/providers/image-schedule.ts

@@ -31,10 +31,13 @@ export async function scheduleFromImages(
     let lastError = ''
     let read = false
     for (const img of images) {
+      ctx.signal?.throwIfAborted()
       let cells
       try {
         cells = readScheduleTable(decodePng(await ctx.http.bytes(url(img.path), { region })), layout)
       } catch (e) {
+        // a cancelled call is not an unreadable image
+        ctx.signal?.throwIfAborted()
         if (e instanceof OutageError) throw e
         lastError = `${img.path}: ${(e as Error).message}`
         continue

package/src/providers/ivano-frankivsk.ts

@@ -1,5 +1,5 @@
 import { OutageError } from '../errors.js'
-import { compareGroups, makeDay, normalizeGroup, type MinuteSlot } from '../schedule.js'
+import { compareGroups, makeDay, normalizeGroup, unpublished, type MinuteSlot } from '../schedule.js'
 import { parseClock, toKyivIso } from '../time.js'
 import type { AddressQuery, DaySchedule, GroupId, GroupMatch, RegionInfo, RegionSchedule } from '../types.js'
 import type { Provider, ProviderContext } from './provider.js'
@@ -75,8 +75,11 @@ export function ivanoFrankivskProvider(): Provider {
     sampleAddress: { city: 'Івано-Франківськ', street: 'Галицька', house: '1' },
 
     async getSchedules(ctx) {
-      const responses = await mapLimit(GROUPS, CONCURRENCY, (g) =>
-        ctx.http.json<unknown>(`${API}/schedule-by-queue?queue=${g}`, { region }),
+      const responses = await mapLimit(
+        GROUPS,
+        CONCURRENCY,
+        (g) => ctx.http.json<unknown>(`${API}/schedule-by-queue?queue=${g}`, { region }),
+        ctx.signal,
       )
       return parseQueueSchedules(responses, ctx.now())
     },
@@ -155,7 +158,7 @@ export function parseQueueSchedules(responses: readonly unknown[], now: Date): R
   }
 
   const dates = [...byDate.keys()].sort()
-  if (!dates.length) return { region, groups: [], schedules: {}, updatedAt: null, fetchedAt: toKyivIso(now) }
+  if (!dates.length) return unpublished(region, GROUPS, now)
 
   const groups = [...new Set([...GROUPS, ...dates.flatMap((d) => [...byDate.get(d)!.keys()])])].sort(
     compareGroups,

package/src/providers/khmelnytskyi.ts

@@ -198,8 +198,8 @@ export function textSchedules(
   html: string,
   now: Date,
   from: string,
-): Map<string, Record<string, MinuteSlot[]>> {
-  const out = new Map<string, Record<string, MinuteSlot[]>>()
+): Map<string, Record<string, MinuteSlot[] | null>> {
+  const out = new Map<string, Record<string, MinuteSlot[] | null>>()
   const start = html.indexOf('class="post"')
   if (start === -1) return out
   const end = html.indexOf('Перевірити чергу', start)
@@ -220,11 +220,20 @@ export function textSchedules(
   return out
 }
 
-function mergeText(images: RegionSchedule, text: Map<string, Record<string, MinuteSlot[]>>): RegionSchedule {
+function mergeText(
+  images: RegionSchedule,
+  text: Map<string, Record<string, MinuteSlot[] | null>>,
+): RegionSchedule {
   if (!text.size) return images
   const schedules: Record<string, DaySchedule[]> = { ...images.schedules }
   for (const [date, groups] of text)
-    for (const g of STANDARD_GROUPS) schedules[g] = [...(schedules[g] ?? []), makeDay(date, groups[g] ?? [])]
+    for (const g of STANDARD_GROUPS) {
+      const slots = groups[g]
+      // named without times or a "power on" statement: not known (an unlisted group has none)
+      const day: DaySchedule =
+        slots === null ? { date, status: 'unknown', intervals: [] } : makeDay(date, slots ?? [])
+      schedules[g] = [...(schedules[g] ?? []), day]
+    }
   for (const g of Object.keys(schedules)) schedules[g]!.sort((a, b) => a.date.localeCompare(b.date))
   return { ...images, groups: Object.keys(schedules).sort(compareGroups), schedules }
 }

package/src/providers/kirovohrad.ts

@@ -14,7 +14,7 @@ import type {
   Street,
 } from '../types.js'
 import type { Provider, ProviderContext } from './provider.js'
-import { cookieHeader, mapLimit } from '../util.js'
+import { SharedTask, cookieHeader, mapLimit } from '../util.js'
 
 /**
  * Kirovohradoblenergo (kiroe.com.ua). The /electricity-blackout page hands out a PHP session
@@ -71,7 +71,7 @@ export interface ApiHouse {
 
 export function kirovohradProvider(): Provider {
   const region = INFO.id
-  let current: Promise<Session> | null = null
+  let current: SharedTask<Session> | null = null
   let currentAt = 0
   let cities: Promise<City[]> | null = null
   // house id → its number and groups, filled by searchHouses so groupOf needs no extra request
@@ -95,15 +95,19 @@ export function kirovohradProvider(): Provider {
   }
 
   const session = (ctx: ProviderContext, renew = false): Promise<Session> => {
-    if (renew || !current || Date.now() - currentAt > SESSION_TTL_MS) {
+    if (renew || !current || current.aborted || Date.now() - currentAt > SESSION_TTL_MS) {
       currentAt = Date.now()
-      const p = bootstrap(ctx)
-      current = p
-      p.catch(() => {
-        if (current === p) current = null
+      // shared by concurrent calls: one caller cancelling doesn't fail the others, and it is
+      // cancelled only when every caller waiting for it has given up
+      const task = new SharedTask((signal) =>
+        bootstrap({ ...ctx, http: ctx.http.withSignal(signal), signal }),
+      )
+      current = task
+      task.promise.catch(() => {
+        if (current === task) current = null
       })
     }
-    return current
+    return current.join(ctx.signal)
   }
 
   const post = async (ctx: ProviderContext, s: Session, path: string): Promise<unknown> => {