@camstack/addon-post-analysis 1.2.5 → 1.2.7

package/dist/{dist-Dlb4YrCt.js → dist-BW-IoQDL.js}

@@ -6837,7 +6837,6 @@ object({ deviceId: number() }), object({ deviceId: number() }), object({
 	patch: record(string(), unknown())
 }), object({ success: literal(true) });
 object({ deviceId: number() }), unknown().nullable();
-/** Shorthand to define a method schema */
 function method(input, output, options) {
 	return {
 		input,
@@ -6845,6 +6844,7 @@ function method(input, output, options) {
 		kind: options?.kind ?? "query",
 		auth: options?.auth ?? "protected",
 		...options?.access !== void 0 ? { access: options.access } : {},
+		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
 	};
 }
@@ -11039,6 +11039,22 @@ var CameraMetricsSchema = object({
 	])
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: number() });
+/**
+* Reference to the frame's retained NATIVE surface + the parent crop's placement
+* within the frame, so the executor can re-cut a leaf child ROI at native
+* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
+*/
+var NativeCropRefSchema = object({
+	/** Handle keying the retained native surface (node-pinned to its owner). */
+	handle: FrameHandleSchema,
+	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
+	cropFrameSpace: object({
+		x: number(),
+		y: number(),
+		w: number(),
+		h: number()
+	})
+});
 var ModelFormatSchema$1 = _enum([
 	"onnx",
 	"coreml",
@@ -11314,7 +11330,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	* Omitted ⇒ the runner's default device (current single-engine
 	* behaviour). Selects WHICH device pool of the node runs the call.
 	*/
-	deviceKey: string().optional()
+	deviceKey: string().optional(),
+	/**
+	* Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+	* when the parent crop was resolved from the frame's retained NATIVE
+	* surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+	* child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+	* resolution from that surface — the SAME quality path faces already
+	* had — instead of the downscaled parent tile. `handle` keys the native
+	* surface (node-pinned to its owner); `cropFrameSpace` is the parent
+	* crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+	* the executor's crop-normalized child ROI back into frame-normalized
+	* coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+	* of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+	* (today's behaviour on the fallback path).
+	*/
+	nativeCropRef: NativeCropRefSchema.optional()
 }), PipelineRunResultBridge, { kind: "mutation" }), method(object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).min(1),
