@trillboards/edge-sdk 0.2.95 → 0.2.98

package/deploy/windows/enroll-connector.ps1

@@ -154,6 +154,13 @@ try {
       exit 5
     }
     1 { Remove-EnrollmentFile; Write-Log "enrollment credential REJECTED - a new one must be issued"; exit 1 }
+    2 {
+      # Bad ARGUMENTS (e.g. a malformed --rtsp). Nothing was attempted, so the
+      # credential is unspent - and unlike 1 and 4 the file is KEPT, because an
+      # operator typo must not cost the store its fleet credential.
+      Write-Log "enrollment arguments are invalid - credential PRESERVED, fix the command and re-run"
+      exit 2
+    }
     4 { Remove-EnrollmentFile; Write-Log "no enrollment token was readable"; exit 1 }
     default {
       Write-Log "enrollment deferred (retryable) - credential PRESERVED for the next-logon retry"

package/dist/DetectorFieldProducer.d.ts

@@ -0,0 +1,482 @@
+/**
+ * DetectorFieldProducer — the connector's detector→declared-field producer.
+ *
+ * ── THE GAP THIS CLOSES ────────────────────────────────────────────────────
+ *
+ * The Android agent has had one of these for a year: `QueueEstimationProcessor`
+ * turns EfficientDet detections into `pedestrian_count` / `queue_length` /
+ * `queue_detected`, keyed under the model that produced them
+ * (`AudienceSensingService.kt:3090` — `model_outputs.efficientdet.{…}`), and
+ * those are exactly the fields `efficientdet` declares in its registry
+ * `outputs_schema`.
+ *
+ * The connector has had none. It runs a real detector on 127.0.0.1:9380 at
+ * 15–90 ms a frame, and the only thing that consumes the result is
+ * `DetectorShadowProbe`, which collapses the whole detection set to a
+ * three-valued enum and discards the boxes. So "how many people are there" —
+ * a question the detector answers in milliseconds, with boxes — was answered by
+ * asking a language model in prose at ~5,645 ms, at ~9% precision on specifics
+ * (docs/runbooks/sensing-catch-rate.md §4a).
+ *
+ * ── ONE FIELD, ONE PRODUCER ────────────────────────────────────────────────
+ *
+ * The input is the `producer` half of `modelClassLiveness.partitionProfileFields`
+ * — `{field, modelId, type}` per entry, where `modelId` is the model whose
+ * registry row DECLARES that field as an output. Ownership is data; this file is
+ * only the resolution. Nothing here decides which model answers a field, and it
+ * must never acquire that opinion: a second place that can decide is how one
+ * fact ends up with two producers, which is the defect the partition exists to
+ * remove.
+ *
+ * The output is TOTAL: `produced.length + withheld.length === fields.length`,
+ * always, on every path including the ones where the detector never answered.
+ * Same contract, and the same reason, as the partition's own
+ * `producer ∪ vlm ∪ withheld === fields`: two independent filters that must
+ * agree is precisely how a field goes missing with nothing to point at.
+ *
+ * This is also why the input is the PARTITION and not the profile's raw
+ * `fields[]`. `person_count` is already in `localInferenceSchema`'s
+ * `PRESENCE_PRIMITIVE_ORDER`, so every profile asks the language model for it
+ * today; a producer handed the raw list would answer it as well and the reading
+ * an operator saw would depend on which component wrote last. The partition is
+ * what takes a produced field OUT of the prompt, and a producer that could not
+ * be told which fields those are could not be correct.
+ *
+ * ── A GRANTED MODEL WHOSE BYTES NEVER LANDED YIELDS A *MISSING* FIELD ──────
+ *
+ * A model can be granted by the profile and still be absent from the box: the
+ * grant comes from `GET /v2/earner/cameras/sensing-profile` and the artifact
+ * arrives separately over `/v1/federated/models`, which was 404 for sixteen days
+ * in August.
+ *
+ * THAT HAS TWO DOORS, and only the first one looks like a failure:
+ *
+ *   the class is unknown to the box — no resident model can emit it, so the
+ *     service answers **400 before inference** (`server.py::_detect`,
+ *     deliberately, on ANY unknown class) and `LocalDetectorClient` raises
+ *     `DetectorUnavailableError`.
+ *
+ *   the class is owned by SOMEBODY ELSE — a different resident model declares
+ *     it, so the call **succeeds with a 200** and a perfectly good answer from
+ *     the wrong instrument. Overlap is the norm: `hardhat` is declared by both
+ *     `ppe_vyra_14cls_v8m` and `ppe_construction_17cls_v8n`, `person` by those
+ *     two plus `rfdetr_medium`. The attribution check in `produce()` is the only
+ *     thing that closes this one — see the long note at its call site before
+ *     deciding it is redundant with the 400.
+ *
+ * In BOTH the field is then ABSENT. Not `false`, not `0`, and — the important
+ * one — NOT handed to the language model instead.
+ * `routeEvaluatorService.js:1272` already gets this right one layer up: a
+ * focused route reads only its mapped field and yields `no_field` rather than
+ * falling back. Substituting a different producer
+ * mid-flight is the split-brain again, in TIME instead of space: the same
+ * question, answered by two different instruments on two different frames, with
+ * nothing on the reading saying which.
+ *
+ * ── `unavailable` NEVER COLLAPSES INTO `empty` ─────────────────────────────
+ *
+ * Structural, not a convention: a value is written in exactly one place in this
+ * file, from a count derived from a parsed 2xx. There is no path from a caught
+ * error to a `false` or a `0`. Every failure — transport, 400, 503, a 2xx whose
+ * envelope is not the contract, the budget running out — lands in `withheld`.
+ *
+ * `LocalDetectorClient` and `DetectorShadowProbe` both carry this distinction in
+ * their own headers, and it is the same one: a cascade that reads "detector
+ * down" as "nobody there" suppresses every alert while `postCount`,
+ * `sensingState:'active'` and the portal's "AI active" tile all stay green
+ * (docs/runbooks/cctv-connector-runtime-edge-cases.md).
+ *
+ * ── ONE CALL PER MODEL, NOT ONE CALL PER FRAME ─────────────────────────────
+ *
+ * The service refuses a request naming ANY class it cannot resolve — it does not
+ * answer the part it recognises — and its own comment says why: "Refusing costs
+ * the `person` detections too; that is the right trade." That is correct for ONE
+ * question. A frame's declared fields are N INDEPENDENT questions, and unioning
+ * them into a single call would make them share a fate they do not share: one
+ * specialist whose bytes never landed would take `person_count` down with it.
+ *
+ * So the classes are grouped by the `modelId` the partition already supplies,
+ * one call per model, each carrying the union of the classes THAT model's fields
+ * need. A model that cannot answer loses its own fields and no others.
+ *
+ * This is not the connector holding a class→model catalogue. It cannot and must
+ * not: `docs/runbooks/sensing-model-library.md` is explicit that the service
+ * owns class→model routing because it is the only component that knows what is
+ * resident, and the wire carries `classes` and no model selector. The grouping
+ * here is FAILURE ISOLATION over an ownership fact the server sent us.
+ *
+ * Calls run SEQUENTIALLY. The box has one inference slot; issuing them in
+ * parallel queues them inside the service and spends the budget on scheduling.
+ *
+ * @reuse-audit
+ *   considered: services/regression/detectorCorpusEndpoint.js
+ *     - reused, as the SEMANTICS this file is a second implementation of: the
+ *       `<concept>_present` / `<concept>_count` key shape, `toDetectorClassName`
+ *       byte-for-byte, and the "trim each class at its own threshold, throw on a
+ *       label nobody asked for" rule, comments included. NOT imported: that is
+ *       CommonJS inside the API image and this is the connector's TypeScript
+ *       bundle; the API does not ship edge-sdk and edge-sdk does not ship the
+ *       API. What keeps them from drifting is that they answer the same corpus —
+ *       the six live `expected_output` keys (`person_count`, `person_present`,
+ *       `forklift_present`, `hardhat_present`, `excavators_present`,
+ *       `fire_extinguisher_present`) ARE the field names, and
+ *       `__tests__/DetectorFieldProducer.test.ts` pins this side onto the classes
+ *       those models declare in `coco_classes`.
+ *     - ONE DELIBERATE DIVERGENCE, marked at `countsForClasses`: its single-class
+ *       branch returns `detections.length` unread, and this one reads the label
+ *       on every branch. That is not a port that drifted — it is the same
+ *       principle under a different consumer. See the note there before
+ *       "restoring" it.
+ *   considered: trillboard-ctv/.../audience/QueueEstimationProcessor.kt
+ *     - reused: its SHAPE. A processor that turns one frame's detection set into
+ *       a map keyed by registry-canonical snake_case field names, with the
+ *       producing model's id travelling ON the values (`model_outputs.<modelId>`)
+ *       so a reading can be attributed. `toJson`'s note — "keys use
+ *       registry-canonical snake_case so `chipPersistence.sanitizeFieldKey` is
+ *       idempotent on canonical input" — is why `produced[].field` is the
+ *       DECLARED name verbatim and is never re-spelled here.
+ *     - deliberately NOT ported: its temporal half — `serviceRatePerMinute`,
+ *       `estimatedWaitTimeMinutes`, `trend`, and the 30-snapshot history they
+ *       are derived from. Nothing in any producer half declares those fields, so
+ *       emitting them would advertise a capability no registry row owns — the
+ *       `yolov8_nano` shape, where a model was offered to ~97 of 114 profile
+ *       authors while every device hardcoded it unloadable. When a model DOES
+ *       declare `queue_length`, that is a field with an owner and it arrives
+ *       here as an ordinary producer entry.
+ *   considered: edge-sensing/src/processors/FaceDetector.ts — `nonMaxSuppression`
+ *     + `iou` (the kernel `LocalDetectorClient`'s header names as the one to use)
+ *     - deliberately NOT used, and this is the one worth reading twice. The
+ *       SERVICE already ran NMS: `deploy/detector/trillboards_detector/decode.py`
+ *       does class-offset greedy NMS at `NMS_IOU_THRESHOLD = 0.7` on the anchor
+ *       branch, transcribed from ultralytics, and deliberately runs NONE on the
+ *       DETR branch because "running NMS over these rows would be a second
+ *       suppression the model was neither trained nor scored with". A pass here
+ *       would be exactly that second suppression, on both branches, and it would
+ *       move the counts away from the ones the committed score cards fitted their
+ *       thresholds against. The kernel is fine; a fourth suppression is not.
+ *   considered: edge-core `CentroidTracker` (the shared nearest-centroid tracker)
+ *     - deliberately NOT used: no field in any producer half needs cross-frame
+ *       identity. `<concept>_present` and `<concept>_count` are both properties
+ *       of ONE frame — which is also how the Android processor computes
+ *       `estimatedQueueLength` (`current.faceCount`, the latest snapshot). Wiring
+ *       a tracker in for fields that do not ask for one would add per-feed state
+ *       with no consumer. When dwell or a unique count lands, that tracker is the
+ *       one to call — it is already the consolidation of three, and a fourth is
+ *       what its own header exists to prevent.
+ *   considered: this package's `zoneContainment.countInZone`
+ *     - not used HERE: it takes a frame size and a normalized rect, and with a
+ *       null rect it IS `boxes.length`. A field focused to an operator's drawn
+ *       region is the natural next consumer of both files at once — the count
+ *       becomes `countInZone(boxes, frame, rect)` and nothing else changes — but
+ *       a producer entry carries no region today and inventing one would be a
+ *       second home for a fact `sensing_route_screens` already owns.
+ *   considered: `DetectorShadowProbe`
+ *     - not extended, and not called: it is a MEASUREMENT that must change
+ *       nothing, with a backoff and a 15 s per-feed cadence bound tuned to that
+ *       job. A producer answering an operator's declared field is a PRODUCT path
+ *       with the opposite cadence obligation.
+ *   considered: edge-core `ModelManager.hasModel(modelId)` — the connector's own
+ *     "is this artifact on disk" check (`fs.existsSync` over the registered path)
+ *     - deliberately NOT used as the arrival gate. It answers about the
+ *       CONNECTOR's download directory; what decides whether a class can be
+ *       answered is the SERVICE's `ClassIndex`, which `labels.py` builds only
+ *       over models whose artifact is on the box. Those are two opinions about
+ *       one fact and they can disagree — a file present but the wrong graph
+ *       (`ModelContractError`), or resident in a service started before the
+ *       download. Pre-checking here would also mean a `hasModel` that returned
+ *       true still has to handle the 400, so the check would be advisory at best
+ *       and a second catalogue at worst. The 400 IS the arrival check, from the
+ *       only component that knows.
+ */
+import { LocalDetectorClient } from './LocalDetectorClient';
+/**
+ * One entry of the `producer` half of a field partition.
+ *
+ * Mirrors what `modelClassLiveness.partitionProfileFields` puts in `producer[]`:
+ * the profile's own field entry, plus the `modelId` that owns it and the type
+ * the owning registry row declared.
+ *
+ * `type` is `string | null` rather than `WireSensingProfileFieldType` ON PURPOSE.
+ * The profile's `fields[].type` is that closed enum, but a producer entry's type
+ * comes from `sensing_model_registry.outputs_schema[].type`, which nothing
+ * validates on write — `declaredOutputFields` reads it as `o.type ?? null` and
+ * says so. Declaring it narrower here would be this file asserting a contract
+ * the data does not have.
+ */
+export interface ProducerField {
+    /** The DECLARED field name, verbatim. Never re-spelled — see the reuse audit. */
+    field: string;
+    /** `sensing_model_registry.model_id` of the model that declares this field. */
+    modelId: string;
+    /** The declared type, or null when the owning row carried none. */
+    type?: string | null;
+}
+/** What a detector can produce: a presence boolean or an instance count. */
+export type ProducedFieldValue = boolean | number;
+/**
+ * One field this frame answered, with everything needed to attribute it.
+ *
+ * `minConfidence` travels WITH the value rather than being restated by whoever
+ * reads it, for the reason `DetectorShadowProbe.minConfidence` does: a fleet
+ * mid-upgrade runs two operating points at once, and pooling readings taken at
+ * two thresholds averages two different classifiers with nothing saying so.
+ */
+export interface ProducedField {
+    field: string;
+    value: ProducedFieldValue;
+    /** The model the PARTITION said owns this field. */
+    modelId: string;
+    /** The class asked for, in the service's wire spelling. */
+    className: string;
+    /** The confidence floor this value was counted at. */
+    minConfidence: number;
+    /** The artifact that actually answered, as it names itself. Null if it did not say. */
+    detectorModel: string | null;
+}
+/** Why a declared field has no reading this frame. */
+export declare const PRODUCER_WITHHOLD_REASONS: {
+    /**
+     * The field name is not `<concept>_present` / `<concept>_count`, so no
+     * detector class can be derived from it.
+     *
+     * WITHHELD RATHER THAN DROPPED. A registry row may declare `queue_length` or
+     * `vehicle_trend` — `efficientdet` declares both — and a detection set answers
+     * neither. Guessing a class out of `trend` is how a bus gets counted as a
+     * person; silently dropping it is how a field goes missing with nothing to
+     * point at.
+     */
+    readonly UNMAPPED: "unmapped";
+    /**
+     * The declared type contradicts what the name asks for — a `_present` field
+     * declared `counter`, say.
+     *
+     * The suffix decides the COMPUTATION and the type is the published contract;
+     * when they disagree the row is defective and either answer is wrong. Refusing
+     * names the defect instead of writing a boolean into a slot rendered as a
+     * number.
+     */
+    readonly TYPE_CONTRADICTS_NAME: "type_contradicts_name";
+    /**
+     * The detector did not answer for this field's model.
+     *
+     * Transport, 400 (a class no resident model can emit — i.e. a granted model
+     * whose bytes never landed), 503, a 2xx whose envelope is not the contract, a
+     * response labelled with a class nobody asked for, or the budget running out.
+     * All of them mean the same thing to a consumer: there is NO READING. None of
+     * them may become a value.
+     */
+    readonly DETECTOR_UNAVAILABLE: "detector_unavailable";
+    /**
+     * The entry names no model.
+     *
+     * Its own reason rather than `unmapped`, because it is a defect in a different
+     * place: the NAME was readable and it is the OWNERSHIP that is missing. The
+     * partition cannot emit such an entry — it only puts a field in `producer[]`
+     * once it has found an owner — so this is a claim about a caller, and saying
+     * "no class follows from that name" about it would send the reader to the
+     * registry's `outputs_schema` when the fault is upstream of it.
+     *
+     * It is refused rather than answered anonymously. The class list would resolve
+     * fine and the count would be correct; what would be lost is attribution, and
+     * "a detection whose producer cannot be named is a detection that cannot be
+     * attributed when a specialist later turns out to be wrong"
+     * (`deploy/detector/trillboards_detector/detections.py`).
+     */
+    readonly UNOWNED: "unowned";
+    /**
+     * The same field name appeared twice in the producer half.
+     *
+     * The first occurrence is answered and the rest are withheld, so the total
+     * contract holds over the input array exactly. A repeated field is the "one
+     * fact, two answers" defect at its smallest scale and it is worth a name.
+     */
+    readonly DUPLICATE: "duplicate";
+};
+export type ProducerWithholdReason = (typeof PRODUCER_WITHHOLD_REASONS)[keyof typeof PRODUCER_WITHHOLD_REASONS];
+export interface WithheldProducerField {
+    field: string;
+    modelId: string;
+    reason: ProducerWithholdReason;
+    detail: string;
+}
+/**
+ * One frame's answer.
+ *
+ * `produced.length + withheld.length === fields.length`. Always.
+ */
+export interface ProducedFieldSet {
+    produced: ProducedField[];
+    withheld: WithheldProducerField[];
+}
+/**
+ * The slice of a detector this producer uses.
+ *
+ * Picked off `LocalDetectorClient` itself rather than re-declared, so a change
+ * to `detect`'s signature breaks here too — and narrowed to the one method,
+ * because this producer never probes health. `DetectorShadowProbe` owns liveness
+ * and backoff; a producer that also had an opinion about when the service is up
+ * would be a second such opinion, and requiring an `isHealthy` stub in every
+ * test would imply one exists.
+ */
+export type DetectorFieldClient = Pick<LocalDetectorClient, 'detect'>;
+/** Builds a client for ONE model group's classes and operating point. */
+export type DetectorClientFactory = (options: {
+    classes: string[];
+    minConfidence: number;
+    timeoutMs: number;
+}) => DetectorFieldClient;
+/**
+ * The device's operating point when a model measured none of its own. 0.25.
+ *
+ * `LocalDetectorClient`'s default, and a FALLBACK rather than an answer — the
+ * same constant and the same caveat as
+ * `detectorCorpusEndpoint.DEFAULT_MIN_CONFIDENCE`. A model whose score card
+ * SELECTED a threshold must be counted at THAT threshold or the field is
+ * produced by a classifier no committed measurement describes: `gh_forklift_combine`
+ * fits 0.7435 and `rfdetr_medium`'s person gate 0.2939, and at 0.25 the
+ * published precision/recall simply do not apply to what shipped.
+ */
+export declare const DEFAULT_PRODUCER_MIN_CONFIDENCE = 0.25;
+/**
+ * Per-call transport timeout. 1000 ms, matching `DEFAULT_SHADOW_TIMEOUT_MS`.
+ *
+ * NOT `LocalDetectorClient`'s own 5 s default: this runs on the path to an
+ * analysis, and the detector's measured cost is ~63 ms p50 / ~79 ms p95, so
+ * 1000 ms is >12x headroom for the slowest plausible answer.
+ */
+export declare const DEFAULT_PRODUCER_TIMEOUT_MS = 1000;
+/**
+ * TOTAL budget across every model call for one frame. 1500 ms.
+ *
+ * A total and not a per-call bound, because the question it answers is "how long
+ * may producing this frame's fields hold the tick", and that is a property of
+ * the frame, not of one model. At the measured p95 a four-model portfolio costs
+ * ~316 ms, so this is ~4.7x headroom and cannot bind on a healthy box.
+ *
+ * When it DOES bind, the models that never got their call are withheld
+ * `detector_unavailable` — a missing field, which is the same discipline the
+ * 400 case gets and for the same reason. A budget that returned a value it did
+ * not measure would be worse than one that stalls.
+ *
+ * It bounds the number of calls STARTED and, via the per-call timeout below,
+ * how long each may sit idle. It does not close the one hole
+ * `LocalDetectorClient`'s header names — a server dribbling bytes slowly under a
+ * large Content-Length keeps the socket busy so the inactivity timer never fires
+ * — because that hole is in the transport and belongs to every client in this
+ * package; two call-site races for it already exist and a third is not the fix.
+ */
+export declare const DEFAULT_PRODUCE_DEADLINE_MS = 1500;
+/**
+ * The detector's canonical wire spelling.
+ *
+ * `normalize_class_name` in
+ * `deploy/detector/trillboards_detector/labels.py` is
+ * `name.strip().lower().replace("_", " ").replace("-", " ")`, and `labels.py`
+ * REFUSES to import a vocabulary whose names are not already folded — so this is
+ * the only spelling `/detect` resolves. A field carries its concept in the
+ * spelling a JSON key can hold (`fire_extinguisher`); the service is asked in
+ * the spelling it demands (`fire extinguisher`). One fold, one place.
+ *
+ * Byte-identical to `detectorCorpusEndpoint.toDetectorClassName`, deliberately:
+ * the corpus that GATES a model's rollout and the producer that READS it in the
+ * field must ask for the same class, or the thing measured is not the thing that
+ * ships.
+ */
+export declare const toDetectorClassName: (name: string) => string;
+/** The producible key shape: `<concept>_present`, `<concept>_count`. */
+export declare const CONCEPT_KEY_RE: RegExp;
+/**
+ * How the service joins the names of the models that answered one frame.
+ *
+ * `MODEL_JOIN` in `deploy/detector/trillboards_detector/server.py`, where
+ * `model` is `MODEL_JOIN.join(batch.models)` — one name on a single-model box, N
+ * for a request the registry split across several. Held here because the
+ * attribution check below has to take that string apart again, and a wrong
+ * separator would silently make every merged answer look unattributed.
+ */
+export declare const DETECTOR_MODEL_JOIN = "+";
+/** A producer field this detector can answer, once its name has been read. */
+export interface MappedProducerField extends ProducerField {
+    /** The concept, in the field's own identifier spelling. */
+    concept: string;
+    /** The class to ask for, in the service's wire spelling. */
+    className: string;
+    kind: 'present' | 'count';
+}
+/**
+ * Read a declared field name, or say why it cannot be read.
+ *
+ * The SUFFIX decides the computation — that is the vocabulary the corpus is
+ * written in and the only self-describing signal on the entry. The declared type
+ * is then checked AGAINST it rather than consulted instead of it: a null type is
+ * fine (plenty of registry rows carry none), and a type that contradicts the
+ * name is a defective row rather than an instruction.
+ */
+export declare function classifyProducerField(entry: ProducerField): MappedProducerField | {
+    reason: ProducerWithholdReason;
+    detail: string;
+};
+/**
+ * How many instances of each asked class this answer contains.
+ *
+ * Ported decision-for-decision from `detectorCorpusEndpoint.countsForConcepts`,
+ * because the corpus that gates a rollout and the producer that reads the model
+ * in the field must count the same way.
+ *
+ * @throws when the service returned a label nobody asked for — see below.
+ */
+export declare function countsForClasses(classes: string[], detections: Array<{
+    label: string;
+    confidence: number;
+}>, classThresholds?: Map<string, number>): Map<string, number>;
+export interface DetectorFieldProducerOptions {
+    /** Detector service base URL. Defaults to the client's loopback default. */
+    baseUrl?: string;
+    /** Per-call transport timeout. Default DEFAULT_PRODUCER_TIMEOUT_MS. */
+    timeoutMs?: number;
+    /** Total budget for one frame's calls. Default DEFAULT_PRODUCE_DEADLINE_MS. 0 disables. */
+    deadlineMs?: number;
+    /**
+     * Per-class operating points in WIRE spelling, as the models' own score cards
+     * fitted them — `modelClassLiveness.livenessFromScoreCard` writes them and
+     * `detectorCorpusEndpoint.thresholdsFromLivenessEvidence` folds them. A class
+     * with no entry is counted at `minConfidence`.
+     */
+    classThresholds?: Map<string, number>;
+    /** Floor for a class whose model measured none. Default DEFAULT_PRODUCER_MIN_CONFIDENCE. */
+    minConfidence?: number;
+    /** Clock injection for tests. Default Date.now. */
+    now?: () => number;
+}
+export declare class DetectorFieldProducer {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly deadlineMs;
+    private readonly classThresholds;
+    private readonly minConfidence;
+    private readonly now;
+    private readonly clientFor;
+    constructor(options?: DetectorFieldProducerOptions, clientFactory?: DetectorClientFactory);
+    /**
+     * Produce this frame's declared fields.
+     *
+     * NEVER THROWS and never returns a promise that rejects: it would sit on the
+     * path to the only thing that produces alerts, and a producer that can fail a
+     * capture tick is worse than one that reports it has no reading.
+     *
+     * @param jpeg   the frame's bytes
+     * @param fields the `producer` half of this profile's field partition
+     */
+    produce(jpeg: Buffer, fields: ProducerField[]): Promise<ProducedFieldSet>;
+    /**
+     * Every field of one model, withheld together.
+     *
+     * A model that did not answer did not answer for ANY of its fields. Booking
+     * them one at a time would invite a partial group, which is the collapse this
+     * whole file is written against.
+     */
+    private withholdGroup;
+}
+/** Flatten an answer to the `{field: value}` map a payload carries. */
+export declare function toFieldValues(produced: ProducedField[]): Record<string, ProducedFieldValue>;
+//# sourceMappingURL=DetectorFieldProducer.d.ts.map

package/dist/DetectorFieldProducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetectorFieldProducer.d.ts","sourceRoot":"","sources":["../src/DetectorFieldProducer.ts"],"names":[],"mappings":"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"}