@trillboards/edge-sdk 0.2.138 → 0.2.150

package/dist/VideoSegmentUploader.js

@@ -0,0 +1,1002 @@
+"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.CctvVideoRecorder = exports.VideoSegmentUploader = exports.defaultBlobPutter = exports.MAX_SEGMENT_BYTES = void 0;
+exports.putTimeoutMs = putTimeoutMs;
+exports.probeMp4File = probeMp4File;
+exports.hashFile = hashFile;
+exports.macHardwarePortType = macHardwarePortType;
+exports.hostUploadNetwork = hostUploadNetwork;
+exports.__resetHostUploadNetworkForTests = __resetHostUploadNetworkForTests;
+exports.attachCctvVideoRecorder = attachCctvVideoRecorder;
+exports.activeCctvVideoRecorders = activeCctvVideoRecorders;
+exports.__resetCctvVideoRecordersForTests = __resetCctvVideoRecordersForTests;
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const AudienceAnalyzeClient_1 = require("./AudienceAnalyzeClient");
+const enterpriseNetwork_1 = require("./enterpriseNetwork");
+const SensingProfileClient_1 = require("./SensingProfileClient");
+/** The route's ceiling on one segment: 256 MiB (268,435,456 bytes). */
+exports.MAX_SEGMENT_BYTES = 268435456;
+/** `PUT` budget floor, and the throughput it assumes: max(60 s, 2 x bytes / 125,000 B/s). */
+const PUT_TIMEOUT_FLOOR_MS = 60000;
+const PUT_ASSUMED_BYTES_PER_SEC = 125000;
+/** A PUT socket that moves nothing for this long is dead, whatever the total budget. */
+const PUT_IDLE_TIMEOUT_MS = 60000;
+const PRESIGN_PATH = '/v2/earner/video-segment-upload-url';
+const FINALIZE_PATH = '/v2/earner/video-segment-finalize';
+/** Finalize streams the whole blob back to hash it; give it the PUT's floor. */
+const FINALIZE_TIMEOUT_MS = 120000;
+const PRESIGN_TIMEOUT_MS = 30000;
+const DEFAULT_RETRY_BASE_MS = 5000;
+const DEFAULT_RETRY_MAX_MS = 15 * 60 * 1000;
+/** C4: `agent_version` is at most 32 characters. */
+const AGENT_VERSION_MAX = 32;
+/** `max(60 s, 2 x bytes / 125,000 B/s)`, in ms. */
+function putTimeoutMs(bytes) {
+    return Math.max(PUT_TIMEOUT_FLOOR_MS, Math.ceil(((2 * bytes) / PUT_ASSUMED_BYTES_PER_SEC) * 1000));
+}
+function childBoxes(buf, start, end) {
+    const out = [];
+    let o = start;
+    while (o + 8 <= end) {
+        let size = buf.readUInt32BE(o);
+        const type = buf.toString('latin1', o + 4, o + 8);
+        let header = 8;
+        if (size === 1) {
+            if (o + 16 > end)
+                break;
+            const big = buf.readBigUInt64BE(o + 8);
+            if (big > BigInt(Number.MAX_SAFE_INTEGER))
+                break;
+            size = Number(big);
+            header = 16;
+        }
+        else if (size === 0) {
+            size = end - o;
+        }
+        if (size < header || o + size > end)
+            break;
+        out.push({ type, start: o + header, end: o + size });
+        o += size;
+    }
+    return out;
+}
+function child(buf, parent, type) {
+    return childBoxes(buf, parent.start, parent.end).find((b) => b.type === type) ?? null;
+}
+const H264_ENTRIES = new Set(['avc1', 'avc3']);
+const HEVC_ENTRIES = new Set(['hvc1', 'hev1']);
+/** A moov larger than this is not one of our segments (300 s at 60 fps is ~0.3 MB of tables). */
+const MAX_MOOV_BYTES = 64 * 1024 * 1024;
+/** Read the video track out of a parsed `moov`. */
+function parseMoov(moov) {
+    const root = { type: 'moov', start: 0, end: moov.length };
+    let video = null;
+    let hasAudio = false;
+    for (const trak of childBoxes(moov, root.start, root.end).filter((b) => b.type === 'trak')) {
+        const mdia = child(moov, trak, 'mdia');
+        if (!mdia)
+            continue;
+        const hdlr = child(moov, mdia, 'hdlr');
+        if (!hdlr || hdlr.end - hdlr.start < 12)
+            continue;
+        const handler = moov.toString('latin1', hdlr.start + 8, hdlr.start + 12);
+        if (handler === 'soun') {
+            hasAudio = true;
+            continue;
+        }
+        if (handler !== 'vide' || video)
+            continue;
+        const mdhd = child(moov, mdia, 'mdhd');
+        const stbl = (() => {
+            const minf = child(moov, mdia, 'minf');
+            return minf ? child(moov, minf, 'stbl') : null;
+        })();
+        if (!mdhd || !stbl)
+            return null;
+        const v1 = moov[mdhd.start] === 1;
+        const timescale = moov.readUInt32BE(mdhd.start + (v1 ? 20 : 12));
+        const mdhdDuration = v1 ? Number(moov.readBigUInt64BE(mdhd.start + 24)) : moov.readUInt32BE(mdhd.start + 16);
+        const stsd = child(moov, stbl, 'stsd');
+        const stts = child(moov, stbl, 'stts');
+        const stsz = child(moov, stbl, 'stsz');
+        if (!stsd || !stts || !stsz || timescale <= 0)
+            return null;
+        const entry = stsd.start + 8;
+        if (entry + 36 > stsd.end)
+            return null;
+        const sampleEntry = moov.toString('latin1', entry + 4, entry + 8);
+        const width = moov.readUInt16BE(entry + 32);
+        const height = moov.readUInt16BE(entry + 34);
+        let frames = 0;
+        let ticks = 0;
+        const sttsCount = moov.readUInt32BE(stts.start + 4);
+        for (let i = 0; i < sttsCount; i += 1) {
+            const at = stts.start + 8 + i * 8;
+            if (at + 8 > stts.end)
+                return null;
+            const count = moov.readUInt32BE(at);
+            frames += count;
+            ticks += count * moov.readUInt32BE(at + 4);
+        }
+        const sampleSize = moov.readUInt32BE(stsz.start + 4);
+        const sampleCount = moov.readUInt32BE(stsz.start + 8);
+        let videoBytes = 0;
+        if (sampleSize !== 0) {
+            videoBytes = sampleSize * sampleCount;
+        }
+        else {
+            if (stsz.start + 12 + sampleCount * 4 > stsz.end)
+                return null;
+            for (let i = 0; i < sampleCount; i += 1)
+                videoBytes += moov.readUInt32BE(stsz.start + 12 + i * 4);
+        }
+        const durationTicks = ticks > 0 ? ticks : mdhdDuration;
+        const durationMs = (durationTicks / timescale) * 1000;
+        if (frames <= 0 || durationMs <= 0 || width <= 0 || height <= 0)
+            return null;
+        video = {
+            codec: H264_ENTRIES.has(sampleEntry) ? 'h264' : HEVC_ENTRIES.has(sampleEntry) ? 'hevc' : sampleEntry.toLowerCase(),
+            sampleEntry,
+            width,
+            height,
+            frames,
+            durationMs,
+            fps: frames / (durationMs / 1000),
+            videoBytes,
+            hasAudio: false,
+        };
+    }
+    return video ? { ...video, hasAudio } : null;
+}
+/**
+ * A CLOSED MP4 with a video track, measured from its own boxes — or null.
+ *
+ * Null is the "never upload this" answer: a file whose top-level boxes run
+ * past its end, or that has no `moov`, is a segment ffmpeg was still writing
+ * (measured: a SIGTERM'd segment is mdat with no moov). It is the last gate
+ * between a partial file and the corpus, after the provider's list check.
+ */
+function probeMp4File(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const head = Buffer.alloc(16);
+        let offset = 0;
+        let moov = null;
+        while (offset + 8 <= size) {
+            const n = fs.readSync(fd, head, 0, 16, offset);
+            if (n < 8)
+                return null;
+            let boxSize = head.readUInt32BE(0);
+            const type = head.toString('latin1', 4, 8);
+            let header = 8;
+            if (boxSize === 1) {
+                if (n < 16)
+                    return null;
+                const big = head.readBigUInt64BE(8);
+                if (big > BigInt(Number.MAX_SAFE_INTEGER))
+                    return null;
+                boxSize = Number(big);
+                header = 16;
+            }
+            else if (boxSize === 0) {
+                boxSize = size - offset;
+            }
+            if (boxSize < header || offset + boxSize > size)
+                return null;
+            if (type === 'moov') {
+                if (boxSize - header > MAX_MOOV_BYTES)
+                    return null;
+                moov = Buffer.alloc(boxSize - header);
+                if (fs.readSync(fd, moov, 0, moov.length, offset + header) !== moov.length)
+                    return null;
+            }
+            offset += boxSize;
+        }
+        if (offset !== size || !moov)
+            return null;
+        return parseMoov(moov);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** SHA-256 (hex, the segment_id) and MD5 (base64, Content-MD5) in one read. */
+function hashFile(file) {
+    return new Promise((resolve, reject) => {
+        const sha = (0, crypto_1.createHash)('sha256');
+        const md5 = (0, crypto_1.createHash)('md5');
+        let bytes = 0;
+        const stream = fs.createReadStream(file, { highWaterMark: 1 << 20 });
+        stream.on('data', (chunk) => {
+            const buf = chunk;
+            sha.update(buf);
+            md5.update(buf);
+            bytes += buf.length;
+        });
+        stream.on('error', reject);
+        stream.on('end', () => resolve({ sha256: sha.digest('hex'), md5Base64: md5.digest('base64'), bytes }));
+    });
+}
+/** The URL without its query: a presigned URL's query IS the credential. */
+function redactSignedUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.protocol}//${u.host}${u.pathname}`;
+    }
+    catch {
+        return '[unparseable upload URL]';
+    }
+}
+/**
+ * Stream a file into a presigned PUT. Never buffers the file: a 256 MiB
+ * segment costs one 64 KB read buffer. Bounded twice — a total budget
+ * (`putTimeoutMs`) and an idle socket timeout — because a stalled upload must
+ * not hold the queue past the URL's own lifetime.
+ */
+const defaultBlobPutter = (url, file, options) => new Promise((resolve, reject) => {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch (err) {
+        reject(new Error(`invalid upload URL: ${err.message}`));
+        return;
+    }
+    const isHttps = parsed.protocol === 'https:';
+    const mod = isHttps ? https : http;
+    const baseOptions = {
+        method: 'PUT',
+        headers: {
+            'Content-Type': options.contentType,
+            'Content-Length': String(options.bytes),
+            // Azure checks the block against this and refuses a mismatch (400).
+            'Content-MD5': options.contentMd5,
+        },
+        timeout: PUT_IDLE_TIMEOUT_MS,
+        ...(isHttps ? { agent: (0, enterpriseNetwork_1.getEnterpriseAgent)() } : {}),
+    };
+    const proxied = isHttps
+        ? { options: baseOptions, proxyUrl: null }
+        : (0, enterpriseNetwork_1.applyHttpProxy)(url, baseOptions);
+    const target = redactSignedUrl(url);
+    let settled = false;
+    const source = fs.createReadStream(file);
+    const finish = (fn) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(deadline);
+        fn();
+    };
+    const fail = (err) => finish(() => {
+        source.destroy();
+        req.destroy();
+        reject((0, enterpriseNetwork_1.diagnoseTransportError)(err, target));
+    });
+    const deadline = setTimeout(() => fail(new Error(`video segment upload exceeded ${options.timeoutMs} ms`)), options.timeoutMs);
+    if (typeof deadline.unref === 'function')
+        deadline.unref();
+    const onResponse = (res) => {
+        const chunks = [];
+        let kept = 0;
+        res.on('data', (chunk) => {
+            if (kept < 4096) {
+                chunks.push(chunk);
+                kept += chunk.length;
+            }
+        });
+        res.on('end', () => finish(() => resolve({ statusCode: res.statusCode || 0, body: Buffer.concat(chunks).toString('utf8').slice(0, 4096) })));
+        res.once('error', (err) => fail(err));
+        res.once('aborted', () => fail(new Error('video segment upload response aborted')));
+    };
+    const req = proxied.proxyUrl
+        ? mod.request(proxied.options, onResponse)
+        : mod.request(url, baseOptions, onResponse);
+    req.on('error', (err) => fail(err));
+    req.on('timeout', () => req.destroy(new Error('video segment upload stalled')));
+    source.on('error', (err) => fail(err));
+    source.pipe(req);
+});
+exports.defaultBlobPutter = defaultBlobPutter;
+// ---------------------------------------------------------------------------
+// The host's own network, as its platform reports it
+// ---------------------------------------------------------------------------
+/** How long the host's network answer is reused: the uplink of a fixed box changes on IT timescales. */
+const NETWORK_CACHE_MS = 10 * 60 * 1000;
+let cachedNetwork = null;
+function normalizeNetwork(value) {
+    return value === 'wifi' || value === 'ethernet' || value === 'cellular' ? value : 'unknown';
+}
+function execText(cmd, args, timeoutMs) {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(cmd, args, { timeout: timeoutMs, windowsHide: true }, (err, stdout) => {
+            resolve(err ? '' : String(stdout || ''));
+        });
+    });
+}
+/**
+ * macOS: the default route's interface, named by `networksetup`'s hardware
+ * port list (`Hardware Port: Wi-Fi` / `Device: en0`).
+ */
+function macHardwarePortType(hardwarePorts, iface) {
+    for (const block of hardwarePorts.split(/\n\s*\n/)) {
+        const port = /Hardware Port:\s*(.+)/.exec(block)?.[1]?.trim() ?? '';
+        const device = /Device:\s*(\S+)/.exec(block)?.[1]?.trim() ?? '';
+        if (device !== iface)
+            continue;
+        if (/wi-?fi|airport/i.test(port))
+            return 'wifi';
+        if (/iphone|cellular|wwan|modem/i.test(port))
+            return 'cellular';
+        if (/ethernet|lan|thunderbolt/i.test(port))
+            return 'ethernet';
+        return 'unknown';
+    }
+    return 'unknown';
+}
+async function probeHostNetwork() {
+    if (process.platform === 'linux') {
+        // The adapter reads /sys/class/net only — no subprocess.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { LinuxPlatformAdapter } = require('@trillboards/edge-platform-linux');
+        return normalizeNetwork(new LinuxPlatformAdapter().getNetworkType());
+    }
+    if (process.platform === 'win32') {
+        // The adapter's own query, run asynchronously (its getNetworkType blocks the
+        // event loop on PowerShell for seconds), parsed by the adapter's parser.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { WindowsPlatformAdapter } = require('@trillboards/edge-platform-windows');
+        const out = await execText('powershell', [
+            '-NoProfile',
+            '-Command',
+            'Get-NetAdapter | Where-Object Status -eq Up | Select-Object -Property Name, InterfaceDescription, MediaType | ConvertTo-Json',
+        ], 5000);
+        return out ? normalizeNetwork(WindowsPlatformAdapter.parseNetworkType(out)) : 'unknown';
+    }
+    if (process.platform === 'darwin') {
+        const route = await execText('route', ['-n', 'get', 'default'], 3000);
+        const iface = /interface:\s*(\S+)/.exec(route)?.[1];
+        if (!iface)
+            return 'unknown';
+        return macHardwarePortType(await execText('networksetup', ['-listallhardwareports'], 3000), iface);
+    }
+    return 'unknown';
+}
+/** The host's uplink type, cached. Any probe failure is 'unknown', never a guess. */
+async function hostUploadNetwork(nowMs = Date.now()) {
+    if (cachedNetwork && nowMs - cachedNetwork.atMs < NETWORK_CACHE_MS)
+        return cachedNetwork.value;
+    let value;
+    try {
+        value = await probeHostNetwork();
+    }
+    catch {
+        value = 'unknown';
+    }
+    cachedNetwork = { value, atMs: nowMs };
+    return value;
+}
+/** Test seam. */
+function __resetHostUploadNetworkForTests() {
+    cachedNetwork = null;
+}
+// ---------------------------------------------------------------------------
+// The uploader
+// ---------------------------------------------------------------------------
+/** The connector's own version — what `agent_version` names for a CCTV segment. */
+function connectorVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return String(require('../package.json').version || '');
+    }
+    catch {
+        return '';
+    }
+}
+class VideoSegmentUploader {
+    constructor(options) {
+        this.queue = [];
+        this.inFlight = null;
+        this.draining = false;
+        this.timer = null;
+        this.stopped = false;
+        this.stats = {
+            queued: 0,
+            inFlight: false,
+            uploaded: 0,
+            uploadedBytes: 0,
+            uploadedSeconds: 0,
+            rejected: {},
+            invalid: 0,
+            unsupportedCodec: 0,
+            oversize: 0,
+            missing: 0,
+            failures: { presign: 0, put: 0, finalize: 0 },
+            lastStatus: null,
+            lastError: null,
+            lastUploadAtMs: null,
+        };
+        if (!options.apiBaseUrl)
+            throw new Error('apiBaseUrl is required for VideoSegmentUploader');
+        if (!options.deviceToken)
+            throw new Error('deviceToken is required for VideoSegmentUploader');
+        this.apiBase = options.apiBaseUrl.replace(/\/+$/, '');
+        this.deviceToken = options.deviceToken;
+        this.agentVersion = (options.agentVersion ?? connectorVersion()).slice(0, AGENT_VERSION_MAX);
+        this.poster = options.poster ?? AudienceAnalyzeClient_1.defaultHttpPoster;
+        this.putBlob = options.putBlob ?? exports.defaultBlobPutter;
+        this.network = options.network ?? (() => hostUploadNetwork());
+        this.probe = options.probe ?? probeMp4File;
+        this.now = options.now ?? Date.now;
+        this.retryBaseMs = Math.max(0, options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS);
+        this.retryMaxMs = Math.max(this.retryBaseMs, options.retryMaxMs ?? DEFAULT_RETRY_MAX_MS);
+        this.log = options.log ?? ((level, message) => (level === 'warn' ? console.warn : console.log)(message));
+    }
+    /** Queue a closed segment. Oldest capture first; a file already queued is ignored. */
+    enqueue(segment) {
+        if (this.stopped || !segment?.file)
+            return;
+        if (this.inFlight?.segment.file === segment.file)
+            return;
+        if (this.queue.some((item) => item.segment.file === segment.file))
+            return;
+        this.queue.push({ segment, attempts: 0, nextAtMs: this.now(), phase: 'upload' });
+        this.queue.sort((a, b) => a.segment.captureStartMs - b.segment.captureStartMs);
+        this.kick();
+    }
+    /** The ring deleted this file; stop trying to deliver it. */
+    forget(file) {
+        const i = this.queue.findIndex((item) => item.segment.file === file);
+        if (i < 0)
+            return;
+        this.queue.splice(i, 1);
+        this.stats.missing += 1;
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    getStats() {
+        return {
+            ...this.stats,
+            queued: this.queue.length,
+            inFlight: this.inFlight !== null,
+            rejected: { ...this.stats.rejected },
+            failures: { ...this.stats.failures },
+        };
+    }
+    /** Deliver every item that is due now, one at a time. Resolves when none is due. */
+    async flush() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            for (;;) {
+                if (this.stopped)
+                    break;
+                const nowMs = this.now();
+                const i = this.queue.findIndex((item) => item.nextAtMs <= nowMs);
+                if (i < 0)
+                    break;
+                const [item] = this.queue.splice(i, 1);
+                this.inFlight = item;
+                let outcome;
+                try {
+                    outcome = await this.deliver(item);
+                }
+                catch (err) {
+                    this.stats.lastError = errorText(err);
+                    outcome = 'retry';
+                }
+                finally {
+                    this.inFlight = null;
+                }
+                if (outcome === 'retry' && !this.stopped) {
+                    item.attempts += 1;
+                    item.nextAtMs = this.now() + Math.min(this.retryMaxMs, this.retryBaseMs * 2 ** Math.min(item.attempts - 1, 20));
+                    this.queue.push(item);
+                    this.queue.sort((a, b) => a.segment.captureStartMs - b.segment.captureStartMs);
+                }
+            }
+        }
+        finally {
+            this.draining = false;
+            this.kick();
+        }
+    }
+    kick() {
+        if (this.stopped || this.draining || this.queue.length === 0)
+            return;
+        const due = Math.min(...this.queue.map((item) => item.nextAtMs));
+        const delay = Math.max(0, due - this.now());
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flush();
+        }, delay);
+        if (typeof this.timer.unref === 'function')
+            this.timer.unref();
+    }
+    /** One attempt at one segment: presign → PUT → finalize, resuming at finalize. */
+    async deliver(item) {
+        const { segment } = item;
+        let bytes;
+        try {
+            bytes = fs.statSync(segment.file).size;
+        }
+        catch {
+            this.stats.missing += 1;
+            return 'done';
+        }
+        if (!item.probe) {
+            const probe = this.probe(segment.file);
+            if (!probe) {
+                this.stats.invalid += 1;
+                this.discard(segment, 'not a complete MP4 with a video track');
+                return 'done';
+            }
+            if (probe.codec !== 'h264' && probe.codec !== 'hevc') {
+                this.stats.unsupportedCodec += 1;
+                this.discard(segment, `codec ${probe.codec} is not h264 or hevc`);
+                return 'done';
+            }
+            item.probe = probe;
+        }
+        if (bytes < 1 || bytes > exports.MAX_SEGMENT_BYTES) {
+            this.stats.oversize += 1;
+            this.discard(segment, `${bytes} bytes is outside 1..${exports.MAX_SEGMENT_BYTES}`);
+            return 'done';
+        }
+        if (!item.hash || item.hash.bytes !== bytes) {
+            item.hash = await hashFile(segment.file);
+            item.phase = 'upload';
+        }
+        const { sha256, md5Base64 } = item.hash;
+        const captureStartMs = Math.round(segment.captureStartMs);
+        if (item.phase === 'upload') {
+            const presign = await this.postJson(PRESIGN_PATH, { segment_id: sha256, bytes, content_type: 'video/mp4', capture_start_ms: captureStartMs }, PRESIGN_TIMEOUT_MS);
+            const uploadUrl = presign.body?.uploadUrl;
+            if (presign.statusCode !== 200 || typeof uploadUrl !== 'string' || !uploadUrl) {
+                this.stats.failures.presign += 1;
+                this.noteFailure('presign', presign.statusCode, presign.rawBody);
+                return 'retry';
+            }
+            let put;
+            try {
+                put = await this.putBlob(uploadUrl, segment.file, {
+                    bytes,
+                    contentMd5: md5Base64,
+                    contentType: 'video/mp4',
+                    timeoutMs: putTimeoutMs(bytes),
+                });
+            }
+            catch (err) {
+                this.stats.failures.put += 1;
+                this.noteFailure('put', null, errorText(err));
+                return 'retry';
+            }
+            if (put.statusCode < 200 || put.statusCode >= 300) {
+                this.stats.failures.put += 1;
+                this.noteFailure('put', put.statusCode, put.body);
+                return 'retry';
+            }
+            item.phase = 'finalize';
+        }
+        const network = normalizeNetwork(await (async () => this.network())().catch(() => 'unknown'));
+        const finalize = await this.postJson(FINALIZE_PATH, this.finalizeBody(item, bytes, network), FINALIZE_TIMEOUT_MS);
+        this.stats.lastStatus = finalize.statusCode;
+        if (finalize.statusCode === 200) {
+            this.stats.uploaded += 1;
+            this.stats.uploadedBytes += bytes;
+            this.stats.uploadedSeconds += item.probe.durationMs / 1000;
+            this.stats.lastUploadAtMs = this.now();
+            this.deleteLocal(segment);
+            return 'done';
+        }
+        if (finalize.statusCode === 422) {
+            // The server read different bytes than we hashed and deleted the blob.
+            const reason = typeof finalize.body?.reason === 'string' ? finalize.body.reason : 'unprocessable';
+            this.stats.rejected[reason] = (this.stats.rejected[reason] ?? 0) + 1;
+            this.log('warn', `[video] ${path.basename(segment.file)} rejected at finalize (${reason}); deleted locally`);
+            this.deleteLocal(segment);
+            return 'done';
+        }
+        this.stats.failures.finalize += 1;
+        this.noteFailure('finalize', finalize.statusCode, finalize.rawBody);
+        // 409 not_uploaded: the blob is not there — PUT again. Anything else
+        // (503 index_unavailable, transport): finalize again; the blob stays.
+        if (finalize.statusCode === 409)
+            item.phase = 'upload';
+        return 'retry';
+    }
+    /** C4, snake_case. Server-authoritative fields (screen, device, source, key) are never sent. */
+    finalizeBody(item, bytes, network) {
+        const probe = item.probe;
+        const hash = item.hash;
+        const durationMs = Math.round(probe.durationMs);
+        return {
+            segment_id: hash.sha256,
+            bytes,
+            content_md5: hash.md5Base64,
+            capture_start_ms: Math.round(item.segment.captureStartMs),
+            capture_end_ms: Math.round(item.segment.captureEndMs),
+            duration_ms: durationMs,
+            codec: probe.codec,
+            width: probe.width,
+            height: probe.height,
+            fps: Math.round(probe.fps * 1000) / 1000,
+            video_bitrate_bps: Math.round((probe.videoBytes * 8) / (probe.durationMs / 1000)),
+            has_audio: probe.hasAudio,
+            audio_codec: null,
+            audio_bitrate_bps: null,
+            trigger_kind: 'continuous',
+            trigger_id: '',
+            agent_version: this.agentVersion,
+            calibration_hash: null,
+            // No fix on a fixed camera: the server fills the registered location.
+            gps_lat: null,
+            gps_lon: null,
+            gps_accuracy_m: null,
+            gps_fix_at_ms: null,
+            upload_network: network,
+        };
+    }
+    async postJson(routePath, payload, timeoutMs) {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            // Device-request auth + replay guard (see middleware/deviceRequestAuth.js).
+            'X-Device-Token': this.deviceToken,
+            'X-Trillboard-Device-Token': this.deviceToken,
+            'X-Device-Timestamp': String(Date.now()),
+            'X-Device-Nonce': (0, crypto_1.randomUUID)(),
+        };
+        let result;
+        try {
+            result = await this.poster(`${this.apiBase}${routePath}`, { method: 'POST', headers, timeoutMs }, JSON.stringify(payload));
+        }
+        catch (err) {
+            return { statusCode: 0, body: null, rawBody: errorText(err) };
+        }
+        let body = null;
+        try {
+            body = result.body ? JSON.parse(result.body) : null;
+        }
+        catch {
+            body = null;
+        }
+        return { statusCode: result.statusCode, body, rawBody: result.body };
+    }
+    noteFailure(phase, status, detail) {
+        this.stats.lastStatus = status;
+        this.stats.lastError = `${phase}${status !== null ? ` HTTP ${status}` : ''}: ${String(detail || '').slice(0, 300)}`;
+    }
+    discard(segment, why) {
+        this.log('warn', `[video] ${path.basename(segment.file)} not uploaded: ${why}; deleted locally`);
+        this.deleteLocal(segment);
+    }
+    deleteLocal(segment) {
+        for (const file of [segment.file, segment.metaFile ?? segment.file.replace(/\.mp4$/i, '.json')]) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch {
+                /* already gone (the ring may have taken it) */
+            }
+        }
+    }
+}
+exports.VideoSegmentUploader = VideoSegmentUploader;
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Seconds in a UTC day: a budget at or above it is continuous recording. */
+const SECONDS_PER_DAY = 86400;
+/**
+ * The segment length and ring the provider holds before the server has ever
+ * answered. Recording is OFF until it does; these only size the ring that
+ * leftovers from an earlier run sit in. They mirror the runtime_config seeds
+ * CCTV_VIDEO_SEGMENT_SECONDS '60' and CCTV_VIDEO_RING_SECONDS '3600'.
+ */
+const UNANSWERED_SEGMENT_SECONDS = 60;
+const UNANSWERED_RING_SECONDS = 3600;
+/** Same cadence as the local profile cache (`DEFAULT_PROFILE_TTL_MS`). */
+const DEFAULT_KNOB_POLL_MS = 5 * 60 * 1000;
+const KNOBS_FILE = 'video-knobs.json';
+const DAILY_FILE = 'video-daily.json';
+function utcDay(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+function writeJsonAtomic(file, value) {
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value));
+    fs.renameSync(tmp, file);
+}
+function sameKnobs(a, b) {
+    return !!a && a.dailySeconds === b.dailySeconds && a.segmentSeconds === b.segmentSeconds && a.ringSeconds === b.ringSeconds;
+}
+/**
+ * One per recording feed. Applies the server's knobs to the provider, keeps
+ * a per-UTC-day recorded-seconds budget, and hands every closed segment to
+ * the uploader.
+ *
+ * Knobs follow the deployedCadenceSource rule: a failed fetch, an API that
+ * does not send `video`, and an unreadable `video` all KEEP the last applied
+ * value — persisted beside the segments, so a restart with the API down
+ * records exactly as before. Until the server has ever answered, recording is
+ * off. Everything starts at the provider's first `open()`, so a recorder that
+ * is built and never opened makes no request and writes nothing.
+ */
+class CctvVideoRecorder {
+    constructor(options) {
+        this.knobs = null;
+        this.daily = { day: '', recordedSeconds: 0 };
+        this.recording = false;
+        this.started = false;
+        this.stopped = false;
+        this.pollTimer = null;
+        this.dayTimer = null;
+        this.counts = { polls: 0, keptOnFailedFetch: 0, keptOnSilence: 0, keptOnMalformed: 0 };
+        this.provider = options.provider;
+        this.dir = options.dir;
+        this.feedName = options.feedName;
+        this.profileClient = options.profileClient;
+        this.uploader = options.uploader;
+        this.pollMs = Math.max(1000, options.pollMs ?? DEFAULT_KNOB_POLL_MS);
+        this.now = options.now ?? Date.now;
+        this.log = options.log ?? ((level, message) => (level === 'warn' ? console.warn : console.log)(message));
+        this.provider.on('segment', (segment) => this.onSegment(segment));
+        this.provider.on('segment_evicted', (evicted) => this.uploader.forget(evicted.file));
+        this.provider.on('opening', () => this.start());
+    }
+    /** Idempotent. Runs synchronously inside the provider's `open()`. */
+    start() {
+        if (this.started || this.stopped)
+            return;
+        this.started = true;
+        this.loadState();
+        this.apply();
+        void this.poll();
+        this.pollTimer = setInterval(() => void this.poll(), this.pollMs);
+        if (typeof this.pollTimer.unref === 'function')
+            this.pollTimer.unref();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.pollTimer)
+            clearInterval(this.pollTimer);
+        if (this.dayTimer)
+            clearTimeout(this.dayTimer);
+        this.pollTimer = null;
+        this.dayTimer = null;
+        this.uploader.stop();
+    }
+    getStats() {
+        return {
+            knobs: this.knobs ? { ...this.knobs } : null,
+            recording: this.recording,
+            day: this.daily.day,
+            recordedSecondsToday: Math.round(this.daily.recordedSeconds * 1000) / 1000,
+            polls: this.counts.polls,
+            keptOnFailedFetch: this.counts.keptOnFailedFetch,
+            keptOnSilence: this.counts.keptOnSilence,
+            keptOnMalformed: this.counts.keptOnMalformed,
+        };
+    }
+    /** One knob fetch. Only an explicit, readable `video` block changes anything. */
+    async poll() {
+        if (this.stopped)
+            return;
+        this.counts.polls += 1;
+        let profile;
+        try {
+            profile = await this.profileClient.fetchProfile();
+        }
+        catch {
+            profile = null;
+        }
+        if (!profile) {
+            this.counts.keptOnFailedFetch += 1;
+            return;
+        }
+        if (profile.video === undefined) {
+            this.counts.keptOnSilence += 1;
+            return;
+        }
+        if (profile.video === null) {
+            this.counts.keptOnMalformed += 1;
+            return;
+        }
+        if (sameKnobs(this.knobs, profile.video))
+            return;
+        this.knobs = { ...profile.video };
+        this.persist(KNOBS_FILE, { version: 1, ...this.knobs, appliedAtMs: this.now() });
+        this.log('info', `[video] ${this.feedName}: ${this.knobs.dailySeconds}s/day, ${this.knobs.segmentSeconds}s segments, ring ${this.knobs.ringSeconds}s`);
+        this.apply();
+    }
+    apply() {
+        if (this.stopped)
+            return;
+        this.rollDay();
+        const k = this.knobs;
+        if (!k) {
+            this.recording = false;
+            this.provider.setSegmentRecording({
+                dir: this.dir,
+                segmentSeconds: UNANSWERED_SEGMENT_SECONDS,
+                ringSeconds: UNANSWERED_RING_SECONDS,
+                enabled: false,
+            });
+            return;
+        }
+        const budgetLeft = k.dailySeconds >= SECONDS_PER_DAY || this.daily.recordedSeconds < k.dailySeconds;
+        this.recording = k.dailySeconds > 0 && budgetLeft;
+        this.provider.setSegmentRecording({
+            dir: this.dir,
+            segmentSeconds: k.segmentSeconds,
+            ringSeconds: k.ringSeconds,
+            enabled: this.recording,
+        });
+        if (k.dailySeconds > 0 && !budgetLeft)
+            this.scheduleNextDay();
+    }
+    onSegment(segment) {
+        if (!segment.recovered) {
+            this.rollDay();
+            this.daily.recordedSeconds += Math.max(0, segment.endSec - segment.startSec);
+            this.persist(DAILY_FILE, this.daily);
+            const k = this.knobs;
+            if (this.recording && k && k.dailySeconds < SECONDS_PER_DAY && this.daily.recordedSeconds >= k.dailySeconds) {
+                this.log('info', `[video] ${this.feedName}: today's ${k.dailySeconds}s recorded; resuming at 00:00 UTC`);
+                this.apply();
+            }
+        }
+        this.uploader.enqueue(segment);
+    }
+    rollDay() {
+        const day = utcDay(this.now());
+        if (day !== this.daily.day)
+            this.daily = { day, recordedSeconds: 0 };
+    }
+    scheduleNextDay() {
+        if (this.dayTimer)
+            return;
+        const nowMs = this.now();
+        const nextDayMs = Date.UTC(new Date(nowMs).getUTCFullYear(), new Date(nowMs).getUTCMonth(), new Date(nowMs).getUTCDate() + 1);
+        this.dayTimer = setTimeout(() => {
+            this.dayTimer = null;
+            this.apply();
+        }, Math.max(1000, nextDayMs - nowMs + 1000));
+        if (typeof this.dayTimer.unref === 'function')
+            this.dayTimer.unref();
+    }
+    loadState() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(path.join(this.dir, KNOBS_FILE), 'utf8'));
+            const ok = [raw?.dailySeconds, raw?.segmentSeconds, raw?.ringSeconds].every((n) => Number.isInteger(n) && n >= 0);
+            if (ok && raw.segmentSeconds > 0) {
+                this.knobs = { dailySeconds: raw.dailySeconds, segmentSeconds: raw.segmentSeconds, ringSeconds: raw.ringSeconds };
+            }
+        }
+        catch {
+            /* never answered on this box */
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(path.join(this.dir, DAILY_FILE), 'utf8'));
+            if (typeof raw?.day === 'string' && Number.isFinite(raw?.recordedSeconds) && raw.recordedSeconds >= 0) {
+                this.daily = { day: raw.day, recordedSeconds: raw.recordedSeconds };
+            }
+        }
+        catch {
+            /* first day */
+        }
+    }
+    persist(name, value) {
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            writeJsonAtomic(path.join(this.dir, name), value);
+        }
+        catch (err) {
+            this.log('warn', `[video] ${this.feedName}: could not save ${name}: ${errorText(err)}`);
+        }
+    }
+}
+exports.CctvVideoRecorder = CctvVideoRecorder;
+// ---------------------------------------------------------------------------
+// Wiring: one recorder per recording feed, one per directory
+// ---------------------------------------------------------------------------
+const recordersByDir = new Map();
+/**
+ * Attach a recorder to a freshly built provider. Returns null — and records
+ * nothing — when the installed edge-platform-rtsp predates segment recording
+ * (edge-sdk accepts any `^0.2.0`). A second recorder for the same directory
+ * replaces the first, so two managers can never deliver one ring twice.
+ */
+function attachCctvVideoRecorder(args) {
+    const provider = args.provider;
+    if (!provider || typeof provider.setSegmentRecording !== 'function' || typeof provider.on !== 'function') {
+        return null;
+    }
+    const uploader = new VideoSegmentUploader({
+        apiBaseUrl: args.apiBaseUrl,
+        deviceToken: args.deviceToken,
+        ...(args.httpPoster ? { poster: args.httpPoster } : {}),
+    });
+    const profileClient = new SensingProfileClient_1.SensingProfileClient({ apiBaseUrl: args.apiBaseUrl, deviceToken: args.deviceToken }, args.httpPoster);
+    const recorder = new CctvVideoRecorder({
+        provider: provider,
+        dir: args.dir,
+        feedName: args.feedName,
+        profileClient,
+        uploader,
+        ...(args.pollMs !== undefined ? { pollMs: args.pollMs } : {}),
+    });
+    const previous = recordersByDir.get(args.dir);
+    if (previous)
+        previous.stop();
+    recordersByDir.set(args.dir, recorder);
+    return recorder;
+}
+/** Every attached recorder, for diagnostics. */
+function activeCctvVideoRecorders() {
+    return [...recordersByDir.entries()].map(([dir, recorder]) => ({ dir, recorder }));
+}
+/** Test seam. */
+function __resetCctvVideoRecordersForTests() {
+    for (const recorder of recordersByDir.values())
+        recorder.stop();
+    recordersByDir.clear();
+}
+//# sourceMappingURL=VideoSegmentUploader.js.map