@@ -11530,7 +11561,11 @@ var DetailResultSchema = object({
 	bbox: NativeCropBboxSchema.optional(),
 	embedding: string().optional(),
 	label: string().optional(),
-	alignedCropJpeg: string().optional()
+	alignedCropJpeg: string().optional(),
+	/** Face short side (px) measured on the NATIVE crop surface. The `bbox`
+	*  above is detection-frame px (≈6× smaller on a 4K camera) — min-face-size
+	*  consumers MUST prefer this when present (2026-07-22 native-gate fix). */
+	nativeFaceShortSidePx: number().optional()
 });
 /**
 * Per-camera tunable ranges + defaults. Single source of truth used
@@ -15972,6 +16007,348 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	enabled: boolean()
 }), _void(), { kind: "mutation" });
 /**
+* notification-rules — the Notification Center rule surface (P1 core).
+*
+* Spec: `docs/superpowers/specs/2026-07-22-notification-center-requirements.md`
+* (operator decisions D-1/D-2/D-3 are binding):
+*
+*  - D-2: rule EVALUATION lives in `addon-post-analysis` (the
+*    `notification-center` module), hooked on the durable persistence
+*    moments (object-event insert, TrackCloser.closeExpired) with a
+*    persisted outbox + retry — never the lossy telemetry bus (D8).
+*  - D-3: urgency belongs to the RULE. `delivery: 'immediate'` fires on the
+*    FIRST persisted detection matching the conditions (per-track dedup,
+*    `maxPerTrack` fixed at 1 — see {@link NC_MAX_PER_TRACK_IMMEDIATE});
+*    `delivery: 'track-end'` evaluates the finalized track record at close.
+*  - DISPATCH stays behind `notification-output` (rules reference targets
+*    by id; per-backend params are a passthrough blob capped by the
+*    target kind's own caps/degrade engine).
+*
+* P1 scope: admin-authored rules only (`createdBy` stamped from the
+* server-injected caller identity — the first `caller: 'required'`
+* adopter). The P1 condition subset is: devices, classes(+exclude),
+* minConfidence, admin zones (any/all + exclude), weekly schedule
+* windows, and the optional label/identity/plate matchers. User rules,
+* private zones, per-recipient fan-out and the wider condition table are
+* P2+ (see spec §7).
+*
+* All schemas here are the single source of truth — `NcRule` etc. are
+* `z.infer` exports; no duplicate interfaces (the advanced-notifier
+* schema/interface drift is explicitly not repeated).
+*/
+/** D-3: the urgency of a rule — which persistence moment evaluates it. */
+var NcDeliverySchema = _enum(["immediate", "track-end"]);
+/** Weekly schedule — OR of windows; absence on the rule = always active. */
+var NcScheduleSchema = object({
+	windows: array(object({
+		/** Days of week the window STARTS on (0 = Sunday … 6 = Saturday). */
+		days: array(number().int().min(0).max(6)).min(1),
+		startMinute: number().int().min(0).max(1439),
+		endMinute: number().int().min(0).max(1439)
+	})).min(1),
+	/** IANA timezone; default = hub host timezone. */
+	timezone: string().optional(),
+	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
+	invert: boolean().optional()
+});
+/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
+var NcPlateMatcherSchema = object({
+	values: array(string().min(1)).min(1),
+	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
+	maxDistance: number().int().min(0).max(3).default(1)
+});
+/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
+var NcZoneConditionSchema = object({
+	ids: array(string().min(1)).min(1),
+	/** Quantifier over `ids` — at least one / every one visited. */
+	match: _enum(["any", "all"]).default("any")
+});
+/**
+* The P1 condition set — a flat AND of groups; absent group = pass;
+* membership lists are OR within the list (spec §2.3).
+*/
+var NcConditionsSchema = object({
+	/** Device scope — absent = all devices. */
+	devices: array(number()).optional(),
+	/** Detector class names (any overlap with the record's class set). */
+	classes: array(string().min(1)).optional(),
+	/** Veto classes — any overlap fails the rule. */
+	classesExclude: array(string().min(1)).optional(),
+	/** Minimum detection confidence 0–1 (fails when the record has none). */
+	minConfidence: number().min(0).max(1).optional(),
+	/** Admin zone membership over event `zones` / track `zonesVisited`. */
+	zones: NcZoneConditionSchema.optional(),
+	/** Veto zones — any hit fails the rule. */
+	zonesExclude: array(string().min(1)).optional(),
+	/**
+	* Exact (case-insensitive) match on the record's collapsed `label`
+	* (identity name / plate text / subclass).
+	*/
+	labelEquals: array(string().min(1)).optional(),
+	/**
+	* Identity matcher. P1 boundary: matched against the record's collapsed
+	* `label` (the identity display name propagated by the face pipeline) —
+	* identity-ID matching rides in P2 when identity ids reach the record.
+	*/
+	identities: array(string().min(1)).optional(),
+	/** Fuzzy plate matcher against the record's `label` (plate text). */
+	plates: NcPlateMatcherSchema.optional()
+});
+/** One delivery target: a `notification-output` Target ref + passthrough params. */
+var NcRuleTargetSchema = object({
+	/** `notification-output` Target id. */
+	targetId: string().min(1),
+	/**
+	* Per-backend passthrough. Recognized keys are mapped onto the canonical
+	* Notification (`priority`, `level`, `sound`, `clickUrl`, `ttl`); the
+	* degrade engine drops what the backend can't render.
+	*/
+	params: record(string(), unknown()).optional()
+});
+/**
+* Media attachment policy (P1 still-image subset). `best` = the best
+* AVAILABLE media at dispatch time (D-3); `best-matching` (track-end
+* condition-best) is deferred — operator open point.
+*/
+var NcMediaPolicySchema = object({ attach: _enum([
+	"best",
+	"keyFrame",
+	"none"
+]).default("best") });
+/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
+var NcThrottleSchema = object({
+	cooldownSec: number().int().min(0).max(86400).default(60),
+	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
+	scope: _enum(["rule", "rule-device"]).default("rule-device")
+});
+/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
+var NcRuleInputSchema = object({
+	name: string().min(1).max(200),
+	enabled: boolean().default(true),
+	delivery: NcDeliverySchema,
+	conditions: NcConditionsSchema.default({}),
+	schedule: NcScheduleSchema.optional(),
+	targets: array(NcRuleTargetSchema).min(1),
+	media: NcMediaPolicySchema.default({ attach: "best" }),
+	throttle: NcThrottleSchema.default({
+		cooldownSec: 60,
+		scope: "rule-device"
+	}),
+	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
+	template: object({
+		title: string().max(500).optional(),
+		body: string().max(2e3).optional()
+	}).optional(),
+	/** Canonical notification priority ordinal (1..5); per-target overridable. */
+	priority: number().int().min(1).max(5).default(3)
+});
+/** Partial patch for `updateRule` — any subset of the input fields. */
+var NcRulePatchSchema = NcRuleInputSchema.partial();
+/** A persisted rule. */
+var NcRuleSchema = NcRuleInputSchema.extend({
+	id: string(),
+	/** userId of the admin who created the rule (server-stamped caller). */
+	createdBy: string(),
+	createdAt: number(),
+	updatedAt: number()
+});
+var NcTestResultSchema = object({
+	recordId: string(),
+	recordKind: _enum(["object-event", "track"]),
+	deviceId: number(),
+	timestamp: number(),
+	wouldFire: boolean(),
+	/** Condition id that failed (first failing group), when `wouldFire` is false. */
+	failedCondition: string().optional(),
+	className: string().optional(),
+	label: string().optional()
+});
+var NcConditionDescriptorSchema = object({
+	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
+	id: string(),
+	group: _enum([
+		"scope",
+		"class",
+		"zones",
+		"quality",
+		"label",
+		"schedule"
+	]),
+	label: string(),
+	/** Editor widget the UI renders — never hardcode per-condition forms. */
+	valueType: _enum([
+		"deviceIdList",
+		"stringList",
+		"number01",
+		"zoneSelection",
+		"zoneIdList",
+		"schedule",
+		"plateMatcher"
+	]),
+	operator: _enum([
+		"in",
+		"notIn",
+		"anyOf",
+		"allOf",
+		"gte",
+		"fuzzyIn",
+		"withinSchedule"
+	]),
+	/** Which delivery kinds the condition applies to. */
+	appliesTo: array(NcDeliverySchema),
+	phase: string(),
+	description: string().optional()
+});
+/**
+* The P1 condition surface as data — served by `getConditionCatalog` so
+* rule editors render from the catalog, not hardcoded forms (spec §4.2).
+*/
+var NC_CONDITION_CATALOG = [
+	{
+		id: "devices",
+		group: "scope",
+		label: "Cameras",
+		valueType: "deviceIdList",
+		operator: "in",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Restrict the rule to these devices; absent = all devices."
+	},
+	{
+		id: "classes",
+		group: "class",
+		label: "Object classes",
+		valueType: "stringList",
+		operator: "in",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Any overlap with the detection class set passes."
+	},
+	{
+		id: "classesExclude",
+		group: "class",
+		label: "Excluded classes",
+		valueType: "stringList",
+		operator: "notIn",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1"
+	},
+	{
+		id: "minConfidence",
+		group: "quality",
+		label: "Minimum confidence",
+		valueType: "number01",
+		operator: "gte",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1"
+	},
+	{
+		id: "zones",
+		group: "zones",
+		label: "Zones",
+		valueType: "zoneSelection",
+		operator: "anyOf",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Admin zone ids; quantifier any/all over the visited set."
+	},
+	{
+		id: "zonesExclude",
+		group: "zones",
+		label: "Excluded zones",
+		valueType: "zoneIdList",
+		operator: "notIn",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1"
+	},
+	{
+		id: "labelEquals",
+		group: "label",
+		label: "Label equals",
+		valueType: "stringList",
+		operator: "in",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Exact match on the collapsed label (identity / plate / subclass)."
+	},
+	{
+		id: "identities",
+		group: "label",
+		label: "Identities",
+		valueType: "stringList",
+		operator: "in",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "P1: matched against the identity display name on the record label."
+	},
+	{
+		id: "plates",
+		group: "label",
+		label: "License plates",
+		valueType: "plateMatcher",
+		operator: "fuzzyIn",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Levenshtein-tolerant match against the plate text."
+	},
+	{
+		id: "schedule",
+		group: "schedule",
+		label: "Schedule",
+		valueType: "schedule",
+		operator: "withinSchedule",
+		appliesTo: ["immediate", "track-end"],
+		phase: "P1",
+		description: "Weekly activation windows (invertible); absent = always active."
+	}
+];
+var notificationRulesCapability = {
+	name: "notification-rules",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		listRules: method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }),
+		getRule: method(object({ ruleId: string() }), object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }),
+		createRule: method(object({ rule: NcRuleInputSchema }), object({ rule: NcRuleSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		updateRule: method(object({
+			ruleId: string(),
+			patch: NcRulePatchSchema
+		}), object({ rule: NcRuleSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		deleteRule: method(object({ ruleId: string() }), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setRuleEnabled: method(object({
+			ruleId: string(),
+			enabled: boolean()
+		}), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Dry-run a rule against recently persisted records (object events for
+		* `immediate`, closed tracks for `track-end`). Mutation kind only to
+		* carry the full rule object safely; no side effects.
+		*/
+		testRule: method(object({
+			rule: NcRuleInputSchema,
+			lookbackMinutes: number().int().min(1).max(1440).default(60)
+		}), object({ results: array(NcTestResultSchema) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getConditionCatalog: method(object({}), object({ catalog: array(NcConditionDescriptorSchema) }))
+	}
+};
+/**
 * Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
 * surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
 * caps stay wire-compatible without a circular cap→cap import.
@@ -23613,6 +23990,54 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.createRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.deleteRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"notificationRules.getConditionCatalog": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.getRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.listRules": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.setRuleEnabled": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.testRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.updateRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notifier.cancel": {
 		capName: "notifier",
 		capScope: "device",
@@ -25868,6 +26293,18 @@ Object.defineProperty(exports, "MACRO_LABELS", {
 		return MACRO_LABELS;
 	}
 });
+Object.defineProperty(exports, "NC_CONDITION_CATALOG", {
+	enumerable: true,
+	get: function() {
+		return NC_CONDITION_CATALOG;
+	}
+});
+Object.defineProperty(exports, "NcRuleSchema", {
+	enumerable: true,
+	get: function() {
+		return NcRuleSchema;
+	}
+});
 Object.defineProperty(exports, "OpsLogEntrySchema", {
 	enumerable: true,
 	get: function() {
@@ -25958,6 +26395,12 @@ Object.defineProperty(exports, "nodePin", {
 		return nodePin;
 	}
 });
+Object.defineProperty(exports, "notificationRulesCapability", {
+	enumerable: true,
+	get: function() {
+		return notificationRulesCapability;
+	}
+});
 Object.defineProperty(exports, "number", {
 	enumerable: true,
 	get: function() {