@camstack/types 1.2.393 → 1.2.394

package/dist/geometry/subject-path.d.ts

@@ -0,0 +1,104 @@
+/**
+ * subject-path — the ONE geometry of "where did this subject go": the path a
+ * track's positions draw over a frame.
+ *
+ * Two surfaces draw it: the event detail of the debug views (admin-ui, an SVG
+ * over the hero frame) and the notification picture (addon-post-analysis, an
+ * SVG burnt into the JPEG by `sharp`, when a rule sets
+ * `media.showSubjectPath`). They must draw the SAME line for the same track,
+ * so the point list, its simplification and the mapping into a crop live here
+ * once. `@camstack/ui-library` re-exports this module for the UI side.
+ *
+ * It lives in `@camstack/types` and not in ui-library because the server
+ * addon that renders the notification picture cannot take ui-library (a React
+ * bundle for the browser), while `@camstack/types` is already the
+ * framework-free contract every side imports — the hub, the admin UI and the
+ * viewer (`@camstack/types/client`). No React, no DOM, no `sharp`: pure.
+ *
+ * ## Space
+ *
+ * Every input and output here is NORMALISED 0..1 in the frame the positions
+ * were captured in. A caller holding pixel positions divides by that frame
+ * first (the detection frame, never a native-res image it happens to show —
+ * the two share the aspect, which is what makes one normalised path land on
+ * both).
+ *
+ * ## Honesty rules (from real tracks, device 615, 2026-08-02)
+ *
+ *  - A near-FULL-FRAME box is a motion placeholder, not a localisation: its
+ *    centre is an artefact, so it is never a path point (it is counted).
+ *  - A still subject repeats one box many times; consecutive samples closer
+ *    than {@link SUBJECT_PATH_DWELL_EPS} collapse into one node carrying the
+ *    count and the time span. The path always ENDS on the last sample.
+ *  - A long track is downsampled to {@link SUBJECT_PATH_MAX_POINTS}, first and
+ *    last kept.
+ *  - Fewer than two nodes is no path: a caller draws nothing.
+ */
+/** A rectangle in normalised 0..1 space. */
+export interface SubjectPathRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** A point in normalised 0..1 space. */
+export interface SubjectPathPoint {
+    readonly x: number;
+    readonly y: number;
+}
+/** One position of the subject: its normalised CENTRE, the box extent when known, the instant. */
+export interface SubjectPathSample {
+    readonly x: number;
+    readonly y: number;
+    /** Normalised box width — absent when only the centre is known. */
+    readonly w?: number;
+    /** Normalised box height — absent when only the centre is known. */
+    readonly h?: number;
+    /** Capture instant (ms). Absent = order of the input. */
+    readonly timestamp?: number;
+}
+/** One drawn node: a normalised centre and the samples that collapsed into it. */
+export interface SubjectPathNode extends SubjectPathPoint {
+    readonly samples: number;
+    readonly firstTs: number;
+    readonly lastTs: number;
+}
+/** The drawable path of one track. */
+export interface SubjectPath {
+    /** Oldest → newest. Fewer than 2 = nothing to draw. */
+    readonly nodes: readonly SubjectPathNode[];
+    /** Samples left out as motion placeholders (near-full-frame boxes). */
+    readonly unlocalized: number;
+}
+/** What to build the path from. */
+export interface SubjectPathOptions {
+    /** Only samples at or before this instant (the frame the path is drawn on). */
+    readonly untilTimestamp?: number;
+    /** Downsample to at most this many nodes. Default {@link SUBJECT_PATH_MAX_POINTS}. */
+    readonly maxPoints?: number;
+}
+/** A box covering at least this fraction of BOTH frame sides is a placeholder. */
+export declare const SUBJECT_PATH_FULL_FRAME_COVERAGE = 0.85;
+/** Consecutive centres closer than this (normalised euclidean) are one dwell node. */
+export declare const SUBJECT_PATH_DWELL_EPS = 0.005;
+/** A path is downsampled to at most this many nodes. */
+export declare const SUBJECT_PATH_MAX_POINTS = 120;
+/** The sample of a normalised box: its centre, its extent. */
+export declare function subjectPathSampleFromBox(bbox: SubjectPathRect, timestamp?: number): SubjectPathSample;
+/**
+ * The path of one track from its samples (normalised, oldest → newest).
+ * Pure; never throws; malformed samples are skipped.
+ */
+export declare function buildSubjectPath(samples: readonly SubjectPathSample[], opts?: SubjectPathOptions): SubjectPath;
+/** True when the path has something to draw (two nodes or more). */
+export declare function isDrawableSubjectPath(path: SubjectPath): boolean;
+/**
+ * The path as seen through `view` — a normalised rectangle of the frame (the
+ * whole frame `{0,0,1,1}`, or the rectangle a crop cut). Points are re-mapped
+ * into the view's own 0..1 space and the line is CLIPPED to it: a path that
+ * leaves the crop and comes back is two runs. Runs of fewer than two points
+ * are dropped, so an empty result means "nothing to draw".
+ */
+export declare function projectSubjectPath(points: readonly SubjectPathPoint[], view: SubjectPathRect): ReadonlyArray<readonly SubjectPathPoint[]>;
+/** An SVG `points` attribute for a run in a `width` × `height` drawing ("x,y x,y …"). */
+export declare function subjectPathSvgPoints(run: readonly SubjectPathPoint[], width: number, height: number): string;

