@ixo/openhands-sdk 0.0.0-stage → 0.1.0

package/dist/cjs/campaign/spots.js

@@ -0,0 +1,790 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openMappingAsk = exports.POOL_READS_PER_LOAD = exports.POOL_TTL_MS = exports.CampaignReadIncomplete = exports.campaignReadBudgetMs = exports.campaignSince = exports.campaignWalkTtlMs = exports.FRESH_BODY_READS = exports.cleanable = void 0;
+exports.pinOf = pinOf;
+exports.loadPins = loadPins;
+exports.termsOf = termsOf;
+exports.completeOrThrow = completeOrThrow;
+exports.afterFailedRead = afterFailedRead;
+exports.forgetCampaignReads = forgetCampaignReads;
+exports.campaignCollections = campaignCollections;
+exports.inThisApp = inThisApp;
+exports.loadCampaignPins = loadCampaignPins;
+exports.poolsToRead = poolsToRead;
+exports.confirmationsIn = confirmationsIn;
+exports.confirmationsFor = confirmationsFor;
+exports.openAskOfType = openAskOfType;
+const given_ts_1 = require("../given.js");
+const envRead_ts_1 = require("../envRead.js");
+const gql_ts_1 = require("../data/gql.js");
+const fold_ts_1 = require("./fold.js");
+const commit_ts_1 = require("./commit.js");
+const bands_ts_1 = require("./bands.js");
+const docPath_ts_1 = require("../data/docPath.js");
+const pool_ts_1 = require("./pool.js");
+const concurrency_ts_1 = require("../data/concurrency.js");
+/**
+ * A pin somebody can put their hands to right now.
+ *
+ * **Not a question about money.** Under the pool rule every approved pin gets
+ * its cleanup ask from the campaign's own legs on the next pass, and whoever
+ * cleans it is paid whatever has arrived in the pot by then — so a mess with
+ * an empty pot is still a mess you can go and clear. The map's banner was
+ * left counting funded pins when that changed, and read "0 ready to clean"
+ * over a map full of them (2026-09-16).
+ *
+ * The ask does have to exist: the few minutes between a pin's approval and
+ * the next pool pass is a mess with nothing yet to answer.
+ */
+/* The rule itself lives in `cleanable.ts`, which imports nothing: two client
+   components need it, and importing it from HERE put this whole module — the
+   index queries, the fold, the store reads — into the browser's bundle, where
+   every line added to it was a byte shipped to a phone. Server code may still
+   take it from here. */
+var cleanable_ts_1 = require("./cleanable.js");
+Object.defineProperty(exports, "cleanable", { enumerable: true, get: function () { return cleanable_ts_1.cleanable; } });
+const APPROVED = 1;
+/**
+ * The bands whose asks take patches rather than one pair of photographs.
+ *
+ * The campaign rule owns this line (`pool.bigFrom`) and the worker reads it
+ * there; a map drawn in a browser has no rule to hand, so it carries the
+ * default the rule ships with. They agree today and the rule is the
+ * authority if they ever stop: what this changes on a map is which buttons a
+ * sheet offers, never who is paid.
+ */
+const BIG_BANDS = new Set(["boot", "trailer", "truck", "bigger"]);
+/*
+ * How many index and store reads go out at once.
+ *
+ * Every fold here is a fan-out: a terms document per collection, a body per
+ * claim. One at a time was the slowest thing any cron did; all at once is a
+ * few hundred sockets against one volunteer-run store. Eight turns a
+ * two-minute fold into seconds without becoming the load it measures.
+ */
+const IN_FLIGHT = 8;
+/** How many claim bodies one load reads itself when the worker has read the rest (fold.ts `readCampaignPins`). */
+exports.FRESH_BODY_READS = 60;
+/* Next's own cache hint. Typed loosely because this module is also read by
+   the worker and by scripts, where `RequestInit` is the platform's and knows
+   nothing about `next` — an untyped spread is honest about that rather than
+   pretending the field is standard. */
+const NEXT_CACHE = { next: { revalidate: 3600 } };
+/**
+ * A pin's coordinates come from the claim body, not from the terms.
+ *
+ * Everywhere else in this estate the poster names the place and the worker
+ * proves they were near it. Here finding the place *is* the work, so the
+ * coordinates arrive inside the submission — which also means a body that
+ * cannot be read is a pin that cannot be drawn, rather than a pin drawn in the
+ * wrong spot. Dropped, quietly and on purpose.
+ */
+function pinOf(claimId, at, body) {
+    const lat = Number(body.location?.lat);
+    const lon = Number(body.location?.lon);
+    if (!Number.isFinite(lat) || !Number.isFinite(lon))
+        return null;
+    if (Math.abs(lat) > 90 || Math.abs(lon) > 180)
+        return null;
+    const said = body.assessment;
+    return {
+        claimId,
+        lat,
+        lon,
+        source: body.location?.source === "photo" ? "photo" : "reported",
+        /* Through the app's own redirect, which finds whichever store holds the
+           bytes: a pin is rendered by two apps and a photograph may sit on either. */
+        thumb: body.thumb ? (0, docPath_ts_1.docPath)(body.thumb) : null,
+        photo: body.file ? (0, docPath_ts_1.docPath)(body.file) : null,
+        photoCid: body.file ?? null,
+        thumbCid: body.thumb ?? null,
+        /* The finder's bands, only when they are bands: anything else is a mess
+           that exists but cannot be priced, and the map says so by showing the
+           pin without a price rather than pricing it at nothing. */
+        assessment: (0, bands_ts_1.isAssessment)(said)
+            ? {
+                volume: said.volume,
+                waste: said.waste,
+                access: said.access,
+                /* Only when it says more than the single band does — a list of one
+                   is the old shape wearing a new field, and every reader would
+                   have to decide which it meant. Junk is dropped and the pin keeps
+                   its price: the three bands are the contract, the list is extra. */
+                ...(() => {
+                    const kinds = (0, bands_ts_1.wastesOf)(said);
+                    return kinds.length > 1 ? { wastes: kinds } : {};
+                })()
+            }
+            : null,
+        ...(body.hazard === true ? { hazard: true } : {}),
+        /* A whole number of days or nothing. The rule decides whether it is a
+           length the campaign allows; this only refuses what is not a length. */
+        ...(Number.isInteger(body.days) && body.days >= 1 && body.days <= 365 ? { days: body.days } : {}),
+        alias: body.alias?.slice(0, 40) ?? null,
+        place: body.place?.slice(0, 80) ?? null,
+        /* A code or nothing — a filter must never group on junk. */
+        ...(typeof body.country === "string" && /^[A-Z]{2}$/.test(body.country) ? { country: body.country } : {}),
+        mappedAt: at,
+        words: body.deliverable?.slice(0, 400) ?? null
+    };
+}
+/**
+ * The map's whole data source.
+ *
+ * One GraphQL read for the approved claims, then their bodies in parallel —
+ * the bodies are immutable and content-addressed, so they cache for as long as
+ * anyone likes. A body that will not load costs one pin, never the page.
+ */
+async function loadPins(collectionId, limit = 500) {
+    const data = await (0, gql_ts_1.gql)(`query {
+      claims(filter: {collectionId: {equalTo: ${JSON.stringify(collectionId)}}}, first: ${limit}, orderBy: SUBMISSION_DATE_DESC) {
+        nodes { claimId submissionDate evaluationByClaimId { status } }
+      }
+    }`, 8);
+    const approved = (data.claims?.nodes ?? []).filter((claim) => claim.evaluationByClaimId?.status === APPROVED);
+    const pins = await (0, concurrency_ts_1.mapLimit)(approved, IN_FLIGHT, async (claim) => {
+        try {
+            const { fetchDoc } = await Promise.resolve().then(() => __importStar(require("../data/docs.js")));
+            const response = await fetchDoc(claim.claimId, { timeoutMs: 10_000, ...NEXT_CACHE });
+            if (!response.ok)
+                return null;
+            return pinOf(claim.claimId, claim.submissionDate, (await response.json()));
+        }
+        catch {
+            return null;
+        }
+    });
+    return pins.filter((pin) => pin !== null);
+}
+const APPROVED_ONLY = (nodes) => nodes.filter((one) => one.evaluationByClaimId?.status === APPROVED);
+async function termsOf(entityDid, cache) {
+    if (cache.has(entityDid))
+        return cache.get(entityDid);
+    const reading = (async () => {
+        try {
+            const { doneMeansProof } = await Promise.resolve().then(() => __importStar(require("../data/resources.js")));
+            const nodes = await (0, gql_ts_1.gql)(`query { entities(filter: {id: {equalTo: ${JSON.stringify(entityDid)}}}) { nodes { linkedResource } } }`, 8);
+            const proof = doneMeansProof((nodes.entities?.nodes?.[0]?.linkedResource ?? []));
+            if (!proof)
+                return null;
+            const { fetchDoc } = await Promise.resolve().then(() => __importStar(require("../data/docs.js")));
+            const response = await fetchDoc(proof, { timeoutMs: 12_000, ...NEXT_CACHE });
+            return response.ok ? (await response.json()) : null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    cache.set(entityDid, reading);
+    return reading;
+}
+/*
+ * One walk per campaign per short while, shared by everyone in this process.
+ *
+ * A funding pass reads the pins, then the confirmations, then the open ask of
+ * a kind — three readers, and each used to page and fold the same collections
+ * again. A request that renders a campaign does the same through two routes.
+ * The walk is the expensive thing here, and thirty seconds is as stale as
+ * the surfaces above it already accept (the youth app's pin cache,
+ * `wcd/lib/campaignCache.ts`, revalidates at thirty). The promise is what is held, so concurrent readers wait on one walk
+ * rather than each starting their own; a walk that failed is forgotten, so
+ * the next reader tries again.
+ */
+/* `CAMPAIGN_WALK_TTL_MS` / `configure({ campaignWalkTtlMs })`, read per call. */
+const campaignWalkTtlMs = () => (0, given_ts_1.givenConfig)().campaignWalkTtlMs ?? Number(((0, envRead_ts_1.hasEnv)() ? (0, envRead_ts_1.firstSet)(process.env.CAMPAIGN_WALK_TTL_MS) : undefined) ?? 30_000);
+exports.campaignWalkTtlMs = campaignWalkTtlMs;
+const walkTtlMs = exports.campaignWalkTtlMs;
+/** `configure({ campaignSince })`, else `NEXT_PUBLIC_CAMPAIGN_SINCE`, else undefined (the walk then reads 90 days back). */
+const campaignSince = () => {
+    const given = (0, given_ts_1.givenConfig)();
+    if ("campaignSince" in given)
+        return given.campaignSince;
+    return (0, envRead_ts_1.hasEnv)() ? process.env.NEXT_PUBLIC_CAMPAIGN_SINCE : undefined;
+};
+exports.campaignSince = campaignSince;
+/** `configure({ campaignReadBudgetMs })`, else `CAMPAIGN_READ_BUDGET_MS`, else 20000. */
+const campaignReadBudgetMs = () => (0, given_ts_1.givenConfig)().campaignReadBudgetMs ?? Number(((0, envRead_ts_1.hasEnv)() ? (0, envRead_ts_1.firstSet)(process.env.CAMPAIGN_READ_BUDGET_MS) : undefined) ?? 20_000);
+exports.campaignReadBudgetMs = campaignReadBudgetMs;
+const walks = new Map();
+/**
+ * A read of the campaign that stopped before it had seen everything.
+ *
+ * The walk has a budget, and it used to return whatever it had when the
+ * budget ran out — including nothing at all, which every caller then treated
+ * as "this campaign has no pins" and cached. Running out of time is not an
+ * answer about the campaign. It is thrown, with what was found so far, and
+ * `campaignCollections` decides: the last complete read if there is one, the
+ * partial one if it found anything, and otherwise the failure it is.
+ */
+class CampaignReadIncomplete extends Error {
+    partial;
+    constructor(partial, why) {
+        super(`the campaign read stopped early: ${why}`);
+        this.name = "CampaignReadIncomplete";
+        this.partial = partial;
+    }
+}
+exports.CampaignReadIncomplete = CampaignReadIncomplete;
+/** Throws when the walk was cut short; returns the read otherwise. Pure, so the rule can be tested without an index. */
+function completeOrThrow(out, cut) {
+    if (cut.pagesCutShort)
+        throw new CampaignReadIncomplete(out, `paging stopped at ${cut.seen} collections`);
+    if (cut.unread > 0)
+        throw new CampaignReadIncomplete(out, `${cut.unread} of ${cut.seen} asks were not classified`);
+    return out;
+}
+/* The last complete read per campaign, for the life of the process — what a
+   failed or cut-short read answers with instead of an empty campaign. */
+const lastComplete = new Map();
+/** What a read that failed is answered with. Exported for the test; `campaignCollections` is its only caller. */
+function afterFailedRead(campaign, error) {
+    const kept = lastComplete.get(campaign);
+    if (kept)
+        return kept;
+    if (error instanceof CampaignReadIncomplete && error.partial.mapping.length > 0)
+        return error.partial;
+    throw error;
+}
+/** For tests: forget every read this process has kept. */
+function forgetCampaignReads() {
+    walks.clear();
+    lastComplete.clear();
+    poolMemo.clear();
+}
+async function campaignCollections(campaign, options = {}) {
+    const key = JSON.stringify([campaign, options.since ?? null, options.limit ?? null, options.budgetMs ?? null]);
+    const now = Date.now();
+    const ttlMs = walkTtlMs();
+    const held = walks.get(key);
+    if (held && now - held.at < ttlMs)
+        return held.reading;
+    for (const [other, entry] of walks)
+        if (now - entry.at >= ttlMs)
+            walks.delete(other);
+    /*
+     * The fold first, the walk only without one.
+     *
+     * The worker folds the campaign once, on its own clock, and publishes the
+     * result (fold.ts); reading that is one small fetch, and it is the same
+     * answer for everybody. The walk below is what this was before, kept as
+     * the fallback for a deployment with no worker in reach or one that has
+     * not folded yet — slower, never absent.
+     */
+    /* The fold chooses the asks; the mapping asks' claims — the pins — are read
+       again from the index, because a pin mapped after the last fold is a pin
+       (fold.ts `liveMapping`). The walk reads everything live already. */
+    const reading = (0, fold_ts_1.readCampaignFold)(campaign)
+        .then((fold) => (fold ? (0, fold_ts_1.liveMapping)((0, fold_ts_1.fromFold)(fold)) : walkCampaign(campaign, options)))
+        .then((complete) => {
+        lastComplete.set(campaign, complete);
+        return complete;
+    }, 
+    /* A read that failed, or ran out of time, is not an empty campaign. */
+    (error) => afterFailedRead(campaign, error));
+    walks.set(key, { at: now, reading });
+    reading.catch(() => {
+        if (walks.get(key)?.reading === reading)
+            walks.delete(key);
+    });
+    return reading;
+}
+async function walkCampaign(campaign, options) {
+    const PAGE = 200;
+    const CEILING = options.limit ?? 5000;
+    const since = options.since ?? (0, exports.campaignSince)() ?? new Date(Date.now() - 90 * 24 * 3600 * 1000).toISOString();
+    /*
+     * A time budget as well as a page ceiling.
+     *
+     * The ceiling bounds how much is read; it does not bound how long that
+     * takes, and on a busy testnet ninety days is more than five thousand
+     * collections. That is a scan measured in minutes, which is longer than a
+     * static export waits (60 s) and longer than a serverless function lives —
+     * so an unset `NEXT_PUBLIC_CAMPAIGN_SINCE` did not make the map slow, it
+     * made the production build fail, on a page whose data is a nicety.
+     *
+     * The trade this makes is the same one the ceiling already makes and says
+     * out loud: a campaign may be missing its oldest asks. A map missing its
+     * oldest pins is a smaller harm than a deployment that will not build.
+     */
+    const deadline = Date.now() + (options.budgetMs ?? (0, exports.campaignReadBudgetMs)());
+    const nodes = [];
+    let cursor = null;
+    let ranOut = false;
+    let pagesCutShort = false;
+    for (;;) {
+        const page = await (0, gql_ts_1.gql)(`query {
+      claimCollections(filter: {startDate: {greaterThan: ${JSON.stringify(since)}}}, first: ${PAGE}${cursor ? `, after: ${JSON.stringify(cursor)}` : ""}, orderBy: START_DATE_DESC) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id state endDate entity admin quota evaluated payments
+          claimsByCollectionId { nodes { claimId submissionDate agentAddress evaluationByClaimId { status evaluationDate } } }
+        }
+      }
+    }`, 8);
+        nodes.push(...(page.claimCollections?.nodes ?? []));
+        const info = page.claimCollections?.pageInfo;
+        ranOut = Date.now() > deadline;
+        if (!info?.hasNextPage || !info.endCursor || nodes.length >= CEILING || ranOut) {
+            if (info?.hasNextPage && (nodes.length >= CEILING || ranOut)) {
+                pagesCutShort = true;
+                console.warn(`[spots] stopped at ${nodes.length} collections after ${ranOut ? "running out of time" : `the ${CEILING} this read pages`}. ` +
+                    `so this campaign may be missing its oldest asks. Set NEXT_PUBLIC_CAMPAIGN_SINCE to the campaign's own start date: ` +
+                    `the window is the whole cost here.`);
+            }
+            break;
+        }
+        cursor = info.endCursor;
+    }
+    const cache = new Map();
+    const out = { mapping: [], cleanups: [], reports: [], commitments: [] };
+    /* The fold is a terms fetch per collection, and it is the expensive half —
+       so it honours the same deadline the paging did, `IN_FLIGHT` reads at a
+       time. Order is kept: the buckets below are newest-first because the walk
+       was, and `openAskOfType` relies on that. A read that would start after
+       the deadline is not started, so the fold stops where the time did. */
+    let unread = 0;
+    const read = await (0, concurrency_ts_1.mapLimit)(nodes, IN_FLIGHT, (node) => {
+        if (Date.now() > deadline) {
+            unread += 1;
+            return Promise.resolve(null);
+        }
+        return termsOf(node.entity, cache);
+    });
+    if (unread > 0)
+        console.warn(`[spots] stopped folding ${unread} of ${nodes.length} asks short. Out of time`);
+    for (const [index, node] of nodes.entries()) {
+        const terms = read[index];
+        if (!terms || terms.campaign !== campaign)
+            continue;
+        const kind = terms.deliverable?.type;
+        if (kind === "mess-report")
+            out.mapping.push(node);
+        else if (kind === "field-report")
+            out.reports.push(node);
+        else if (kind === "commitment")
+            out.commitments.push(node);
+        else if (typeof terms.clears === "string") {
+            /* An ask is open while its deadline stands and nothing has filled it —
+               the same openness rule every surface uses, in miniature. */
+            const ends = node.endDate ? Date.parse(node.endDate) : NaN;
+            const open = node.state === 0 && (!Number.isFinite(ends) || ends > Date.now());
+            out.cleanups.push({ node, clears: terms.clears, open });
+        }
+    }
+    return completeOrThrow(out, { pagesCutShort, unread, seen: nodes.length });
+}
+/**
+ * Every pin in a campaign, with what became of it.
+ *
+ * Nothing here reads a ledger; a spot's whole life is public or it is not
+ * true.
+ */
+/**
+ * A pin the worker read, with its photographs addressed for THIS app.
+ *
+ * `thumb` and `photo` are same-origin paths (`docPath`), and `docPath` carries
+ * the base path of whoever runs it: `/cleanup/api/doc/<cid>` in the youth app,
+ * `/api/doc/<cid>` in the main one. While each app projected its own pins that
+ * was invisible. The worker projects them once for both, and it has no base
+ * path — so the youth app served the worker's `/api/doc/<cid>`, which is a 404
+ * under `/cleanup`, and every pin on the production map lost its photograph
+ * (2026-09-20, the morning the campaign became rows).
+ *
+ * A path is the reading app's to build, so it is rebuilt here from the
+ * address: the one the pin carries when it has it, else the last segment of
+ * whatever path was stored, under whatever prefix. Anything that is not one
+ * of our document paths — an absolute URL, a shape from some later release —
+ * is left exactly as it was. Returns a copy: the state a load writes onto a
+ * pin must never reach the set that is kept between loads.
+ */
+function inThisApp(pin) {
+    return { ...pin, thumb: ownPath(pin.thumb, pin.thumbCid), photo: ownPath(pin.photo, pin.photoCid) };
+}
+const DOC_PATH = /^(?:\/[^/?#]+)*\/api\/doc\/([^/?#]+)$/;
+function ownPath(stored, cid) {
+    if (cid && (0, docPath_ts_1.isCid)(cid))
+        return (0, docPath_ts_1.docPath)(cid);
+    if (!stored)
+        return stored;
+    const match = DOC_PATH.exec(stored);
+    if (!match)
+        return stored;
+    let address;
+    try {
+        address = decodeURIComponent(match[1]);
+    }
+    catch {
+        return stored;
+    }
+    return (0, docPath_ts_1.isCid)(address) ? (0, docPath_ts_1.docPath)(address) : stored;
+}
+async function loadCampaignPins(campaign, options = {}) {
+    const { mapping, cleanups, reports, commitments } = await campaignCollections(campaign, options);
+    /* The pins themselves: every approved mess report across every mapping ask
+       in the tag — a campaign may open a second one when the first fills. */
+    const pins = [];
+    /* Every approved claim's body, fetched together. One at a time this was
+       ~1 s per claim, and a fourteen-claim campaign spent 17 s here — past
+       the read budget on a bad day, so the map opened empty and centred on
+       Ljubljana while the pins existed. */
+    /* The worker has read most of them already (`readCampaignPins`): each pin is
+       a projection of a sealed body that never changes, and fetching every one
+       of them here, on every cold load, was a minute's work at two thousand
+       pins. What the worker has is taken as it is — copied, because the state
+       below is written onto these objects and the worker's set is kept between
+       loads. What only the index knows about — claims newer than the worker's
+       last publish — is read here as before, newest first and bounded, so a
+       load is never a thousand requests again; the rest arrive with the
+       worker's next publish. With no worker to ask, every body is read here,
+       exactly as it always was. */
+    const known = await (0, fold_ts_1.readCampaignPins)(campaign);
+    const have = new Set();
+    if (known) {
+        for (const [claimId, pin] of known) {
+            pins.push(inThisApp(pin));
+            have.add(claimId);
+        }
+    }
+    const unseen = mapping.flatMap((node) => APPROVED_ONLY(node.claimsByCollectionId?.nodes ?? [])).filter((claim) => !have.has(claim.claimId));
+    const approved = have.size + unseen.length;
+    const toRead = known ? unseen.slice(0, exports.FRESH_BODY_READS) : unseen;
+    const bodies = await (0, concurrency_ts_1.mapLimit)(toRead, IN_FLIGHT, (claim) => bodyPin(claim.claimId, claim.submissionDate));
+    for (const pin of bodies)
+        if (pin)
+            pins.push(pin);
+    /* Approved claims and not one readable body is the store being down, not a
+       campaign without pins — and an empty list here is cached by every caller
+       as exactly that. A campaign that really has none has no approved claims,
+       and still answers with the empty list. */
+    if (approved > 0 && pins.length === 0)
+        throw new Error(`none of ${approved} approved claims could be read from the store`);
+    /* What people found when they went there. Read before cleanups, because a
+       pin reported gone or hazardous is not a pin anybody should be funding. */
+    const findings = new Map();
+    for (const node of reports) {
+        const claims = APPROVED_ONLY(node.claimsByCollectionId?.nodes ?? []);
+        /* Fetched together, folded in order: the precedence below depends on it. */
+        const bodies = await (0, concurrency_ts_1.mapLimit)(claims, IN_FLIGHT, (claim) => bodyOf(claim.claimId));
+        for (const body of bodies) {
+            const about = typeof body?.about === "string" ? body.about : null;
+            const finding = body?.finding;
+            if (!about || !finding)
+                continue;
+            /* Hazard outranks absence outranks confirmation: the most consequential
+               thing anybody reported is the one that must reach the reader. */
+            const held = findings.get(about);
+            if (held === "hazardous")
+                continue;
+            if (finding === "hazardous" || held !== "absent")
+                findings.set(about, finding);
+        }
+    }
+    /*
+     * Promises, folded before states so a crew shows on a pin in any state
+     * somebody might still turn up for.
+     *
+     * **Submitted, not approved.** The commitment ask names no checker and
+     * grants no evaluate authorization, so nothing will ever rule on these —
+     * a promise is not true or false. The claim's existence is the record.
+     */
+    const crews = new Map();
+    for (const node of commitments) {
+        const claims = node.claimsByCollectionId?.nodes ?? [];
+        const bodies = await (0, concurrency_ts_1.mapLimit)(claims, IN_FLIGHT, (claim) => bodyOf(claim.claimId));
+        for (const [index, claim] of claims.entries()) {
+            const promise = (0, commit_ts_1.readCommitment)(bodies[index] ?? null);
+            if (!promise || promise.campaign !== campaign || !(0, commit_ts_1.stillStanding)(promise))
+                continue;
+            const held = crews.get(promise.about) ?? { who: new Set(), names: [] };
+            const who = claim.agentAddress ?? claim.claimId;
+            if (held.who.has(who))
+                continue;
+            held.who.add(who);
+            if (promise.alias && held.names.length < 3)
+                held.names.push(promise.alias);
+            crews.set(promise.about, held);
+        }
+    }
+    /* The newest cleanup for each pin — the walk is newest-first, so the first
+       one seen wins, exactly as a linear search would have found it. */
+    /*
+     * One cleanup per pin, and where there are two, the newest.
+     *
+     * A chain ask cannot be extended, so a campaign that runs all year renews
+     * a cleanup by posting a twin and carrying the pool across. Both name the
+     * same pin for ever after, and the live one is the later — keeping the
+     * first would leave the map reading an expired ask's empty pool.
+     */
+    const clearing = new Map();
+    for (const one of cleanups) {
+        const held = clearing.get(one.clears);
+        if (!held || Number(one.node.id) > Number(held.node.id))
+            clearing.set(one.clears, one);
+    }
+    for (const pin of pins) {
+        /* A site takes patches from many people; a bagful is one person with a
+           bin bag. The line is the campaign's — read from the volume band the
+           finder chose and frozen at approval, never re-assessed later. */
+        pin.big = BIG_BANDS.has(pin.assessment?.volume ?? "");
+        const crew = crews.get(pin.claimId);
+        if (crew)
+            pin.crew = { count: crew.who.size, names: crew.names };
+        /* The finder's own flag, on the report itself. Read before anybody
+           else's finding, because the person who says "don't come here" is the
+           one who was standing in front of it, and a crowd must never be offered
+           this spot while we wait for a second opinion. */
+        if (pin.hazard) {
+            pin.state = "professionals";
+            continue;
+        }
+        const finding = findings.get(pin.claimId);
+        if (finding === "hazardous") {
+            pin.state = "professionals";
+            continue;
+        }
+        if (finding === "absent") {
+            pin.state = "gone";
+            continue;
+        }
+        const cleanup = clearing.get(pin.claimId);
+        if (!cleanup) {
+            /* Approved, and its ask has not been posted yet — the pool pass runs
+               every ten minutes. Open, with nothing in the pot and no way to pay
+               into it yet, which the sheet says in those words. */
+            pin.state = "open";
+            continue;
+        }
+        pin.cleanupId = cleanup.node.id;
+        pin.poolAddress = cleanup.node.admin ?? null;
+        pin.endsAt = cleanup.node.endDate ?? null;
+        const done = APPROVED_ONLY(cleanup.node.claimsByCollectionId?.nodes ?? []);
+        /*
+         * A site is cleaned when somebody shows the whole area clear, and the
+         * patches that were held are approved in the same pass — so on a site,
+         * an approval is the site claim and every patch behind it. Pending
+         * claims on a site are patches waiting for that moment.
+         */
+        const pending = (cleanup.node.claimsByCollectionId?.nodes ?? []).filter((one) => !one.evaluationByClaimId);
+        const ended = pin.endsAt ? Date.parse(pin.endsAt) < Date.now() : false;
+        if (pin.big)
+            pin.patchesMax = Number(cleanup.node.quota ?? 0) || undefined;
+        if (done.length > 0)
+            pin.state = "cleaned";
+        else if (pending.length > 0 && pin.big) {
+            /* Patches filed before the ask ended are still judged after it, so a
+               site with work in hand is being cleared whatever the calendar says. */
+            pin.state = "cleaning";
+            pin.patches = { count: pending.length, people: new Set(pending.map((one) => one.agentAddress ?? one.claimId)).size };
+        }
+        else if (ended) {
+            /* Its days ran out and nobody cleared it. The chain refuses new claims
+               against it now; the pool pass returns what it holds once anything
+               already filed is decided. On the map it is a mess that may still be
+               there — and the honest offer is to map it again. */
+            pin.state = "expired";
+        }
+        else
+            pin.state = "open";
+        /* When it was cleaned, so a corner that fouls again can be re-reported
+           once the cool-down has passed — a campaign that runs all year has to
+           let a place come back. */
+        if (done.length > 0) {
+            pin.cleanedAt = done.map((claim) => claim.evaluationByClaimId?.evaluationDate ?? null).filter(Boolean).sort().at(-1) ?? null;
+        }
+    }
+    await fillPools(pins, cleanups);
+    return pins;
+}
+/**
+ * What is in each open pin's pot, read from the chain in one go.
+ *
+ * A balance per pin would be one request each and a map draws two hundred;
+ * the distinct pool addresses are asked for together instead. A pool that
+ * cannot be read is left undefined rather than shown as zero — "nothing in
+ * the pot" and "we could not look" are different sentences, and only one of
+ * them should discourage a backer.
+ */
+exports.POOL_TTL_MS = 60_000;
+exports.POOL_READS_PER_LOAD = 300;
+const POOL_MEMO_MAX = 10_000;
+const poolMemo = new Map();
+/**
+ * Which pots this load reads: the ones never read, then the stalest, never
+ * more than the cap — and among equals, the newest ask first. Pure, so the
+ * rule can be tested without a chain.
+ */
+function poolsToRead(live, memo, now, cap = exports.POOL_READS_PER_LOAD, ttlMs = exports.POOL_TTL_MS) {
+    const newest = new Map();
+    for (const one of live)
+        newest.set(one.address, Math.max(newest.get(one.address) ?? 0, one.askId));
+    return [...newest.entries()]
+        .map(([address, askId]) => ({ address, askId, at: memo.get(address)?.at ?? -Infinity }))
+        .filter((one) => now - one.at >= ttlMs)
+        .sort((a, b) => a.at - b.at || b.askId - a.askId)
+        .slice(0, Math.max(0, cap))
+        .map((one) => one.address);
+}
+async function fillPools(pins, cleanups) {
+    const live = pins.filter((pin) => pin.poolAddress && (pin.state === "open" || pin.state === "cleaning"));
+    if (!live.length)
+        return;
+    const byId = new Map(cleanups.map((one) => [String(one.node.id), one.node]));
+    const legOf = (node, which) => Number(node?.payments?.[which]?.amount?.[0]?.amount ?? 0);
+    try {
+        const { getQueryClient } = await Promise.resolve().then(() => __importStar(require("../chain/query.js")));
+        const { askDenom } = await Promise.resolve().then(() => __importStar(require("../chain/money.js")));
+        const client = await getQueryClient();
+        /* One balance per live pool is one request each, and the chain has no way
+           to ask for many. Two hundred pins was tolerable; two thousand open pots
+           is two thousand RPC calls a load. So a balance is remembered for a
+           minute, and a load reads at most `POOL_READS_PER_LOAD` of the ones it
+           does not know or knows stalest — the newest asks first, which is where
+           money is arriving. Every pot is still read; a very large campaign takes
+           a few loads to go round instead of one load taking a minute. */
+        const now = Date.now();
+        const wanted = poolsToRead(live.map((pin) => ({ address: pin.poolAddress, askId: Number(pin.cleanupId) || 0 })), poolMemo, now);
+        await (0, concurrency_ts_1.mapLimit)(wanted, IN_FLIGHT, async (address) => {
+            const { balance } = await client.cosmos.bank.v1beta1.balance({ address, denom: askDenom() });
+            poolMemo.set(address, { at: now, base: Number(balance?.amount ?? 0) });
+        });
+        if (poolMemo.size > POOL_MEMO_MAX)
+            for (const address of [...poolMemo.keys()].slice(0, poolMemo.size - POOL_MEMO_MAX))
+                poolMemo.delete(address);
+        for (const pin of live) {
+            const node = byId.get(String(pin.cleanupId));
+            const balanceBase = poolMemo.get(pin.poolAddress)?.base;
+            if (balanceBase === undefined)
+                continue;
+            pin.poolBase = (0, pool_ts_1.poolAvailable)({
+                balanceBase,
+                quota: Number(node?.quota ?? 1),
+                evaluated: Number(node?.evaluated ?? 0),
+                checkRewardBase: legOf(node, "evaluation"),
+                approvalLegBase: legOf(node, "approval")
+            });
+        }
+    }
+    catch {
+        /* An unreadable chain leaves every pot unknown, which the sheet says. */
+    }
+}
+/**
+ * How many people have stood at each pin and said it is really there.
+ *
+ * The count that lets a truck-sized spot take somebody's money: sponsor funds
+ * never escrow against one person's say-so. It reads the campaign's own field
+ * reports — the same standing ask the "it's gone" tap writes to — and not, as
+ * it once did, the newest two hundred claims on the entire chain regardless of
+ * who filed them or what they were about.
+ *
+ * Every pin at once, from one walk. A funding round asks this about each spot
+ * it is considering, and the older shape answered by re-walking the campaign
+ * every time — forty spots, forty scans, each one a window's worth of terms
+ * fetches.
+ */
+async function confirmationsIn(campaign, options = {}) {
+    const { reports } = await campaignCollections(campaign, options);
+    /* One person, one confirmation. Two reports from the same key are one
+       opinion, and the whole point of this number is that it is several. */
+    const byPin = new Map();
+    for (const node of reports) {
+        const claims = APPROVED_ONLY(node.claimsByCollectionId?.nodes ?? []);
+        const bodies = await (0, concurrency_ts_1.mapLimit)(claims, IN_FLIGHT, (claim) => bodyOf(claim.claimId));
+        for (const [index, claim] of claims.entries()) {
+            const body = bodies[index];
+            if (body?.finding !== "confirmed" || typeof body.about !== "string" || body.campaign !== campaign)
+                continue;
+            const who = claim.agentAddress ?? claim.claimId;
+            const seen = byPin.get(body.about) ?? new Set();
+            seen.add(who);
+            byPin.set(body.about, seen);
+        }
+    }
+    return new Map([...byPin].map(([pin, who]) => [pin, who.size]));
+}
+/** The same question about one pin. Prefer `confirmationsIn` in a loop. */
+async function confirmationsFor(campaign, claimId, options = {}) {
+    return (await confirmationsIn(campaign, options)).get(claimId) ?? 0;
+}
+async function bodyOf(claimId) {
+    try {
+        const { fetchDoc } = await Promise.resolve().then(() => __importStar(require("../data/docs.js")));
+        const response = await fetchDoc(claimId, { timeoutMs: 10_000, ...NEXT_CACHE });
+        return response.ok ? (await response.json()) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function bodyPin(claimId, at) {
+    const body = await bodyOf(claimId);
+    return body ? pinOf(claimId, at, body) : null;
+}
+/**
+ * The campaign's standing mapping ask, if it has one open.
+ *
+ * One campaign, one mapping ask — the novelty gate refuses duplicates within
+ * one ask, so a second would let the same mess be mapped twice for two fees.
+ */
+/**
+ * The campaign's open ask of a given kind, found rather than configured.
+ *
+ * `NEXT_PUBLIC_MESS_ASK` names one collection, is build-inlined, and therefore
+ * turns "the mapping ask filled up, post another" into a redeploy nobody can
+ * do from a phone. A campaign that runs all year will do that several times,
+ * and will also want a standing field-report ask and a commitment ask that
+ * nobody wants to name in three environments each.
+ *
+ * So: ask the campaign what it has open. The env var still wins where it is
+ * set, because pinning one collection is exactly right during a rehearsal.
+ */
+async function openAskOfType(campaign, type, options = {}) {
+    const { mapping, reports, cleanups } = await campaignCollections(campaign, options);
+    const pool = type === "mess-report" ? mapping : type === "field-report" ? reports : cleanups.map((one) => one.node);
+    /* Newest first — `campaignCollections` walks START_DATE_DESC — so a campaign
+       on its third mapping ask gets the one it just posted, not the one that
+       filled up in March. */
+    for (const node of pool) {
+        const ends = node.endDate ? Date.parse(node.endDate) : NaN;
+        if (node.state === 0 && (!Number.isFinite(ends) || ends > Date.now()))
+            return node.id;
+    }
+    return null;
+}
+/** The campaign's open mapping ask — the one the map is made of. */
+const openMappingAsk = (campaign, options = {}) => openAskOfType(campaign, "mess-report", options);
+exports.openMappingAsk = openMappingAsk;
+//# sourceMappingURL=spots.js.map