@camstack/addon-osd-manager 0.1.183 → 0.1.184

package/dist/index.js

@@ -5382,7 +5382,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-C16NCZR2.mjs
+//#region ../types/dist/sleep-DAJ9Er57.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -28085,148 +28085,17 @@ var pipelineExecutorCapability = {
 	}
 };
 /**
-* Wire shapes of the Load balancing surface (D748): the session placement
-* policy, the atomic share write, the observed placement statistics, the
-* hardware share suggestion and the stale device pins.
-*/
-/**
-* How a new detection session picks its node and device.
-*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
-*    constant node order at a tie (D37). An idle node always ties at 0, so a
-*    weight only bites once a node already holds a session.
-*  - `share` — the share of PARALLEL sessions is held to the weights, and a
-*    full or drowning node yields to a free one (D748).
-*/
-var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
-var LoadBalancingSharesInputSchema = object({
-	/** nodeId → share (> 0). A node left out keeps its weight. */
-	nodes: record(string(), number().positive()).default({}),
-	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
-	devices: record(string(), record(string(), number().positive())).default({})
-});
-var PlacementStatsInputSchema = object({ 
-/** Window the observed shares are averaged over (default 1 h, max 24 h). */
-windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
-var PlacementDeviceStatsSchema = object({
-	deviceKey: string(),
-	/** Sessions running on this device now. */
-	sessionsNow: number(),
-	/** Sessions started on this device inside the window. */
-	sessionsStarted: number(),
-	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
-	observedShare: number().nullable()
-});
-var PlacementNodeStatsSchema = object({
-	nodeId: string(),
-	sessionsNow: number(),
-	sessionsStarted: number(),
-	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
-	observedShare: number().nullable(),
-	/** Most sessions this node ran at once inside the window. */
-	peakSessions: number(),
-	/** Sessions a share election handed elsewhere because this node was full or drowning. */
-	yieldsAway: number(),
-	devices: array(PlacementDeviceStatsSchema).readonly()
-});
-/** A camera's device pin that the session path cannot honour. */
-var StaleDevicePinSchema = object({
-	deviceId: number(),
-	deviceKey: string(),
-	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
-	reason: _enum(["disabled", "absent"])
-});
-var PlacementStatsSchema = object({
-	policy: SessionPlacementPolicySchema,
-	windowMs: number(),
-	/** How much of the window was actually observed (the hub keeps it in memory). */
-	observedForMs: number(),
-	sessionsNow: number(),
-	/** Most parallel sessions across the cluster inside the window. */
-	clusterPeakSessions: number(),
-	nodes: array(PlacementNodeStatsSchema).readonly(),
-	stalePins: array(StaleDevicePinSchema).readonly()
-});
-var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
-var SuggestedDeviceShareSchema = object({
-	deviceKey: string(),
-	/** Share of the node (0–100, rounded). */
-	share: number(),
-	modelId: string().nullable(),
-	/** Inferences per second at that model, from the measured table. */
-	fps: number().nullable(),
-	measured: boolean(),
-	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
-	suggestedMaxSessions: number().nullable()
-});
-var SuggestedNodeShareSchema = object({
-	nodeId: string(),
-	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
-	share: number().nullable(),
-	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
-	capacitySessions: number(),
-	devices: array(SuggestedDeviceShareSchema).readonly(),
-	skippedReason: string().nullable()
-});
-var SuggestSharesResultSchema = object({
-	headroom: number(),
-	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
-	cameraFps: number(),
-	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
-	iterations: number(),
-	nodes: array(SuggestedNodeShareSchema).readonly()
-});
-/**
-* Where the node and device shares come from (D750).
-*  - `auto` — computed by the system from the cluster's measured capacity at
-*    the Auto tune models, and recomputed whenever a node or device joins,
-*    leaves, is switched on or off, or changes model.
-*  - `manual` — the operator's stored sliders. A node or device that cannot
-*    take sessions gives its share to the others in proportion; the stored
-*    values are never rewritten for that.
-*/
-var ShareSourceSchema = _enum(["auto", "manual"]);
-var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
-object({
-	nodes: record(string(), number()),
-	devices: record(string(), record(string(), number()))
-});
-var EffectiveDeviceShareSchema = object({
-	deviceKey: string(),
-	/** Can take sessions now (enabled, available, can run the root). */
-	eligible: boolean(),
-	/** The share the source assigns, as a percentage of the node's devices. */
-	configuredPct: number(),
-	/** The share actually used, after an ineligible device's share went to the others. */
-	effectivePct: number()
-});
-var EffectiveNodeShareSchema = object({
-	nodeId: string(),
-	eligible: boolean(),
-	configuredPct: number(),
-	effectivePct: number(),
-	devices: array(EffectiveDeviceShareSchema).readonly()
-});
-var EffectiveSharesSchema = object({
-	source: ShareSourceSchema,
-	policy: SessionPlacementPolicySchema,
-	/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
-	autoPending: boolean(),
-	/** When the automatic shares were last computed (ms epoch); null = never. */
-	computedAt: number().nullable(),
-	/** What made the system recompute them last. */
-	trigger: string().nullable(),
-	nodes: array(EffectiveNodeShareSchema).readonly(),
-	/** The relative weights the election reads (before eligibility). */
-	nodeWeights: record(string(), number()),
-	deviceWeights: record(string(), record(string(), number()))
-});
-/**
 * The wire shapes of the Auto tune plan and apply (D745), used by the
 * `pipeline-orchestrator` cap. The recommender's own types
-* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
+* (`recommend.ts`) are the TS face of the same data; these
 * schemas are what crosses the cap boundary.
 */
 var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
+/** The operator's range for it. */
+var MIN_SESSIONS_PER_DEVICE_RANGE = {
+	min: 1,
+	max: 8
+};
 var HardwareClassIdSchema = _enum([
 	"intel-core-ultra",
 	"intel-n-series",
@@ -28244,8 +28113,9 @@ var AcceleratorKindSchema = _enum([
 ]);
 var RecommendationReasonSchema = discriminatedUnion("kind", [
 	object({
-		kind: literal("fits"),
-		utilisation: number()
+		kind: literal("capacity"),
+		sessions: number(),
+		minSessions: number()
 	}),
 	object({
 		kind: literal("tie-faster"),
@@ -28260,16 +28130,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 	}),
 	object({
 		kind: literal("no-fit-lightest"),
-		utilisation: number()
+		sessions: number(),
+		minSessions: number()
 	}),
 	object({
 		kind: literal("derived-latency"),
 		modelId: string()
 	}),
-	object({
-		kind: literal("estimated-load"),
-		observedForMs: number().nullable()
-	}),
 	object({ kind: literal("cpu-device") }),
 	object({ kind: literal("coral-untouched") }),
 	object({ kind: literal("device-disabled") }),
@@ -28285,28 +28152,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 		format: ModelFormatSchema$1
 	})
 ]);
-var DeviceDemandSchema = object({
-	nodeId: string(),
-	deviceKey: string(),
-	demandFps: number(),
-	maxCameraFps: number(),
-	alwaysOnCameras: number(),
-	onMotionSessions: number(),
-	onMotionSource: _enum([
-		"observed-24h",
-		"estimate",
-		"none"
-	]),
-	observedForMs: number().nullable(),
-	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
-	placement: SessionPlacementPolicySchema
-});
 var DeviceModelChoiceSchema = object({
 	modelId: string(),
 	p50Ms: number(),
 	fps: number(),
 	measured: boolean(),
-	utilisation: number(),
+	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
+	capacitySessions: number(),
 	personRecall: number()
 });
 var DeviceRecommendationSchema = object({
@@ -28314,7 +28166,6 @@ var DeviceRecommendationSchema = object({
 	accelerator: AcceleratorKindSchema.nullable(),
 	enabled: boolean(),
 	available: boolean(),
-	demand: DeviceDemandSchema.nullable(),
 	chosen: DeviceModelChoiceSchema.nullable(),
 	reasons: array(RecommendationReasonSchema).readonly()
 });
@@ -28375,20 +28226,20 @@ var AutoTuneOptionsSchema = object({
 	/** Share of each accelerator's throughput kept free (0.3–0.5). */
 	headroom: number().min(.3).max(.5).default(.4),
 	/**
-	* What-if shares (D748): plan as if these node/device shares were stored
-	* and the policy were `share`. Absent = the stored shares under the stored
-	* policy. A what-if plan is for display; apply always re-plans from what
-	* is stored.
+	* The least number of parallel sessions every device must sustain at the
+	* camera rate with the headroom kept free (D755). The most accurate model
+	* that reaches it wins.
 	*/
-	shares: LoadBalancingSharesInputSchema.optional()
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
 var AutoTunePlanSchema = object({
 	/** Hash of everything the apply will write — the apply refuses a different one. */
 	planHash: string(),
 	family: literal("yolov9"),
 	headroom: number(),
-	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
-	whatIf: boolean(),
+	minSessionsPerDevice: number(),
+	/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
+	cameraFps: number(),
 	generatedAt: number(),
 	nodes: array(NodeRecommendationSchema).readonly(),
 	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
@@ -28398,7 +28249,8 @@ var AutoTunePlanSchema = object({
 });
 var AutoTuneApplyInputSchema = object({
 	planHash: string(),
-	headroom: number().min(.3).max(.5).default(.4)
+	headroom: number().min(.3).max(.5).default(.4),
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
 var AutoTunePhaseResultSchema = object({
 	phase: _enum([
@@ -28430,6 +28282,177 @@ var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
 		reason: _enum(["apply-in-progress"])
 	})
 ]);
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
+var LoadBalancingSharesInputSchema = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+/**
+* Where an automatic share's capacity comes from (D755).
+*  - `hardware` — the static capacity of each device at its Auto tune model:
+*    the measured latency table for the node's hardware class.
+*  - `benchmark` — the node's own measured capacity (node benchmark results).
+*    A node with no results falls back to `hardware`, and says so.
+*/
+var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
+/** Why a node under the `benchmark` source was sized from hardware instead. */
+var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
+var SuggestSharesInputSchema = object({
+	headroom: number().min(.3).max(.5).default(.4),
+	/** Default `hardware`. */
+	source: CapacitySourceSchema.default("hardware")
+});
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
+	fps: number().nullable(),
+	/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
+	measured: boolean(),
+	/**
+	* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
+	* or the benchmark's measured max sessions. Never enforced.
+	*/
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable(),
+	/** What this node's capacity was read from; null when the node is skipped. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Set when the `benchmark` source was asked for and this node used `hardware`. */
+	capacityFallback: CapacityFallbackSchema.nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** The source asked for; each node says what it actually used. */
+	source: CapacitySourceSchema,
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** The Auto tune capacity floor the models were picked at. */
+	minSessionsPerDevice: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* Where the node and device shares come from (D750, D755).
+*  - `hardware` (default) — computed by the system from each node's static
+*    capacity (its accelerators at their Auto tune models, from the measured
+*    latency table), recomputed whenever a node or device joins, leaves, is
+*    switched on or off, or changes model. No load input.
+*  - `benchmark` — the same, from each node's measured capacity (node
+*    benchmark results); a node without results falls back to `hardware`.
+*  - `manual` — the operator's stored sliders.
+* Either way a node or device that cannot take sessions gives its share to
+* the others in proportion; the stored values are never rewritten for that.
+*/
+var ShareSourceSchema = _enum([
+	"hardware",
+	"benchmark",
+	"manual"
+]);
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Automatic `benchmark`: why this node used `hardware` instead. */
+	capacityFallback: CapacityFallbackSchema.nullable(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -29841,8 +29864,10 @@ var CameraStepOverridePatchSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
+var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
 var CameraPipelineSettingsSchema = object({
 	stepToggles: record(string(), boolean()).optional(),
+	stepSettings: CameraStepSettingsSchema.optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
@@ -30608,9 +30633,11 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Auto tune (D745) — DRY RUN. Recommends ONE detector family (YOLOv9)
-		* for the whole cluster from each node's static hardware class, the
-		* measured latency table and the detection demand, and lists every write
+		* Auto tune (D745, D755) — DRY RUN. Recommends ONE detector family
+		* (YOLOv9) for the whole cluster from each node's static hardware class
+		* and the measured latency table: per device, the most accurate model
+		* that sustains at least `minSessionsPerDevice` parallel sessions at the
+		* camera rate with the headroom kept free (no load input), and lists every write
 		* the apply would make: the node model pins set, the enrichment pins and
 		* model-bound thresholds removed (node level and per camera), and the
 		* per-camera detector thresholds cleared. Writes nothing. Step
@@ -30649,10 +30676,12 @@ var pipelineOrchestratorCapability = {
 		*/
 		getPlacementStats: method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }),
 		/**
-		* Load balancing (D748) — shares proportional to each node's measured
-		* capacity at the models Auto tune would pick, iterated (≤ 3 rounds)
-		* until the shares stop moving; per device, an ADVISORY session cap.
-		* Writes nothing.
+		* Load balancing (D748, D755) — shares proportional to each node's
+		* capacity in parallel sessions: from the latency table at the models
+		* Auto tune picks (`hardware`), or from node benchmark results
+		* (`benchmark`, each node without results falling back to `hardware` and
+		* saying so). The automatic shares are exactly this answer. Per device,
+		* an ADVISORY session cap. Writes nothing.
 		*/
 		suggestShares: method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }),
 		/**
@@ -30663,9 +30692,11 @@ var pipelineOrchestratorCapability = {
 		*/
 		getEffectiveShares: method(_void(), EffectiveSharesSchema, { auth: "admin" }),
 		/**
-		* Load balancing (D750) — switch between automatic and manual shares.
-		* Going manual seeds the sliders with the current automatic shares (one
-		* atomic write), so nothing jumps; going automatic recomputes at once.
+		* Load balancing (D750, D755) — switch the share source: `hardware`
+		* (automatic, from static capacity), `benchmark` (automatic, from node
+		* benchmark results) or `manual`. Going manual seeds the sliders with the
+		* current automatic shares (one atomic write), so nothing jumps; going
+		* to an automatic source recomputes at once.
 		*/
 		setShareSource: method(SetShareSourceInputSchema, object({ success: literal(true) }), {
 			kind: "mutation",
@@ -30700,6 +30731,22 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Write or clear one step's CAMERA-WIDE settings (D754) — the fields this
+		* camera overrides on every accelerator it runs on. `settings` is the
+		* whole field-level bag for that step (only the overridden keys; a
+		* model-bound field travels with its binding key); `null` or `{}` clears
+		* it. Merged at dispatch between the node base and the per-(node,device)
+		* override, key by key.
+		*/
+		setCameraStepSettings: method(object({
+			deviceId: number(),
+			addonId: string(),
+			settings: record(string(), unknown()).nullable()
+		}), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
 		setCameraPipelineForAgent: method(object({
 			deviceId: number(),
@@ -52040,6 +52087,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraStepSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -57664,6 +57717,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",