package/dist/index.d.ts

@@ -261,8 +261,9 @@ export { isAudioClassName, isBaseConditionKey, knownValues, NC_BASE_CONDITION_KE
 export { type PreparedAction, type PreparedAttachment, type PreparedNotification, prepareNotification, type ResolvedLevel, } from './notification/degrade-engine.js';
 export { htmlToText, markdownToHtmlLite, markdownToText, type NotificationFormat as NotificationBodyFormat, resolveFormat, textToHtml, transcodeBody, } from './notification/format-transcode.js';
 export { conditionExclusionReason, conditionVisibleForKind, defaultDeliveryForSection, droppedConditionsForKind, isAudioRule, isOccupancyRule, isSystemDelivery, isSystemRuleKind, kindsForDiscriminator, NC_AUDIO_SEED, NC_CAMERA_SCOPE_CAP_NAME, NC_OCCUPANCY_DEFAULTS, NC_RULE_EDITOR_SECTION_ORDER, NC_RULE_KIND_SPECS, NC_RULE_SECTIONS, NC_SYSTEM_DELIVERY, NC_SYSTEM_RULE_KINDS, type NcDroppedCondition, type NcKindVisibilitySubject, type NcRuleEditorSection, type NcRuleEditorSectionKey, type NcRuleKind, type NcRuleKindSpec, type NcRuleOwningSectionKey, type NcRuleSection, type NcRuleSectionKey, type NcRuleConditionsSubject, type NcRuleSectionSubject, type NcRuleSeed, parseRuleSection, ruleDeviceCompatCapNames, ruleDeviceCompatCapQueries, ruleEditorSectionsForKind, ruleGroupingApplies, ruleKindOf, ruleKindSpec, ruleMatchesSection, ruleSection, ruleSectionOf, ruleSeedForSection, systemFamilyOfKind, systemRuleKindOf, } from './notification/rule-kinds.js';
-export { imageModesForKind, legacyImageMode, NC_MEDIA_IMAGE_MODES, type NcMediaRuleSubject, ncMediaPolicyError, normalizeNcMediaPolicy, resolveNcMediaImage, ruleTriggerZoneIds, } from './notification/media-image.js';
+export { imageModesForKind, legacyImageMode, NC_MEDIA_IMAGE_MODES, type NcMediaRuleSubject, ncMediaPolicyError, normalizeNcMediaPolicy, resolveNcMediaImage, ruleTriggerZoneIds, subjectHasPath, } from './notification/media-image.js';
 export { isScheduleActive } from './notification/schedule.js';
+export { buildSubjectPath, isDrawableSubjectPath, projectSubjectPath, SUBJECT_PATH_DWELL_EPS, SUBJECT_PATH_FULL_FRAME_COVERAGE, SUBJECT_PATH_MAX_POINTS, type SubjectPath, type SubjectPathNode, type SubjectPathOptions, type SubjectPathPoint, type SubjectPathRect, type SubjectPathSample, subjectPathSampleFromBox, subjectPathSvgPoints, } from './geometry/subject-path.js';
 export { isAlarmControllableCap, NC_ALARM_CONTROLLABLE_CAPS, NC_ALARM_OPENING_EVENT_KINDS, NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING, type NcAlarmControllableCap, type NcAlarmMembershipSubject, type NcAlarmOpeningEventKind, ruleAutoTriggersAlarm, ruleBelongsToAlarm, ruleGatedOnArmedState, sensorTransitionNeverFires, } from './notification/alarm-membership.js';
 export { alarmDeviceBlocksArming, alarmDeviceSecureOnArm, type AlarmDeviceBlocksInput, type AlarmDeviceSecureOnArmInput, type NcAlarmSecureActuation, secureActuationFor, } from './notification/alarm-controllable.js';
 export { alarmPatchLanded, applyBlockingEdit, applyModeDelaysEdits, applyModeDeviceListEdit, applyNonBlockingEdit, applySecureOnArmEdit, derivePostTriggeredAction, NC_ALARM_DEFAULT_TRIGGERED_DURATION_SEC, NC_ALARM_DELAY_FIELDS, NC_ALARM_NOTIFY_FIELDS, type NcAlarmDelayField, type NcAlarmDelaySettings, type NcAlarmDelaySource, type NcAlarmModeDeviceListEditResult, type NcAlarmModeNotifyPolicy, type NcAlarmNonBlockingEditResult, type NcAlarmNotifyField, type NcAlarmResolvedDelays, resolveModeDelays, resolveModeNotifyPolicy, } from './notification/alarm-settings.js';

package/dist/index.js

@@ -14698,36 +14698,13 @@ var StorageKindSchema = zod.z.object({
 	declaration: require_sleep.RecordKindDeclarationSchema
 });
 /**
-* The collections retired by exact name by D870 (their data became keys of the
-* camera's settings). No addon declares any of them any more; the engine still
-* refuses one a running addon declared this boot. `dropCollection` may remove
-* these, the per-addon scoped `addon-settings` / `addon-devices` / `sections`
-* tables, and the tables of owners that are no longer installed - nothing else.
-* The records-migration leftovers (D871 `stats-5m`, the phase-0 tables) were
-* dropped by hand on the operator hubs and left this list with D900.
-*/
-var STORAGE_ADMIN_MOVED_COLLECTIONS = [
-	"stream-broker:probe-snapshots",
-	"stream-broker:profile-map",
-	"stream-broker:rtsp-tokens",
-	"notification-center:device-mutes",
-	"recorder:recording-configs",
-	"pipeline-orchestrator:device-features"
-];
-/** The per-addon blob tables a scoped name may carry. */
-var STORAGE_ADMIN_SCOPED_BASES = [
-	"addon-settings",
-	"addon-devices",
-	"sections"
-];
-/**
-* storage-admin - the operator's maintenance reach into the settings database:
-* list its tables, drop one that nothing owns any more (D870).
+* storage-admin - the operator's maintenance reach into the databases: list
+* their tables and record kinds, read a kind for diagnosis. Read-only: a table
+* the code no longer creates is dropped by hand, offline (D901).
 *
 * Hub-only, internal and `auth: 'admin'` explicitly (`internal` does not gate
-* the mount, see `data-store-provider`). Both methods are LOGGED by the engine
-* with the table and the counts. `dropCollection` is a ONE-SHOT of the D870
-* migration and is marked for removal once the last hub has run it.
+* the mount, see `data-store-provider`). `listTables` is LOGGED by the engine
+* with the counts.
 *
 * `listTables` is READ-ONLY: it never creates a table, which `count` and `get`
 * on an undeclared scoped name used to do.
@@ -14743,26 +14720,6 @@ var storageAdminCapability = {
 		* optionally only those owned by `ownerPrefix`. Reads only.
 		*/
 		listTables: require_sleep.method(zod.z.object({ ownerPrefix: zod.z.string().min(1).optional() }), zod.z.object({ tables: zod.z.array(StorageTableSchema) }), { auth: "admin" }),
-		/**
-		* Drop one table. REFUSES when an addon declared it since the engine
-		* started (a running addon still owns it), when it is an engine or
-		* canonical table, when it does not exist, or when its row count is not
-		* `expectRows` - the caller states what it believes it is deleting. The
-		* engine also refuses anything but `<owner>:(addon-settings|addon-devices|
-		* sections)`, the retired collections by name, and tables of owners that
-		* are not installed (and refuses when it cannot read the installed list).
-		* Removed with the D870 migration script once the last hub ran it.
-		*/
-		dropCollection: require_sleep.method(zod.z.object({
-			collection: zod.z.string().min(1),
-			expectRows: zod.z.number().int().nonnegative()
-		}), zod.z.object({
-			dropped: zod.z.literal(true),
-			rows: zod.z.number().int().nonnegative()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
 		/** Every record kind of both files with rows, a size estimate, class and retention (D881). */
 		listKinds: require_sleep.method(zod.z.object({
 			owner: zod.z.string().min(1).optional(),
@@ -44414,6 +44371,15 @@ var NcMediaPolicySchema = zod.z.object({
 	* Replaces `zoneCrop`.
 	*/
 	showTriggerZone: zod.z.boolean().optional(),
+	/**
+	* Draw the SUBJECT'S PATH on the picture — a line in the subject's colour
+	* through the track's positions up to the frame shown, the same path the
+	* debug views draw (`buildSubjectPath`, D903). Every picture mode a subject
+	* is drawn on: a `crop` maps the path into the crop and clips it. Valid only
+	* on a rule whose subject is a tracked object (refused on a sound rule);
+	* dropped on `image: 'none'`. Absent = off.
+	*/
+	showSubjectPath: zod.z.boolean().optional(),
 	/** @deprecated D897 — accepted from an editor that predates `image`, folded into it on save. */
 	attach: zod.z.enum([
 		"best",
@@ -85053,12 +85019,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"storageAdmin.dropCollection": {
-		capName: "storage-admin",
-		capScope: "system",
-		addonId: null,
-		access: "delete"
-	},
 	"storageAdmin.listKinds": {
 		capName: "storage-admin",
 		capScope: "system",
@@ -96356,22 +96316,35 @@ function resolveNcMediaImage(media, kind) {
 }
 /**
 * The stored shape of a media policy: `image` set, the legacy triple gone.
+* `showSubjectPath` survives on a kind with a tracked subject and a picture.
 * `showTriggerZone` survives only where it can be drawn — a zone trigger and a
 * mode other than `crop`/`none`; a legacy `zoneCrop` on a zone rule becomes it.
 * Every other field (gif, clip, rolls, speed, profile, linked cameras) is
 * carried through untouched. Pure; never throws.
 */
 function normalizeNcMediaPolicy(media, rule) {
-	const image = resolveNcMediaImage(media, ruleKindOf(rule));
-	const { attach: _attach, frame: _frame, zoneCrop, showTriggerZone, image: _image, ...rest } = media;
+	const kind = ruleKindOf(rule);
+	const image = resolveNcMediaImage(media, kind);
+	const { attach: _attach, frame: _frame, zoneCrop, showTriggerZone, showSubjectPath, image: _image, ...rest } = media;
 	const drawable = (showTriggerZone === true || media.image === void 0 && zoneCrop === true) && image !== "crop" && image !== "none" && ruleTriggerZoneIds(rule.conditions).length > 0;
+	const pathDrawable = showSubjectPath === true && image !== "none" && subjectHasPath(kind);
 	return {
 		...rest,
 		image,
-		...drawable ? { showTriggerZone: true } : {}
+		...drawable ? { showTriggerZone: true } : {},
+		...pathDrawable ? { showSubjectPath: true } : {}
 	};
 }
 /**
+* True when a rule of this kind has a TRACKED subject whose path can be drawn
+* (`showSubjectPath`): the kinds whose subject owns a region of the frame. A
+* sound owns none, and a kind that carries no media has no picture.
+*/
+function subjectHasPath(kind) {
+	const spec = ruleKindSpec(kind);
+	return spec.carriesMedia && spec.carriesSubjectCrop;
+}
+/**
 * Why a media policy cannot be SAVED on this rule, or null. Server-side and
 * editor alike: `showTriggerZone` on a rule whose trigger is not a zone, and a
 * mode the rule's kind cannot honour.
@@ -96383,6 +96356,7 @@ function ncMediaPolicyError(media, rule) {
 		if (offered.length > 0 && !offered.includes(media.image)) return `media.image '${media.image}' is not available for a ${kind} rule (offered: ${offered.join(", ")})`;
 	}
 	if (media.showTriggerZone === true && ruleTriggerZoneIds(rule.conditions).length === 0) return "media.showTriggerZone needs a rule triggered by a zone (a zones condition or an occupancy zone)";
+	if (media.showSubjectPath === true && !subjectHasPath(kind)) return `media.showSubjectPath needs a rule whose subject is a tracked object (not a ${kind} rule)`;
 	return null;
 }
 //#endregion
@@ -96468,6 +96442,190 @@ function isScheduleActive(schedule, atMs) {
 	return schedule.invert === true ? !inside : inside;
 }
 //#endregion
+//#region src/geometry/subject-path.ts
+/** A box covering at least this fraction of BOTH frame sides is a placeholder. */
+var SUBJECT_PATH_FULL_FRAME_COVERAGE = .85;
+/** Consecutive centres closer than this (normalised euclidean) are one dwell node. */
+var SUBJECT_PATH_DWELL_EPS = .005;
+/** A path is downsampled to at most this many nodes. */
+var SUBJECT_PATH_MAX_POINTS = 120;
+var clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+/** The sample of a normalised box: its centre, its extent. */
+function subjectPathSampleFromBox(bbox, timestamp) {
+	return {
+		x: bbox.x + bbox.w / 2,
+		y: bbox.y + bbox.h / 2,
+		w: bbox.w,
+		h: bbox.h,
+		...timestamp !== void 0 ? { timestamp } : {}
+	};
+}
+function isPlaceholder(s) {
+	return s.w !== void 0 && s.h !== void 0 && s.w >= .85 && s.h >= .85;
+}
+function downsample(xs, max) {
+	if (xs.length <= max || max < 2) return xs;
+	const step = (xs.length - 1) / (max - 1);
+	const out = [];
+	for (let i = 0; i < max - 1; i++) {
+		const x = xs[Math.round(i * step)];
+		if (x !== void 0) out.push(x);
+	}
+	const last = xs[xs.length - 1];
+	if (last !== void 0) out.push(last);
+	return out;
+}
+function isFiniteSample(s) {
+	return Number.isFinite(s.x) && Number.isFinite(s.y);
+}
+/**
+* The path of one track from its samples (normalised, oldest → newest).
+* Pure; never throws; malformed samples are skipped.
+*/
+function buildSubjectPath(samples, opts) {
+	const until = opts?.untilTimestamp;
+	const nodes = [];
+	let unlocalized = 0;
+	let tail = null;
+	for (let index = 0; index < samples.length; index++) {
+		const s = samples[index];
+		if (s === void 0 || !isFiniteSample(s)) continue;
+		if (until !== void 0 && s.timestamp !== void 0 && s.timestamp > until) continue;
+		if (isPlaceholder(s)) {
+			unlocalized += 1;
+			continue;
+		}
+		const ts = s.timestamp !== void 0 && Number.isFinite(s.timestamp) ? s.timestamp : index;
+		const x = clamp01(s.x);
+		const y = clamp01(s.y);
+		const prev = nodes[nodes.length - 1];
+		if (prev !== void 0 && Math.hypot(x - prev.x, y - prev.y) < .005) {
+			nodes[nodes.length - 1] = {
+				...prev,
+				samples: prev.samples + 1,
+				lastTs: Math.max(prev.lastTs, ts)
+			};
+			tail = {
+				x,
+				y,
+				samples: 1,
+				firstTs: ts,
+				lastTs: ts
+			};
+			continue;
+		}
+		tail = null;
+		nodes.push({
+			x,
+			y,
+			samples: 1,
+			firstTs: ts,
+			lastTs: ts
+		});
+	}
+	const end = nodes[nodes.length - 1];
+	if (tail !== null && end !== void 0 && end.samples > 1 && (tail.x !== end.x || tail.y !== end.y)) {
+		nodes[nodes.length - 1] = {
+			...end,
+			samples: end.samples - 1
+		};
+		nodes.push(tail);
+	}
+	return {
+		nodes: downsample(nodes, opts?.maxPoints ?? 120),
+		unlocalized
+	};
+}
+/** True when the path has something to draw (two nodes or more). */
+function isDrawableSubjectPath(path) {
+	return path.nodes.length >= 2;
+}
+function inside(p) {
+	return p.x >= 0 && p.x <= 1 && p.y >= 0 && p.y <= 1;
+}
+/** Liang–Barsky: the part of segment a→b inside the unit square, or null. */
+function clipSegment(a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	let t0 = 0;
+	let t1 = 1;
+	const edges = [
+		[-dx, a.x],
+		[dx, 1 - a.x],
+		[-dy, a.y],
+		[dy, 1 - a.y]
+	];
+	for (const [p, q] of edges) {
+		if (p === 0) {
+			if (q < 0) return null;
+			continue;
+		}
+		const r = q / p;
+		if (p < 0) {
+			if (r > t1) return null;
+			if (r > t0) t0 = r;
+		} else {
+			if (r < t0) return null;
+			if (r < t1) t1 = r;
+		}
+	}
+	return [{
+		x: a.x + t0 * dx,
+		y: a.y + t0 * dy
+	}, {
+		x: a.x + t1 * dx,
+		y: a.y + t1 * dy
+	}];
+}
+function samePoint(a, b) {
+	return Math.abs(a.x - b.x) < 1e-9 && Math.abs(a.y - b.y) < 1e-9;
+}
+/**
+* The path as seen through `view` — a normalised rectangle of the frame (the
+* whole frame `{0,0,1,1}`, or the rectangle a crop cut). Points are re-mapped
+* into the view's own 0..1 space and the line is CLIPPED to it: a path that
+* leaves the crop and comes back is two runs. Runs of fewer than two points
+* are dropped, so an empty result means "nothing to draw".
+*/
+function projectSubjectPath(points, view) {
+	if (points.length < 2 || !(view.w > 0) || !(view.h > 0)) return [];
+	const local = points.map((p) => ({
+		x: (p.x - view.x) / view.w,
+		y: (p.y - view.y) / view.h
+	}));
+	const runs = [];
+	let run = [];
+	for (let i = 1; i < local.length; i++) {
+		const a = local[i - 1];
+		const b = local[i];
+		if (a === void 0 || b === void 0) continue;
+		const seg = clipSegment(a, b);
+		if (seg === null) {
+			if (run.length >= 2) runs.push(run);
+			run = [];
+			continue;
+		}
+		const [from, to] = seg;
+		const last = run[run.length - 1];
+		if (last === void 0 || !samePoint(last, from)) {
+			if (run.length >= 2) runs.push(run);
+			run = [from];
+		}
+		run.push(to);
+		if (!inside(b)) {
+			if (run.length >= 2) runs.push(run);
+			run = [];
+		}
+	}
+	if (run.length >= 2) runs.push(run);
+	return runs;
+}
+/** An SVG `points` attribute for a run in a `width` × `height` drawing ("x,y x,y …"). */
+function subjectPathSvgPoints(run, width, height) {
+	const fmt = (v) => String(Math.round(v * 100) / 100);
+	return run.map((p) => `${fmt(p.x * width)},${fmt(p.y * height)}`).join(" ");
+}
+//#endregion
 //#region src/notification/alarm-membership.ts
 var ARMED_WORD_PREFIX = "armed_";
 var ALARM_PANEL_CAP = "alarm-panel";
@@ -105240,12 +105398,13 @@ exports.STATE_LABELS = STATE_LABELS;
 exports.STATE_LABEL_KEYS = STATE_LABEL_KEYS;
 exports.STATIONARY_OVERLAY_STYLE = STATIONARY_OVERLAY_STYLE;
 exports.STORAGE_ACCESS_FALLBACK = STORAGE_ACCESS_FALLBACK;
-exports.STORAGE_ADMIN_MOVED_COLLECTIONS = STORAGE_ADMIN_MOVED_COLLECTIONS;
-exports.STORAGE_ADMIN_SCOPED_BASES = STORAGE_ADMIN_SCOPED_BASES;
 exports.STORAGE_BYTES_PER_GB = STORAGE_BYTES_PER_GB;
 exports.STORAGE_LOCATION_MODES = STORAGE_LOCATION_MODES;
 exports.STREAM_PROFILE_META = STREAM_PROFILE_META;
 exports.STREAM_QUALITY_LABELS = STREAM_QUALITY_LABELS;
+exports.SUBJECT_PATH_DWELL_EPS = SUBJECT_PATH_DWELL_EPS;
+exports.SUBJECT_PATH_FULL_FRAME_COVERAGE = SUBJECT_PATH_FULL_FRAME_COVERAGE;
+exports.SUBJECT_PATH_MAX_POINTS = SUBJECT_PATH_MAX_POINTS;
 exports.SUB_DETECTION_TYPES = SUB_DETECTION_TYPES;
 exports.SYSTEM_CAP_NAMES = SYSTEM_CAP_NAMES;
 exports.SYSTEM_SCOPE_DEVICE_METHODS = SYSTEM_SCOPE_DEVICE_METHODS;
@@ -105637,6 +105796,7 @@ exports.buildNcTaxonomy = buildNcTaxonomy;
 exports.buildRoleScopes = buildRoleScopes;
 exports.buildSecretRef = require_sleep.buildSecretRef;
 exports.buildStreamParamsConfigSchema = buildStreamParamsConfigSchema;
+exports.buildSubjectPath = buildSubjectPath;
 exports.buildVideoArgs = require_composition.buildVideoArgs;
 exports.buildViewerLink = buildViewerLink;
 exports.builtCapabilityBlockers = builtCapabilityBlockers;
@@ -105958,6 +106118,7 @@ exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
 exports.isDeviceScopedCap = require_sleep.isDeviceScopedCap;
 exports.isDoActionActuatable = isDoActionActuatable;
 exports.isDoPickerDeviceType = isDoPickerDeviceType;
+exports.isDrawableSubjectPath = isDrawableSubjectPath;
 exports.isEmbeddingModelFailed = isEmbeddingModelFailed;
 exports.isEvent = require_sleep.isEvent;
 exports.isEventKindLabelKey = isEventKindLabelKey;
@@ -106171,6 +106332,7 @@ exports.pressureSensorCapability = pressureSensorCapability;
 exports.principalMayReachAddon = principalMayReachAddon;
 exports.privacyMaskCapability = privacyMaskCapability;
 exports.procedureAuthKey = procedureAuthKey;
+exports.projectSubjectPath = projectSubjectPath;
 exports.providerMotionEvent = providerMotionEvent;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
 exports.ptzCapability = ptzCapability;
@@ -106350,6 +106512,9 @@ exports.streamSignalsCapability = streamSignalsCapability;
 exports.stripRetiredBandPreBufferSec = stripRetiredBandPreBufferSec;
 exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
 exports.subKindsOf = subKindsOf;
+exports.subjectHasPath = subjectHasPath;
+exports.subjectPathSampleFromBox = subjectPathSampleFromBox;
+exports.subjectPathSvgPoints = subjectPathSvgPoints;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
 exports.summarizeEffectiveScope = summarizeEffectiveScope;
 exports.summarizeReview = summarizeReview;