@camstack/system 1.2.6 → 1.2.8

package/dist/{dist-DIlYZWEp.js → dist-CdgScQ3H.js}

@@ -2702,7 +2702,6 @@ function expandCapMethods(def) {
 	};
 	return out;
 }
-/** Shorthand to define a method schema */
 function method(input, output, options) {
 	return {
 		input,
@@ -2710,6 +2709,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
 	};
 }
@@ -8365,6 +8365,22 @@ var CameraMetricsSchema = zod.z.object({
 	])
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: zod.z.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 = zod.z.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: zod.z.object({
+		x: zod.z.number(),
+		y: zod.z.number(),
+		w: zod.z.number(),
+		h: zod.z.number()
+	})
+});
 var ModelFormatSchema$1 = zod.z.enum([
 	"onnx",
 	"coreml",
@@ -8739,7 +8755,22 @@ var pipelineExecutorCapability = {
 			* Omitted ⇒ the runner's default device (current single-engine
 			* behaviour). Selects WHICH device pool of the node runs the call.
 			*/
-			deviceKey: zod.z.string().optional()
+			deviceKey: zod.z.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" }),
 		/**
 		* Batched run — N raw frames packed into one cap call. The provider
@@ -9042,7 +9073,11 @@ var DetailResultSchema = zod.z.object({
 	bbox: NativeCropBboxSchema.optional(),
 	embedding: zod.z.string().optional(),
 	label: zod.z.string().optional(),
-	alignedCropJpeg: zod.z.string().optional()
+	alignedCropJpeg: zod.z.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: zod.z.number().optional()
 });
 /**
 * Per-camera tunable ranges + defaults. Single source of truth used
@@ -15728,6 +15763,247 @@ var notificationOutputCapability = {
 	}
 };
 /**
+* 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 = zod.z.enum(["immediate", "track-end"]);
+/** One weekly activation window. `startMinute > endMinute` crosses midnight. */
+var NcScheduleWindowSchema = zod.z.object({
+	/** Days of week the window STARTS on (0 = Sunday … 6 = Saturday). */
+	days: zod.z.array(zod.z.number().int().min(0).max(6)).min(1),
+	startMinute: zod.z.number().int().min(0).max(1439),
+	endMinute: zod.z.number().int().min(0).max(1439)
+});
+/** Weekly schedule — OR of windows; absence on the rule = always active. */
+var NcScheduleSchema = zod.z.object({
+	windows: zod.z.array(NcScheduleWindowSchema).min(1),
+	/** IANA timezone; default = hub host timezone. */
+	timezone: zod.z.string().optional(),
+	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
+	invert: zod.z.boolean().optional()
+});
+/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
+var NcPlateMatcherSchema = zod.z.object({
+	values: zod.z.array(zod.z.string().min(1)).min(1),
+	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
+	maxDistance: zod.z.number().int().min(0).max(3).default(1)
+});
+/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
+var NcZoneConditionSchema = zod.z.object({
+	ids: zod.z.array(zod.z.string().min(1)).min(1),
+	/** Quantifier over `ids` — at least one / every one visited. */
+	match: zod.z.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 = zod.z.object({
+	/** Device scope — absent = all devices. */
+	devices: zod.z.array(zod.z.number()).optional(),
+	/** Detector class names (any overlap with the record's class set). */
+	classes: zod.z.array(zod.z.string().min(1)).optional(),
+	/** Veto classes — any overlap fails the rule. */
+	classesExclude: zod.z.array(zod.z.string().min(1)).optional(),
+	/** Minimum detection confidence 0–1 (fails when the record has none). */
+	minConfidence: zod.z.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: zod.z.array(zod.z.string().min(1)).optional(),
+	/**
+	* Exact (case-insensitive) match on the record's collapsed `label`
+	* (identity name / plate text / subclass).
+	*/
+	labelEquals: zod.z.array(zod.z.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: zod.z.array(zod.z.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 = zod.z.object({
+	/** `notification-output` Target id. */
+	targetId: zod.z.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: zod.z.record(zod.z.string(), zod.z.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 = zod.z.object({ attach: zod.z.enum([
+	"best",
+	"keyFrame",
+	"none"
+]).default("best") });
+/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
+var NcThrottleSchema = zod.z.object({
+	cooldownSec: zod.z.number().int().min(0).max(86400).default(60),
+	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
+	scope: zod.z.enum(["rule", "rule-device"]).default("rule-device")
+});
+/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
+var NcRuleInputSchema = zod.z.object({
+	name: zod.z.string().min(1).max(200),
+	enabled: zod.z.boolean().default(true),
+	delivery: NcDeliverySchema,
+	conditions: NcConditionsSchema.default({}),
+	schedule: NcScheduleSchema.optional(),
+	targets: zod.z.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: zod.z.object({
+		title: zod.z.string().max(500).optional(),
+		body: zod.z.string().max(2e3).optional()
+	}).optional(),
+	/** Canonical notification priority ordinal (1..5); per-target overridable. */
+	priority: zod.z.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: zod.z.string(),
+	/** userId of the admin who created the rule (server-stamped caller). */
+	createdBy: zod.z.string(),
+	createdAt: zod.z.number(),
+	updatedAt: zod.z.number()
+});
+var NcTestResultSchema = zod.z.object({
+	recordId: zod.z.string(),
+	recordKind: zod.z.enum(["object-event", "track"]),
+	deviceId: zod.z.number(),
+	timestamp: zod.z.number(),
+	wouldFire: zod.z.boolean(),
+	/** Condition id that failed (first failing group), when `wouldFire` is false. */
+	failedCondition: zod.z.string().optional(),
+	className: zod.z.string().optional(),
+	label: zod.z.string().optional()
+});
+var NcConditionDescriptorSchema = zod.z.object({
+	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
+	id: zod.z.string(),
+	group: zod.z.enum([
+		"scope",
+		"class",
+		"zones",
+		"quality",
+		"label",
+		"schedule"
+	]),
+	label: zod.z.string(),
+	/** Editor widget the UI renders — never hardcode per-condition forms. */
+	valueType: zod.z.enum([
+		"deviceIdList",
+		"stringList",
+		"number01",
+		"zoneSelection",
+		"zoneIdList",
+		"schedule",
+		"plateMatcher"
+	]),
+	operator: zod.z.enum([
+		"in",
+		"notIn",
+		"anyOf",
+		"allOf",
+		"gte",
+		"fuzzyIn",
+		"withinSchedule"
+	]),
+	/** Which delivery kinds the condition applies to. */
+	appliesTo: zod.z.array(NcDeliverySchema),
+	phase: zod.z.string(),
+	description: zod.z.string().optional()
+});
+var notificationRulesCapability = {
+	name: "notification-rules",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		listRules: method(zod.z.object({}), zod.z.object({ rules: zod.z.array(NcRuleSchema) }), { auth: "admin" }),
+		getRule: method(zod.z.object({ ruleId: zod.z.string() }), zod.z.object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }),
+		createRule: method(zod.z.object({ rule: NcRuleInputSchema }), zod.z.object({ rule: NcRuleSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		updateRule: method(zod.z.object({
+			ruleId: zod.z.string(),
+			patch: NcRulePatchSchema
+		}), zod.z.object({ rule: NcRuleSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		deleteRule: method(zod.z.object({ ruleId: zod.z.string() }), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setRuleEnabled: method(zod.z.object({
+			ruleId: zod.z.string(),
+			enabled: zod.z.boolean()
+		}), zod.z.object({ success: zod.z.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(zod.z.object({
+			rule: NcRuleInputSchema,
+			lookbackMinutes: zod.z.number().int().min(1).max(1440).default(60)
+		}), zod.z.object({ results: zod.z.array(NcTestResultSchema) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getConditionCatalog: method(zod.z.object({}), zod.z.object({ catalog: zod.z.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.
@@ -22573,6 +22849,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	networkQualityCapability,
 	nodesCapability,
 	notificationOutputCapability,
+	notificationRulesCapability,
 	notifierCapability,
 	numericSensorCapability,
 	oauthIntegrationCapability,
@@ -25314,6 +25591,54 @@ var METHOD_ACCESS_MAP = 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",