c8y-nitro 0.10.3 → 0.11.0

package/dist/scope-CxEPZ74p.mjs

@@ -0,0 +1,2763 @@
+import { t as DEFAULTS } from "./defaults-CrrCinRJ.mjs";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { TestRunner, beforeEach } from "vitest";
+// src/testing/store.ts
+const CHILD_KINDS = [
+	"childDevices",
+	"childAssets",
+	"childAdditions"
+];
+const PARENT_KIND = {
+	childDevices: "deviceParents",
+	childAssets: "assetParents",
+	childAdditions: "additionParents"
+};
+function emptyTenant(tenant) {
+	return {
+		tenant,
+		managedObjects: /* @__PURE__ */ new Map(),
+		children: /* @__PURE__ */ new Map(),
+		externalIds: [],
+		measurements: /* @__PURE__ */ new Map(),
+		events: /* @__PURE__ */ new Map(),
+		alarms: /* @__PURE__ */ new Map(),
+		operations: /* @__PURE__ */ new Map(),
+		binaries: /* @__PURE__ */ new Map(),
+		eventBinaries: /* @__PURE__ */ new Map()
+	};
+}
+const store = {
+	nextId: 1,
+	tenants: /* @__PURE__ */ new Map(),
+	/**
+	* Refs from `c8y.device()`/`c8y.managedObject()` → ids in the current test.
+	*/
+	refs: /* @__PURE__ */ new Map(),
+	/**
+	* True while a test's arranged data is rebuilt: no notifications then.
+	*/
+	silent: false,
+	reset() {
+		this.nextId = 1;
+		this.tenants.clear();
+		this.refs.clear();
+	},
+	tenant(tenant) {
+		let data = this.tenants.get(tenant);
+		if (!data) {
+			data = emptyTenant(tenant);
+			this.tenants.set(tenant, data);
+		}
+		return data;
+	},
+	newId() {
+		return String(this.nextId++);
+	},
+	now() {
+		return (/* @__PURE__ */ new Date()).toISOString();
+	}
+};
+/**
+* Child ids of a managed object.
+* @param data - Tenant data
+* @param parentId - Managed object id
+* @param kind - Relation kind
+*/
+function childIds(data, parentId, kind) {
+	return data.children.get(parentId)?.[kind] ?? [];
+}
+/**
+* Parent ids of a managed object for a relation kind.
+* @param data - Tenant data
+* @param childId - Managed object id
+* @param kind - Relation kind (the parent's children list)
+*/
+function parentIds(data, childId, kind) {
+	const parents = [];
+	for (const [parentId, relations] of data.children) if (relations[kind].includes(childId)) parents.push(parentId);
+	return parents;
+}
+/**
+* Adds a child reference (idempotent).
+* @param data - Tenant data
+* @param parentId - Parent managed object id
+* @param kind - Relation kind
+* @param childId - Child managed object id
+*/
+function addChild(data, parentId, kind, childId) {
+	let relations = data.children.get(parentId);
+	if (!relations) {
+		relations = {
+			childDevices: [],
+			childAssets: [],
+			childAdditions: []
+		};
+		data.children.set(parentId, relations);
+	}
+	if (!relations[kind].includes(childId)) relations[kind].push(childId);
+}
+/**
+* Removes a child reference.
+* @param data - Tenant data
+* @param parentId - Parent managed object id
+* @param kind - Relation kind
+* @param childId - Child managed object id
+* @returns Whether the reference existed
+*/
+function removeChild(data, parentId, kind, childId) {
+	const relations = data.children.get(parentId);
+	const index = relations?.[kind].indexOf(childId) ?? -1;
+	if (index === -1) return false;
+	relations[kind].splice(index, 1);
+	return true;
+}
+/**
+* Deletes a managed object, its references (both directions), and its
+* external ids. Measurements, events, alarms, and operations of the object are
+* kept (documented assumption).
+* @param data - Tenant data
+* @param id - Managed object id
+*/
+function deleteManagedObject(data, id) {
+	if (!data.managedObjects.delete(id)) return false;
+	data.children.delete(id);
+	for (const relations of data.children.values()) for (const kind of CHILD_KINDS) relations[kind] = relations[kind].filter((childId) => childId !== id);
+	data.externalIds = data.externalIds.filter((entry) => entry.managedObjectId !== id);
+	data.binaries.delete(id);
+	return true;
+}
+// src/testing/capabilities.generated.ts
+/**
+* Query parameters and required body fields of the endpoints the fake tenant emulates.
+*/
+const C8Y_ENDPOINTS = {
+	"GET /inventory/managedObjects": { query: [
+		"childAdditionId",
+		"childAssetId",
+		"childDeviceId",
+		"currentPage",
+		"fragmentType",
+		"ids",
+		"onlyRoots",
+		"owner",
+		"pageSize",
+		"q",
+		"query",
+		"skipChildrenNames",
+		"text",
+		"type",
+		"withChildren",
+		"withChildrenCount",
+		"withGroups",
+		"withLatestValues",
+		"withParents",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /inventory/managedObjects": { query: [] },
+	"GET /inventory/managedObjects/{id}": { query: [
+		"skipChildrenNames",
+		"withChildren",
+		"withChildrenCount",
+		"withLatestValues",
+		"withParents"
+	] },
+	"PUT /inventory/managedObjects/{id}": { query: [] },
+	"DELETE /inventory/managedObjects/{id}": { query: [
+		"cascade",
+		"forceCascade",
+		"withDeviceUser"
+	] },
+	"GET /inventory/managedObjects/{id}/childDevices": { query: [
+		"currentPage",
+		"pageSize",
+		"query",
+		"withChildren",
+		"withChildrenCount",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /inventory/managedObjects/{id}/childDevices": { query: [] },
+	"GET /inventory/managedObjects/{id}/childAssets": { query: [
+		"currentPage",
+		"pageSize",
+		"query",
+		"withChildren",
+		"withChildrenCount",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /inventory/managedObjects/{id}/childAssets": { query: [] },
+	"GET /inventory/managedObjects/{id}/childAdditions": { query: [
+		"currentPage",
+		"pageSize",
+		"query",
+		"withChildren",
+		"withChildrenCount",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /inventory/managedObjects/{id}/childAdditions": { query: [] },
+	"DELETE /inventory/managedObjects/{id}/childDevices/{childId}": { query: [] },
+	"DELETE /inventory/managedObjects/{id}/childAssets/{childId}": { query: [] },
+	"DELETE /inventory/managedObjects/{id}/childAdditions/{childId}": { query: [] },
+	"GET /identity/externalIds/{type}/{externalId}": { query: [] },
+	"DELETE /identity/externalIds/{type}/{externalId}": { query: [] },
+	"GET /identity/globalIds/{id}/externalIds": { query: [] },
+	"POST /identity/globalIds/{id}/externalIds": {
+		query: [],
+		required: ["externalId", "type"]
+	},
+	"GET /measurement/measurements": { query: [
+		"currentPage",
+		"dateFrom",
+		"dateTo",
+		"pageSize",
+		"revert",
+		"source",
+		"type",
+		"valueFragmentSeries",
+		"valueFragmentType",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /measurement/measurements": {
+		query: [],
+		required: [
+			"source",
+			"time",
+			"type"
+		]
+	},
+	"GET /measurement/measurements/{id}": { query: [] },
+	"DELETE /measurement/measurements/{id}": { query: [] },
+	"GET /event/events": { query: [
+		"createdFrom",
+		"createdTo",
+		"currentPage",
+		"dateFrom",
+		"dateTo",
+		"fragmentType",
+		"fragmentValue",
+		"lastUpdatedFrom",
+		"lastUpdatedTo",
+		"pageSize",
+		"revert",
+		"source",
+		"type",
+		"withSourceAdditions",
+		"withSourceAssets",
+		"withSourceChildren",
+		"withSourceDevices",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /event/events": {
+		query: [],
+		required: [
+			"source",
+			"text",
+			"time",
+			"type"
+		]
+	},
+	"GET /event/events/{id}": { query: [] },
+	"PUT /event/events/{id}": { query: [] },
+	"DELETE /event/events/{id}": { query: [] },
+	"GET /alarm/alarms": { query: [
+		"createdFrom",
+		"createdTo",
+		"currentPage",
+		"dateFrom",
+		"dateTo",
+		"lastUpdatedFrom",
+		"lastUpdatedTo",
+		"pageSize",
+		"resolved",
+		"severity",
+		"source",
+		"status",
+		"type",
+		"withSourceAdditions",
+		"withSourceAssets",
+		"withSourceChildren",
+		"withSourceDevices",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /alarm/alarms": {
+		query: [],
+		required: [
+			"severity",
+			"source",
+			"text",
+			"time",
+			"type"
+		]
+	},
+	"PUT /alarm/alarms": { query: [
+		"createdFrom",
+		"createdTo",
+		"dateFrom",
+		"dateTo",
+		"resolved",
+		"severity",
+		"source",
+		"status",
+		"withSourceAdditions",
+		"withSourceAssets",
+		"withSourceChildren",
+		"withSourceDevices"
+	] },
+	"GET /alarm/alarms/{id}": { query: [] },
+	"PUT /alarm/alarms/{id}": { query: [] },
+	"GET /devicecontrol/operations": { query: [
+		"agentId",
+		"bulkOperationId",
+		"currentPage",
+		"dateFrom",
+		"dateTo",
+		"deviceId",
+		"fragmentType",
+		"pageSize",
+		"revert",
+		"status",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"POST /devicecontrol/operations": {
+		query: [],
+		required: ["deviceId"]
+	},
+	"GET /devicecontrol/operations/{id}": { query: [] },
+	"PUT /devicecontrol/operations/{id}": {
+		query: [],
+		required: ["status"]
+	},
+	"DELETE /measurement/measurements": { query: [
+		"dateFrom",
+		"dateTo",
+		"fragmentType",
+		"source",
+		"type"
+	] },
+	"GET /measurement/measurements/series": { query: [
+		"aggregationFunction",
+		"aggregationInterval",
+		"aggregationType",
+		"dateFrom",
+		"dateTo",
+		"revert",
+		"series",
+		"source"
+	] },
+	"DELETE /event/events": { query: [
+		"createdFrom",
+		"createdTo",
+		"dateFrom",
+		"dateTo",
+		"fragmentType",
+		"source",
+		"type"
+	] },
+	"POST /event/events/{id}/binaries": { query: [] },
+	"GET /event/events/{id}/binaries": { query: [] },
+	"PUT /event/events/{id}/binaries": { query: [] },
+	"DELETE /event/events/{id}/binaries": { query: [] },
+	"POST /inventory/binaries": {
+		query: [],
+		required: ["file", "object"]
+	},
+	"GET /inventory/binaries": { query: [
+		"childAdditionId",
+		"childAssetId",
+		"childDeviceId",
+		"currentPage",
+		"ids",
+		"owner",
+		"pageSize",
+		"type",
+		"withTotalPages"
+	] },
+	"GET /inventory/binaries/{id}": { query: [] },
+	"PUT /inventory/binaries/{id}": { query: [] },
+	"DELETE /inventory/binaries/{id}": { query: [] },
+	"POST /notification2/subscriptions": {
+		query: [],
+		required: ["context", "subscription"]
+	},
+	"GET /notification2/subscriptions": { query: [
+		"context",
+		"currentPage",
+		"pageSize",
+		"source",
+		"subscription",
+		"typeFilter",
+		"withTotalElements",
+		"withTotalPages"
+	] },
+	"DELETE /notification2/subscriptions": { query: ["context", "source"] },
+	"GET /notification2/subscriptions/{id}": { query: [] },
+	"DELETE /notification2/subscriptions/{id}": { query: [] },
+	"POST /notification2/token": {
+		query: [],
+		required: ["subscriber", "subscription"]
+	},
+	"POST /notification2/unsubscribe": { query: ["token"] }
+};
+/**
+* Enum values from the spec.
+*/
+const C8Y_ENUMS = {
+	alarmSeverity: [
+		"CRITICAL",
+		"MAJOR",
+		"MINOR",
+		"WARNING"
+	],
+	alarmStatus: [
+		"ACTIVE",
+		"ACKNOWLEDGED",
+		"CLEARED"
+	],
+	operationStatus: [
+		"SUCCESSFUL",
+		"FAILED",
+		"EXECUTING",
+		"PENDING"
+	],
+	seriesAggregationType: [
+		"DAILY",
+		"HOURLY",
+		"MINUTELY"
+	],
+	seriesAggregationFunction: [
+		"min",
+		"max",
+		"avg",
+		"sum",
+		"count",
+		"stdDevPop",
+		"stdDevSamp"
+	]
+};
+// src/testing/api/http.ts
+/**
+* Thrown by an API handler for a request the fake cannot answer faithfully
+* (an endpoint feature it does not emulate). The test fails with the reason.
+*/
+var UnsupportedRequestError = class extends Error {};
+const rawRequests = /* @__PURE__ */ new WeakMap();
+/**
+* The raw parts of a request.
+* @param call - The request
+*/
+function raw(call) {
+	return rawRequests.get(call) ?? {
+		bytes: /* @__PURE__ */ new Uint8Array(),
+		contentType: "",
+		params: new URLSearchParams(call.query)
+	};
+}
+/**
+* Base URL used in `self`/`next` links.
+*/
+function baseUrl() {
+	return (process.env.C8Y_BASEURL || DEFAULTS.baseUrl).replace(/\/+$/, "");
+}
+/**
+* Cumulocity-style error response.
+* @param status - HTTP status
+* @param error - Error code, e.g. `inventory/Not Found`
+* @param message - Human-readable message
+*/
+function apiError(status, error, message) {
+	return Object.assign(Response.json({
+		error,
+		message,
+		info: "https://cumulocity.com/guides/reference/rest-implementation"
+	}, { status }), { message });
+}
+/**
+* Validates query parameters against the spec: parameters the real endpoint
+* knows but the fake does not emulate fail loudly; unknown parameters are
+* ignored, like the real API does.
+* @param endpoint - Endpoint key, e.g. `GET /inventory/managedObjects`
+* @param call - The request
+* @param supported - Parameters this fake endpoint emulates
+*/
+function checkQuery(endpoint, call, supported) {
+	const known = C8Y_ENDPOINTS[endpoint].query;
+	for (const [name, value] of Object.entries(call.query)) if (known.includes(name) && !supported.includes(name) && value !== "" && value !== "false") throw new UnsupportedRequestError(`query parameter "${name}" of ${endpoint} is not emulated`);
+}
+/**
+* Returns a 422 response if required body fields (from the spec) are missing.
+* @param endpoint - Endpoint key
+* @param body - Request body
+*/
+function checkRequired(endpoint, body) {
+	const missing = (C8Y_ENDPOINTS[endpoint].required ?? []).filter((field) => body[field] === void 0 || body[field] === null);
+	if (missing.length > 0) return apiError(422, "undefined/validationError", `Following mandatory fields should be included: ${missing.join(",")}`);
+}
+/**
+* Reads a boolean query parameter.
+* @param call
+* @param name
+* @param fallback
+*/
+function flag(call, name, fallback = false) {
+	const value = call.query[name];
+	return value === void 0 ? fallback : value === "true";
+}
+/**
+* Builds a paged collection response like Cumulocity's: `statistics`, `self`,
+* and `next`/`prev` links (`next` always, `prev` after the first page).
+* @param call - The request (paging params)
+* @param collection - Property name, e.g. `managedObjects`
+* @param items - All matching items, in result order
+* @param path - Collection path, e.g. `/inventory/managedObjects`
+* @param options - Paging options
+* @param options.statistics - `binaries`: always `totalPages`, never `totalElements`
+*/
+function paged(call, collection, items, path, options = {}) {
+	for (const name of ["pageSize", "currentPage"]) {
+		const value = call.query[name];
+		if (value !== void 0 && !/^-?\d+$/.test(value)) return apiError(422, "undefined/validationError", `Parameter '${name}' must have an integer value!`);
+	}
+	const pageSize = Math.min(Math.max(Number.parseInt(call.query.pageSize ?? "5", 10), 1), 2e3);
+	const currentPage = Math.max(Number.parseInt(call.query.currentPage ?? "1", 10), 1);
+	const page = items.slice((currentPage - 1) * pageSize, currentPage * pageSize);
+	const link = (pageNumber) => {
+		const params = new URLSearchParams({
+			...call.query,
+			pageSize: String(pageSize),
+			currentPage: String(pageNumber)
+		});
+		return `${baseUrl()}${path}?${params}`;
+	};
+	const statistics = {
+		currentPage,
+		pageSize
+	};
+	const totalPages = Math.ceil(items.length / pageSize);
+	const withTotalPages = options.statistics === "binaries" || flag(call, "withTotalPages");
+	if (withTotalPages) statistics.totalPages = totalPages;
+	if (options.statistics !== "binaries" && flag(call, "withTotalElements")) statistics.totalElements = items.length;
+	return Response.json({
+		self: link(currentPage),
+		[collection]: page,
+		statistics,
+		...withTotalPages && currentPage >= totalPages ? {} : { next: link(currentPage + 1) },
+		...currentPage > 1 ? { prev: link(currentPage - 1) } : {}
+	});
+}
+/**
+* Filters documents by an inclusive-from, exclusive-to date range on a field.
+* @param value - ISO date of the document
+* @param from - Range start (inclusive)
+* @param to - Range end (exclusive)
+*/
+function inRange(value, from, to) {
+	const time = Date.parse(String(value));
+	if (from !== void 0 && time < Date.parse(from)) return false;
+	if (to !== void 0 && time >= Date.parse(to)) return false;
+	return true;
+}
+/**
+* Sorts documents by a date field.
+* @param items - Documents
+* @param field - Date field
+* @param newestFirst - Sort descending
+*/
+function byTime(items, field, newestFirst) {
+	return [...items].sort((a, b) => {
+		const diff = Date.parse(String(a[field])) - Date.parse(String(b[field]));
+		return newestFirst ? -diff : diff;
+	});
+}
+/**
+* The source id of a measurement/event/alarm.
+* @param document
+*/
+function sourceId(document) {
+	return document.source?.id;
+}
+// src/testing/api/query.ts
+/**
+* A query the platform would reject (answered with 422).
+*/
+var QuerySyntaxError = class extends Error {};
+const COMPARISONS = /* @__PURE__ */ new Set([
+	"eq",
+	"gt",
+	"ge",
+	"lt",
+	"le"
+]);
+function tokenize(input) {
+	const tokens = [];
+	let i = 0;
+	while (i < input.length) {
+		const char = input[i];
+		if (/\s/.test(char)) i++;
+		else if (char === "(" || char === ")" || char === ",") {
+			tokens.push({
+				kind: "punct",
+				value: char
+			});
+			i++;
+		} else if (char === "'") {
+			let value = "";
+			i++;
+			while (i < input.length) if (input[i] === "'" && input[i + 1] === "'") {
+				value += "'";
+				i += 2;
+			} else if (input[i] === "'") break;
+			else value += input[i++];
+			if (i >= input.length) throw new QuerySyntaxError("unterminated string");
+			i++;
+			tokens.push({
+				kind: "string",
+				value
+			});
+		} else {
+			const value = /^[^\s(),']+/.exec(input.slice(i))[0];
+			tokens.push({
+				kind: "word",
+				value
+			});
+			i += value.length;
+		}
+	}
+	return tokens;
+}
+function literal(token) {
+	if (token.kind === "string") return token.value;
+	if (token.value === "null") return null;
+	if (token.value === "true" || token.value === "false") return token.value === "true";
+	if (/^-?\d+[fd]?$/i.test(token.value)) return Number.parseInt(token.value, 10);
+	const decimal = /^(-?\d+\.\d+)[fd]$/i.exec(token.value);
+	if (decimal) return Number(decimal[1]);
+	return token.value;
+}
+/**
+* Reads a dotted path from a document. Arrays on the way are flattened, so the
+* result is a list of all values at that path.
+* @param document - The document
+* @param path - e.g. `c8y_Hardware.serialNumber` or `customers.id`
+*/
+function readValues(document, path) {
+	let values = [document];
+	for (const key of path.split(".")) values = values.flatMap((value) => {
+		return (Array.isArray(value) ? value : [value]).flatMap((item) => item && typeof item === "object" && key in item ? [item[key]] : []);
+	});
+	return values.flatMap((value) => Array.isArray(value) ? value : [value]);
+}
+/**
+* Reads a single value from a dotted path (first match).
+* @param document - The document
+* @param path - Dotted path
+*/
+function readPath(document, path) {
+	return readValues(document, path)[0];
+}
+function compareOne(actual, operator, expected, asDate) {
+	if (expected === null) return operator === "eq" && actual === null;
+	if (actual === null || actual === void 0 || typeof actual === "object") return false;
+	if (asDate) {
+		const left = Date.parse(String(actual));
+		const right = Date.parse(String(expected));
+		switch (operator) {
+			case "eq": return left === right;
+			case "gt": return left > right;
+			case "ge": return left >= right;
+			case "lt": return left < right;
+			default: return left <= right;
+		}
+	}
+	if (typeof actual !== typeof expected) return false;
+	if (operator === "eq") {
+		if (typeof expected === "string" && expected.includes("*")) {
+			const pattern = expected.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+			return new RegExp(`^${pattern}$`, "i").test(String(actual));
+		}
+		return actual === expected;
+	}
+	if (typeof expected === "boolean") return false;
+	const left = actual;
+	const right = expected;
+	switch (operator) {
+		case "gt": return left > right;
+		case "ge": return left >= right;
+		case "lt": return left < right;
+		default: return left <= right;
+	}
+}
+function descendants(data, roots) {
+	const result = /* @__PURE__ */ new Set();
+	const queue = [...roots];
+	while (queue.length > 0) {
+		const id = queue.shift();
+		if (result.has(id)) continue;
+		result.add(id);
+		for (const kind of CHILD_KINDS) queue.push(...childIds(data, id, kind));
+	}
+	return result;
+}
+function parseFilter(input, data) {
+	const tokens = tokenize(input);
+	let position = 0;
+	const peek = () => tokens[position];
+	const next = () => {
+		const token = tokens[position++];
+		if (!token) throw new QuerySyntaxError("unexpected end");
+		return token;
+	};
+	const expect = (value) => {
+		if (next().value !== value) throw new QuerySyntaxError(`expected "${value}"`);
+	};
+	const argumentList = () => {
+		expect("(");
+		const args = [];
+		while (peek()?.value !== ")") {
+			args.push(next().value);
+			if (peek()?.value === ",") next();
+		}
+		expect(")");
+		if (args.length === 0) throw new QuerySyntaxError("missing function argument");
+		return args;
+	};
+	function parseOr() {
+		let left = parseAnd();
+		while (peek()?.kind === "word" && peek().value === "or") {
+			next();
+			const a = left;
+			const b = parseAnd();
+			left = (document) => a(document) || b(document);
+		}
+		return left;
+	}
+	function parseAnd() {
+		let left = parseUnary();
+		while (peek()?.kind === "word" && peek().value === "and") {
+			next();
+			const a = left;
+			const b = parseUnary();
+			left = (document) => a(document) && b(document);
+		}
+		return left;
+	}
+	function parseUnary() {
+		const token = next();
+		if (token.value === "(") {
+			const inner = parseOr();
+			expect(")");
+			return inner;
+		}
+		if (token.kind !== "word") throw new QuerySyntaxError(`unexpected "${token.value}"`);
+		if (token.value === "not") {
+			expect("(");
+			const inner = parseOr();
+			expect(")");
+			return (document) => !inner(document);
+		}
+		if (peek()?.value === "(") {
+			const args = argumentList();
+			switch (token.value) {
+				case "has":
+					if (args.length !== 1) throw new QuerySyntaxError("has() accepts one argument");
+					return (document) => readValues(document, args[0]).length > 0;
+				case "hasany": return (document) => args.some((fragment) => readValues(document, fragment).length > 0);
+				case "bygroupid": return (document) => args.some((group) => childIds(data, group, "childAssets").includes(String(document.id)));
+				case "isinhierarchyof": return (document) => descendants(data, args).has(String(document.id));
+				default: throw new QuerySyntaxError(`unknown function ${token.value}()`);
+			}
+		}
+		const operator = next();
+		if (!COMPARISONS.has(operator.value)) throw new QuerySyntaxError(`unknown operator "${operator.value}"`);
+		const value = literal(next());
+		const asDate = token.value.endsWith(".date");
+		const path = asDate ? token.value.slice(0, -5) : token.value;
+		return (document) => {
+			const values = readValues(document, path);
+			return values.length === 0 ? compareOne(void 0, operator.value, value, asDate) : values.some((actual) => compareOne(actual, operator.value, value, asDate));
+		};
+	}
+	const filter = parseOr();
+	if (position < tokens.length) throw new QuerySyntaxError(`unexpected "${tokens[position].value}"`);
+	return filter;
+}
+/**
+* Parses a `query`/`q` parameter value.
+* @param raw - e.g. `$filter=(name eq 'Pump*') $orderby=name asc`
+* @param data - Tenant data (for `bygroupid()` and `isinhierarchyof()`)
+*/
+function parseQuery(raw, data) {
+	const orderByMatch = /\$orderby=(.*)$/.exec(raw);
+	const filterSource = (/\$filter=(.*?)(?:\s*\$orderby=.*)?$/.exec(raw)?.[1] ?? (orderByMatch ? raw.slice(0, orderByMatch.index) : raw)).trim();
+	const orderBy = (orderByMatch?.[1] ?? "").split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+		const [field, direction] = part.split(/\s+/);
+		return {
+			field,
+			descending: direction?.toLowerCase() === "desc"
+		};
+	});
+	return {
+		filter: filterSource ? parseFilter(filterSource, data) : () => true,
+		orderBy
+	};
+}
+/**
+* Sorts documents by `$orderby` fields.
+* @param items - Documents
+* @param orderBy - Sort fields
+*/
+function applyOrderBy(items, orderBy) {
+	if (orderBy.length === 0) return items;
+	const rank = (value) => value === void 0 || value === null ? 0 : typeof value === "number" ? 1 : 2;
+	return [...items].sort((a, b) => {
+		for (const { field, descending } of orderBy) {
+			let left = readPath(a, field);
+			let right = readPath(b, field);
+			if (field === "id") {
+				left = Number(left);
+				right = Number(right);
+			}
+			if (left === right || rank(left) === 0 && rank(right) === 0) continue;
+			const result = rank(left) !== rank(right) ? rank(left) - rank(right) : left < right ? -1 : 1;
+			return descending ? -result : result;
+		}
+		return 0;
+	});
+}
+// src/testing/realtime.ts
+/**
+* Notification 2.0 in the fake tenant: subscriptions, tokens, and consumer
+* WebSockets (in memory). Data changes are published to matching
+* subscriptions as frames in the platform's format:
+*
+* ```
+* <ackId>
+* /<tenant>/<api>/<sourceId>
+* CREATE | UPDATE | DELETE
+*
+* <JSON payload>
+* ```
+*
+* Unlike the data, this state lives as long as the test file's Nitro app: a
+* Nitro plugin that subscribes at startup stays subscribed for every test.
+* Undelivered notifications are dropped when the data is reset.
+*/
+/**
+* Set by the platform: requests being answered (handlers may be writing).
+*/
+let platformInflight = () => 0;
+function trackInflight(count) {
+	platformInflight = count;
+}
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+/**
+* Standard properties, which `fragmentsToCopy` always keeps (verified for
+* events; assumed for the other APIs).
+*/
+const STANDARD_FIELDS = /* @__PURE__ */ new Set([
+	"id",
+	"self",
+	"type",
+	"text",
+	"time",
+	"source",
+	"creationTime",
+	"lastUpdated",
+	"severity",
+	"status",
+	"count",
+	"firstOccurrenceTime",
+	"deviceId",
+	"deviceName",
+	"description",
+	"failureReason",
+	"name",
+	"owner"
+]);
+/**
+* With `fragmentsToCopy`, the platform delivers only the named fragments next
+* to the standard properties.
+* @param document - The rendered object
+* @param fragments - The subscription's `fragmentsToCopy`
+*/
+function copyFragments(document, fragments) {
+	if (!fragments || fragments.length === 0) return document;
+	return Object.fromEntries(Object.entries(document).filter(([key]) => STANDARD_FIELDS.has(key) || fragments.includes(key)));
+}
+function typesOf(typeFilter) {
+	if (!typeFilter) return;
+	const quoted = [...typeFilter.matchAll(/'([^']*)'/g)].map((match) => match[1]);
+	return quoted.length > 0 ? quoted : typeFilter.split(/\s+or\s+/).map((type) => type.trim());
+}
+const realtime = {
+	nextId: 1,
+	nextAck: 1,
+	subscriptions: [],
+	tokens: /* @__PURE__ */ new Map(),
+	sockets: /* @__PURE__ */ new Set(),
+	/**
+	* frames waiting for a consumer of a subscription name (persistent subscriptions)
+	*/
+	backlog: /* @__PURE__ */ new Map(),
+	/**
+	* delivered but not yet acknowledged frames, per socket
+	*/
+	unacked: /* @__PURE__ */ new Map(),
+	/**
+	* frames scheduled for delivery
+	*/
+	scheduled: 0,
+	createSubscription(subscription) {
+		const created = {
+			...subscription,
+			id: String(this.nextId++)
+		};
+		this.subscriptions.push(created);
+		return created;
+	},
+	createToken(token) {
+		const value = `fake-token-${this.nextId++}-${token.subscription}`;
+		this.tokens.set(value, token);
+		return value;
+	},
+	connect(socket) {
+		const token = this.tokens.get(new URL(socket.url).searchParams.get("token") ?? "");
+		if (!token || socket.readyState === CLOSED) {
+			socket.readyState = CLOSED;
+			socket.emit("error", /* @__PURE__ */ new Error("Invalid notification token"));
+			socket.emit("close", 1008, "invalid token");
+			return;
+		}
+		socket.token = token;
+		socket.readyState = OPEN;
+		this.sockets.add(socket);
+		this.unacked.set(socket, /* @__PURE__ */ new Set());
+		socket.emit("open");
+		const waiting = this.backlog.get(this.key(token.tenant, token.subscription)) ?? [];
+		this.backlog.delete(this.key(token.tenant, token.subscription));
+		for (const frame of waiting) this.deliver(socket, frame);
+	},
+	disconnect(socket) {
+		this.sockets.delete(socket);
+		this.unacked.delete(socket);
+	},
+	acknowledge(socket, ackId) {
+		this.unacked.get(socket)?.delete(ackId);
+	},
+	key(tenant, subscription) {
+		return `${tenant}\u0000${subscription}`;
+	},
+	deliver(socket, frame) {
+		this.scheduled++;
+		setTimeout(() => {
+			this.scheduled--;
+			if (socket.readyState !== OPEN) return;
+			this.unacked.get(socket)?.add(frame.ackId);
+			socket.emit("message", Buffer.from(frame.text));
+		}, 0);
+	},
+	/**
+	* Publishes a data change to every matching subscription.
+	* @param tenant - Tenant of the data
+	* @param api - Notification API, e.g. `measurements`
+	* @param action - CREATE, UPDATE, or DELETE
+	* @param document - The rendered object (for DELETE: `{ id }` plus its source)
+	* @param sourceId - Device id the notification is about
+	*/
+	publish(tenant, api, action, document, sourceId) {
+		const names = /* @__PURE__ */ new Map();
+		for (const subscription of this.subscriptions) {
+			if (subscription.tenant !== tenant) continue;
+			const apis = subscription.subscriptionFilter?.apis ?? ["*"];
+			if (!apis.includes("*") && !apis.includes(api)) continue;
+			if (subscription.context === "mo" && subscription.source?.id !== sourceId) continue;
+			const types = typesOf(subscription.subscriptionFilter?.typeFilter);
+			if (types && !types.includes(String(document.type))) continue;
+			names.set(subscription.subscription, subscription);
+		}
+		for (const [name, subscription] of names) {
+			const ackId = String(this.nextAck++);
+			const payload = action === "DELETE" ? `com.cumulocity.notification.service.RealtimeDeletedObject$1@${(this.nextAck * 2654435761 >>> 0).toString(16)}` : JSON.stringify(copyFragments(document, subscription.fragmentsToCopy));
+			const frame = {
+				ackId,
+				text: `${ackId}\n/${tenant}/${api}/${sourceId ?? document.id}\n${action}\n\n${payload}`
+			};
+			const consumers = [...this.sockets].filter((socket) => socket.token?.tenant === tenant && socket.token.subscription === name);
+			if (consumers.length > 0) for (const socket of consumers) this.deliver(socket, frame);
+			else if (!subscription.nonPersistent) {
+				const key = this.key(tenant, name);
+				this.backlog.set(key, [...this.backlog.get(key) ?? [], frame]);
+			}
+		}
+	},
+	/**
+	* Notifications on their way to a consumer or not yet acknowledged.
+	*/
+	pending() {
+		let count = this.scheduled + platformInflight();
+		for (const acks of this.unacked.values()) count += acks.size;
+		for (const [key, frames] of this.backlog) {
+			const [tenant, subscription] = key.split("\0");
+			if ([...this.tokens.values()].some((token) => token.tenant === tenant && token.subscription === subscription)) count += frames.length;
+		}
+		return count;
+	},
+	/**
+	* Drops undelivered notifications (data reset between tests).
+	*/
+	dropPending() {
+		this.backlog.clear();
+		for (const acks of this.unacked.values()) acks.clear();
+	}
+};
+/**
+* In-memory stand-in for the `ws` WebSocket c8y-realtime opens for a consumer.
+*/
+var FakeWebSocket = class {
+	static CONNECTING = CONNECTING;
+	static OPEN = OPEN;
+	static CLOSING = CLOSING;
+	static CLOSED = CLOSED;
+	readyState = CONNECTING;
+	url;
+	token;
+	listeners = /* @__PURE__ */ new Map();
+	constructor(url) {
+		this.url = String(url);
+		setTimeout(() => realtime.connect(this), 0);
+	}
+	on(event, listener) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(listener);
+		return this;
+	}
+	addEventListener(event, listener) {
+		this.on(event, listener);
+	}
+	removeAllListeners() {
+		this.listeners.clear();
+		return this;
+	}
+	emit(event, ...args) {
+		for (const listener of [...this.listeners.get(event) ?? []]) listener(...args);
+	}
+	/**
+	* The consumer acknowledges a frame by sending its ack id.
+	* @param data
+	*/
+	send(data) {
+		realtime.acknowledge(this, String(data).trim());
+	}
+	ping() {
+		setTimeout(() => this.emit("pong"), 0);
+	}
+	close() {
+		if (this.readyState === CLOSED) return;
+		this.readyState = CLOSED;
+		realtime.disconnect(this);
+		setTimeout(() => this.emit("close", 1e3, ""), 0);
+	}
+	terminate() {
+		this.close();
+	}
+};
+/**
+* Waits until the service has finished starting up its realtime clients: no
+* platform request in flight, and every minted token has a connected socket.
+* @param timeout - Milliseconds to wait at most
+*/
+async function waitForRealtimeStartup(timeout = 3e3) {
+	const start = Date.now();
+	let quietTicks = 0;
+	while (quietTicks < 3 && Date.now() - start < timeout) {
+		await new Promise((resolve) => {
+			setTimeout(resolve, 5);
+		});
+		const connected = new Set([...realtime.sockets].map((socket) => socket.token));
+		quietTicks = platformInflight() === 0 && realtime.scheduled === 0 && [...realtime.tokens.values()].every((token) => connected.has(token)) ? quietTicks + 1 : 0;
+	}
+}
+// src/testing/notify.ts
+/**
+* Publishes a data change as a Notification 2.0 notification, unless the
+* change is part of rebuilding a test's arranged data (`store.silent`).
+* @param data - Tenant data the change happened in
+* @param api - Notification API
+* @param action - CREATE, UPDATE, or DELETE
+* @param document - Rendered object
+* @param sourceId - Device the notification is about
+*/
+function notify(data, api, action, document, sourceId) {
+	if (!store.silent) realtime.publish(data.tenant, api, action, document, sourceId);
+}
+// src/testing/api/inventory.ts
+const SERVER_FIELDS$1 = [
+	"id",
+	"self",
+	"creationTime",
+	"lastUpdated",
+	...CHILD_KINDS,
+	...Object.values(PARENT_KIND)
+];
+function moSelf(id) {
+	return `${baseUrl()}/inventory/managedObjects/${id}`;
+}
+function notFound$2(id) {
+	return apiError(404, "inventory/Not Found", `Finding device data from database failed : No managedObject for id '${id}'!`);
+}
+/**
+* Renders a stored managed object like the platform: `self`, child references
+* (`childDevices`, `childAssets`, `childAdditions`), and parent references.
+* @param data - Tenant data
+* @param document - Stored managed object
+* @param options - Rendering options
+* @param options.withChildren - Include child references (default true)
+* @param options.skipChildrenNames - Omit names in references
+* @param options.withParents
+*/
+function renderManagedObject(data, document, options = {}) {
+	const self = moSelf(document.id);
+	const reference = (id, referenceSelf) => ({
+		self: referenceSelf,
+		managedObject: {
+			id,
+			self: moSelf(id),
+			...options.skipChildrenNames ? {} : { name: data.managedObjects.get(id)?.name }
+		}
+	});
+	const rendered = {
+		...structuredClone(document),
+		self
+	};
+	for (const kind of CHILD_KINDS) {
+		const children = options.withChildren === false ? [] : childIds(data, document.id, kind);
+		rendered[kind] = {
+			self: `${self}/${kind}`,
+			references: children.map((id) => reference(id, `${self}/${kind}/${id}`))
+		};
+		const parentKind = PARENT_KIND[kind];
+		const parents = options.withParents ? parentIds(data, document.id, kind) : [];
+		rendered[parentKind] = {
+			self: `${self}/${parentKind}`,
+			references: parents.flatMap((id) => {
+				const parent = data.managedObjects.get(id);
+				return parent ? [{ managedObject: renderManagedObject(data, parent, { withChildren: false }) }] : [];
+			})
+		};
+	}
+	return rendered;
+}
+/**
+* Creates a managed object (server fields assigned, relation fields ignored).
+* @param data - Tenant data
+* @param body - Managed object fragments
+* @param owner - Owner user name
+*/
+function createManagedObject(data, body, owner) {
+	const now = store.now();
+	const document = {
+		id: store.newId(),
+		owner,
+		...omit(body, SERVER_FIELDS$1),
+		creationTime: now,
+		lastUpdated: now
+	};
+	if (typeof body.owner === "string") document.owner = body.owner;
+	data.managedObjects.set(document.id, document);
+	notify(data, "managedobjects", "CREATE", renderManagedObject(data, document), document.id);
+	return document;
+}
+function omit(body, fields) {
+	return Object.fromEntries(Object.entries(body).filter(([key]) => !fields.includes(key)));
+}
+/**
+* Full-text search as documented (and verified): the value is split into
+* tokens at whitespace and `/`, `-`, `.`; an object matches if any examined
+* property (id, type, name, owner, external ids) contains any of the tokens.
+* A value in double quotes searches for the exact phrase.
+* @param data - Tenant data
+* @param document - Managed object
+* @param text - Search value
+*/
+function searchText(data, document, text) {
+	const values = [
+		document.id,
+		document.type,
+		document.name,
+		document.owner,
+		...data.externalIds.filter((entry) => entry.managedObjectId === document.id).map((entry) => entry.externalId)
+	].filter((value) => typeof value === "string").map((value) => value.toLowerCase());
+	const phrase = /^"(.*)"$/.exec(text.trim());
+	if (phrase) return values.some((value) => value.includes(phrase[1].toLowerCase()));
+	const tokenize = (value) => value.toLowerCase().split(/[\s/.-]+/).filter(Boolean);
+	const tokens = new Set(values.flatMap(tokenize));
+	return tokenize(text).some((token) => tokens.has(token));
+}
+function listManagedObjects(call, data, documents) {
+	let items = documents;
+	const { query } = call;
+	if (query.type && query.query === void 0 && query.q === void 0) items = items.filter((document) => document.type === query.type);
+	if (query.fragmentType) items = items.filter((document) => document[query.fragmentType] !== void 0);
+	if (query.ids) {
+		const ids = query.ids.split(",");
+		items = items.filter((document) => ids.includes(document.id));
+	}
+	if (query.owner) items = items.filter((document) => document.owner === query.owner);
+	if (query.text) items = items.filter((document) => searchText(data, document, query.text));
+	for (const [param, kind] of [
+		["childDeviceId", "childDevices"],
+		["childAssetId", "childAssets"],
+		["childAdditionId", "childAdditions"]
+	]) if (query[param]) items = items.filter((document) => childIds(data, document.id, kind).includes(query[param]));
+	if (flag(call, "onlyRoots")) items = items.filter((document) => CHILD_KINDS.every((kind) => parentIds(data, document.id, kind).length === 0));
+	let orderBy = [];
+	for (const param of ["query", "q"]) if (query[param]) {
+		const parsed = parseQuery(query[param], data);
+		items = items.filter((document) => parsed.filter(document));
+		orderBy = parsed.orderBy;
+	}
+	if (query.q !== void 0) items = items.filter((document) => document.c8y_IsDevice !== void 0);
+	return applyOrderBy(items, orderBy);
+}
+const LIST_PARAMS = [
+	"childAdditionId",
+	"childAssetId",
+	"childDeviceId",
+	"currentPage",
+	"fragmentType",
+	"ids",
+	"onlyRoots",
+	"owner",
+	"pageSize",
+	"q",
+	"query",
+	"skipChildrenNames",
+	"text",
+	"type",
+	"withChildren",
+	"withParents",
+	"withTotalElements",
+	"withTotalPages"
+];
+const DETAIL_PARAMS = [
+	"skipChildrenNames",
+	"withChildren",
+	"withParents"
+];
+/**
+* Inventory API: managed objects and child references.
+* @param call - The request
+* @param segments - Path segments
+* @param data - Tenant data
+*/
+function inventory(call, segments, data) {
+	try {
+		return inventoryRequest(call, segments, data);
+	} catch (error) {
+		if (error instanceof QuerySyntaxError) return apiError(422, "inventory/Invalid Data", `Find by filter query failed : Query '${call.query.query ?? call.query.q}' could not be understood. Please try again.`);
+		throw error;
+	}
+}
+function inventoryRequest(call, segments, data) {
+	const [, , id, kind, childId] = segments;
+	const { method } = call;
+	const render = (document) => renderManagedObject(data, document, {
+		withChildren: flag(call, "withChildren", true),
+		skipChildrenNames: flag(call, "skipChildrenNames"),
+		withParents: flag(call, "withParents")
+	});
+	if (id === void 0) {
+		if (method === "GET") {
+			checkQuery("GET /inventory/managedObjects", call, LIST_PARAMS);
+			return paged(call, "managedObjects", listManagedObjects(call, data, [...data.managedObjects.values()]).map(render), "/inventory/managedObjects");
+		}
+		if (method === "POST") {
+			checkQuery("POST /inventory/managedObjects", call, []);
+			const document = createManagedObject(data, call.body ?? {}, call.user ?? "test-user");
+			return Response.json(render(document), { status: 201 });
+		}
+		return;
+	}
+	const document = data.managedObjects.get(id);
+	if (kind === void 0) {
+		if (method === "GET") {
+			checkQuery("GET /inventory/managedObjects/{id}", call, DETAIL_PARAMS);
+			return document ? Response.json(render(document)) : notFound$2(id);
+		}
+		if (method === "PUT") {
+			checkQuery("PUT /inventory/managedObjects/{id}", call, []);
+			if (!document) return notFound$2(id);
+			for (const [key, value] of Object.entries(omit(call.body ?? {}, SERVER_FIELDS$1))) if (value === null) delete document[key];
+			else document[key] = value;
+			document.lastUpdated = store.now();
+			notify(data, "managedobjects", "UPDATE", renderManagedObject(data, document), document.id);
+			return Response.json(render(document));
+		}
+		if (method === "DELETE") {
+			checkQuery("DELETE /inventory/managedObjects/{id}", call, []);
+			if (document?.c8y_IsBinary !== void 0) return apiError(422, "inventory/Invalid Data", "Cannot delete managed object. :  Cannot change binary metadata through inventory api.");
+			if (!deleteManagedObject(data, id)) return notFound$2(id);
+			notify(data, "managedobjects", "DELETE", { id }, id);
+			return new Response(null, { status: 204 });
+		}
+		return;
+	}
+	if (!CHILD_KINDS.includes(kind)) return;
+	const childKind = kind;
+	const endpoint = `/inventory/managedObjects/{id}/${childKind}`;
+	if (childId === void 0 && method === "GET") {
+		checkQuery(`GET ${endpoint}`, call, [
+			"currentPage",
+			"pageSize",
+			"query",
+			"withChildren",
+			"withTotalElements",
+			"withTotalPages"
+		]);
+		if (!document) return notFound$2(id);
+		let children = childIds(data, id, childKind).map((child) => data.managedObjects.get(child)).filter((child) => child !== void 0);
+		if (call.query.query) {
+			const parsed = parseQuery(call.query.query, data);
+			children = applyOrderBy(children.filter((child) => parsed.filter(child)), parsed.orderBy);
+		}
+		return paged(call, "references", children.map((child) => ({
+			self: `${moSelf(id)}/${childKind}/${child.id}`,
+			managedObject: render(child)
+		})), `/inventory/managedObjects/${id}/${childKind}`);
+	}
+	if (childId === void 0 && method === "POST") {
+		checkQuery(`POST ${endpoint}`, call, []);
+		if (!document) return notFound$2(id);
+		const body = call.body ?? {};
+		if ((call.headers["content-type"] ?? "").toLowerCase().includes("managedobject+json")) {
+			const child = createManagedObject(data, body, call.user ?? "test-user");
+			addChild(data, id, childKind, child.id);
+			return Response.json(render(child), { status: 201 });
+		}
+		const requested = Array.isArray(body.references) ? body.references.map((reference) => String(reference.managedObject?.id)) : [String(body.managedObject?.id)];
+		for (const child of requested) if (!data.managedObjects.has(child)) return notFound$2(child);
+		const references = requested.map((child) => {
+			addChild(data, id, childKind, child);
+			return {
+				self: `${moSelf(id)}/${childKind}/${child}`,
+				managedObject: render(data.managedObjects.get(child))
+			};
+		});
+		return Response.json(Array.isArray(body.references) ? { references } : references[0], { status: 201 });
+	}
+	if (childId !== void 0 && method === "DELETE") {
+		if (!document) return notFound$2(id);
+		return removeChild(data, id, childKind, childId) ? new Response(null, { status: 204 }) : apiError(422, "inventory/Invalid Data", `managedObject with id: ${childId}, is not a child of object with id: ${id} : Parent child relationship validation failed`);
+	}
+}
+// src/testing/api/data.ts
+const RESOURCES = {
+	measurement: {
+		collection: "measurements",
+		path: "/measurement/measurements",
+		domain: "measurement",
+		listParams: [
+			"currentPage",
+			"dateFrom",
+			"dateTo",
+			"pageSize",
+			"revert",
+			"source",
+			"type",
+			"valueFragmentSeries",
+			"valueFragmentType",
+			"withTotalElements",
+			"withTotalPages"
+		]
+	},
+	event: {
+		collection: "events",
+		path: "/event/events",
+		domain: "event",
+		listParams: [
+			"createdFrom",
+			"createdTo",
+			"currentPage",
+			"dateFrom",
+			"dateTo",
+			"fragmentType",
+			"lastUpdatedFrom",
+			"lastUpdatedTo",
+			"pageSize",
+			"revert",
+			"source",
+			"type",
+			"withTotalElements",
+			"withTotalPages"
+		]
+	},
+	alarm: {
+		collection: "alarms",
+		path: "/alarm/alarms",
+		domain: "alarm",
+		listParams: [
+			"createdFrom",
+			"createdTo",
+			"currentPage",
+			"dateFrom",
+			"dateTo",
+			"lastUpdatedFrom",
+			"lastUpdatedTo",
+			"pageSize",
+			"resolved",
+			"severity",
+			"source",
+			"status",
+			"type",
+			"withTotalElements",
+			"withTotalPages"
+		]
+	},
+	devicecontrol: {
+		collection: "operations",
+		path: "/devicecontrol/operations",
+		domain: "devicecontrol",
+		listParams: [
+			"currentPage",
+			"dateFrom",
+			"dateTo",
+			"deviceId",
+			"fragmentType",
+			"pageSize",
+			"revert",
+			"status",
+			"withTotalElements",
+			"withTotalPages"
+		]
+	}
+};
+const SERVER_FIELDS = [
+	"id",
+	"self",
+	"creationTime",
+	"lastUpdated",
+	"count",
+	"firstOccurrenceTime"
+];
+function renderDocument(data, resource, document) {
+	const rendered = {
+		...structuredClone(document),
+		self: `${baseUrl()}${resource.path}/${document.id}`
+	};
+	const source = sourceId(document);
+	if (source !== void 0) rendered.source = {
+		id: source,
+		self: moSelf(source),
+		name: data.managedObjects.get(source)?.name
+	};
+	if (resource.collection === "operations" && typeof document.deviceId === "string") rendered.deviceName = data.managedObjects.get(document.deviceId)?.name;
+	return rendered;
+}
+function publish(data, resource, action, document) {
+	const source = resource.collection === "operations" ? document.deviceId : sourceId(document);
+	const payload = action === "DELETE" ? { id: document.id } : renderDocument(data, resource, document);
+	notify(data, resource.collection, action, payload, source);
+}
+function notFound$1(resource, id) {
+	const name = resource.collection.slice(0, -1);
+	return apiError(404, `${resource.domain}/Not Found`, `Finding ${name} from database failed : No ${name} for gid '${id}'!`);
+}
+const DATE_PARAMS = [
+	"dateFrom",
+	"dateTo",
+	"createdFrom",
+	"createdTo",
+	"lastUpdatedFrom",
+	"lastUpdatedTo"
+];
+/**
+* 422 for date query parameters that are not dates (verified for measurements and events).
+* @param call - The request
+*/
+function checkDates(call) {
+	for (const name of DATE_PARAMS) {
+		const value = call.query[name];
+		if (value !== void 0 && Number.isNaN(Date.parse(value))) return apiError(422, `${value} is not a valid date./Invalid Data`, `${value} is not a valid date.`);
+	}
+}
+/**
+* Date range match: from inclusive, to exclusive; equal bounds match exactly
+* that instant (verified against the platform).
+* @param value - ISO date of the document
+* @param from - Range start
+* @param to - Range end
+*/
+function inDateRange(value, from, to) {
+	if (from !== void 0 && to !== void 0 && Date.parse(from) === Date.parse(to)) return Date.parse(String(value)) === Date.parse(from);
+	return inRange(value, from, to);
+}
+function invalid(message) {
+	return apiError(422, "undefined/validationError", message);
+}
+function checkEnum(field, value, allowed) {
+	return value !== void 0 && !allowed.includes(String(value)) ? invalid(`Invalid value '${String(value)}' for ${field}; allowed: ${allowed.join(", ")}`) : void 0;
+}
+function omitServerFields(body) {
+	return Object.fromEntries(Object.entries(body).filter(([key]) => !SERVER_FIELDS.includes(key)));
+}
+/**
+* Creates a measurement, event, alarm, or operation with platform semantics
+* (validation, alarm deduplication, operation status PENDING).
+* @param data - Tenant data
+* @param resource - The resource
+* @param body - Request body
+* @returns The stored document, or an error response
+*/
+function createDocument(data, resource, body) {
+	const endpoint = `POST ${resource.path}`;
+	if (resource.collection === "events" && (body.source === void 0 || body.source === null)) return apiError(422, "event/Invalid Data", "Source of the event must not be null");
+	const missing = checkRequired(endpoint, body);
+	if (missing) return missing;
+	if (resource.collection !== "operations" && Number.isNaN(Date.parse(String(body.time)))) return apiError(400, `${resource.domain}/Bad Request`, "Failed to parse JSON string");
+	if (resource.collection !== "measurements") {
+		const field = (resource.collection === "operations" ? [
+			"id",
+			"creationTime",
+			"status",
+			"failureReason"
+		] : ["id", "creationTime"]).find((name) => body[name] !== void 0);
+		if (field) return apiError(422, "undefined/validationError", `post.input.${field}: is not allowed here`);
+	}
+	if (resource.collection === "operations") {
+		if (Object.keys(body).every((key) => key === "deviceId")) return apiError(422, "devicecontrol/Invalid Data", "At least one weak-typed property must be included");
+	}
+	const now = store.now();
+	const source = resource.collection === "operations" ? body.deviceId : sourceId(body);
+	if (source === void 0 && resource.collection !== "operations") return apiError(422, `${resource.domain}/Invalid Data`, "Source id must not be null");
+	if (!data.managedObjects.has(String(source)) && resource.collection !== "operations") return resource.collection === "alarms" ? apiError(404, "inventory/Not Found", `Finding device data from database failed : No managedObject for id '${String(source)}'!`) : apiError(422, `${resource.domain}/Unprocessable Entity`, "Source object does not exist in inventory.");
+	if (resource.collection === "operations" && !hasAgent(data, String(source))) return apiError(422, "devicecontrol/Unprocessable Entity", `Agent for device '${String(source)}' does not exist in inventory!`);
+	if (resource.collection === "alarms") {
+		const existing = [...data.alarms.values()].find((alarm) => sourceId(alarm) === source && alarm.type === body.type && alarm.status !== "CLEARED");
+		if (existing && body.status !== "CLEARED") {
+			existing.firstOccurrenceTime ??= existing.time;
+			existing.count = existing.count + 1;
+			existing.time = body.time;
+			existing.lastUpdated = now;
+			publish(data, resource, "UPDATE", existing);
+			return existing;
+		}
+	}
+	const document = {
+		...omitServerFields(body),
+		id: store.newId(),
+		creationTime: now
+	};
+	if (source !== void 0 && resource.collection !== "operations") document.source = { id: String(source) };
+	if (resource.collection !== "measurements") document.lastUpdated = now;
+	if (resource.collection === "alarms") {
+		document.status ??= "ACTIVE";
+		document.count = 1;
+	}
+	if (resource.collection === "operations") {
+		document.status = "PENDING";
+		delete document.failureReason;
+	}
+	data[resource.collection].set(document.id, document);
+	publish(data, resource, "CREATE", document);
+	return document;
+}
+/**
+* Whether a device is an agent (`com_cumulocity_model_Agent`) or has one
+* among its device parents, which the platform requires for operations.
+* @param data - Tenant data
+* @param deviceId - Device id
+* @param seen
+*/
+function hasAgent(data, deviceId, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(deviceId)) return false;
+	seen.add(deviceId);
+	if (data.managedObjects.get(deviceId)?.com_cumulocity_model_Agent !== void 0) return true;
+	return parentIds(data, deviceId, "childDevices").some((parent) => hasAgent(data, parent, seen));
+}
+/**
+* Applies an update to a stored document (fragments merged, `null` removes).
+* @param data
+* @param resource - The resource
+* @param document - Stored document
+* @param body - Update
+* @returns An error response, if invalid
+*/
+function updateDocument(data, resource, document, body) {
+	const readOnly = resource.collection === "operations" ? ["deviceId", "deviceName"] : [
+		"source",
+		"time",
+		"type"
+	];
+	if (resource.collection === "operations") {
+		const error = checkEnum("status", body.status, C8Y_ENUMS.operationStatus);
+		if (error) return error;
+	}
+	if (resource.collection === "operations") {
+		const fixed = ["creationTime"].find((field) => body[field] !== void 0) ?? (body.deviceId !== void 0 && String(body.deviceId) !== document.deviceId ? "deviceId" : void 0);
+		if (fixed) return apiError(422, "undefined/validationError", `put.operation.${fixed}: is not allowed here`);
+		if (body.failureReason !== void 0 && body.failureReason !== null && body.status !== "FAILED") return apiError(422, "devicecontrol/Invalid Data", "failureReason can only be set for the status FAILED");
+		if (body.status !== void 0 && body.status !== "FAILED") delete document.failureReason;
+	}
+	if (resource.collection === "alarms") {
+		const fixed = [
+			"type",
+			"time",
+			"count",
+			"creationTime",
+			"lastUpdated",
+			"firstOccurrenceTime"
+		].find((field) => body[field] !== void 0);
+		if (fixed) return apiError(422, "undefined/validationError", `put.alarm.${fixed}: is not allowed here`);
+	}
+	for (const [key, value] of Object.entries(omitServerFields(body))) {
+		if (readOnly.includes(key)) continue;
+		if (value === null && key === "text" && resource.collection === "events") continue;
+		if (value === null) delete document[key];
+		else document[key] = value;
+	}
+	if (resource.collection !== "measurements") document.lastUpdated = store.now();
+	publish(data, resource, "UPDATE", document);
+}
+/**
+* Event updates the platform rejects (verified against the platform).
+* @param call - The request
+* @param id - Event id from the URL
+* @param body - Update
+*/
+function checkEventUpdate(call, id, body) {
+	const contentType = call.headers["content-type"] ?? "";
+	if (contentType && !/json/i.test(contentType)) return apiError(415, "general/Unsupported Media Type", `Content type '${contentType}' not supported`);
+	if (body.id !== void 0 && String(body.id) !== id) return apiError(422, "event/Invalid Data", "Id from representation must be the same like in url");
+	if (body.source !== void 0) return apiError(422, "event/Invalid Data", "Invalid value for source argument! : Value must be null!");
+	const forbidden = [
+		"time",
+		"type",
+		"creationTime",
+		"lastUpdated"
+	].find((field) => body[field] !== void 0);
+	if (forbidden) return apiError(422, "undefined/validationError", `put.eventRepresentation.${forbidden}: is not allowed here`);
+}
+function list(call, data, resource) {
+	const { query } = call;
+	const values = (name) => query[name]?.split(",").map((value) => value.trim());
+	let items = [...data[resource.collection].values()];
+	if (query.source) items = items.filter((document) => sourceId(document) === query.source);
+	if (query.deviceId) items = items.filter((document) => document.deviceId === query.deviceId);
+	if (query.type) {
+		const types = values("type");
+		items = items.filter((document) => types.includes(String(document.type)));
+	}
+	if (query.status) {
+		const statuses = resource.collection === "operations" ? [query.status] : values("status");
+		items = items.filter((document) => statuses.includes(String(document.status)));
+	}
+	if (query.severity) {
+		const severities = values("severity");
+		items = items.filter((document) => severities.includes(String(document.severity)));
+	}
+	if (query.resolved !== void 0) {
+		const resolved = flag(call, "resolved");
+		items = items.filter((document) => document.status === "CLEARED" === resolved);
+	}
+	if (query.fragmentType) items = items.filter((document) => document[query.fragmentType] !== void 0);
+	if (query.valueFragmentType) items = items.filter((document) => {
+		const fragment = document[query.valueFragmentType];
+		return fragment !== void 0 && (query.valueFragmentSeries === void 0 || fragment[query.valueFragmentSeries] !== void 0);
+	});
+	const timeField = resource.collection === "operations" ? "creationTime" : "time";
+	if (query.dateFrom !== void 0 || query.dateTo !== void 0) items = items.filter((document) => inDateRange(document[timeField], query.dateFrom, query.dateTo));
+	if (query.createdFrom !== void 0 || query.createdTo !== void 0) items = items.filter((document) => inDateRange(document.creationTime, query.createdFrom, query.createdTo));
+	if (query.lastUpdatedFrom !== void 0 || query.lastUpdatedTo !== void 0) items = items.filter((document) => inDateRange(document.lastUpdated, query.lastUpdatedFrom, query.lastUpdatedTo));
+	const revert = flag(call, "revert");
+	const hasRange = query.dateFrom !== void 0 || query.dateTo !== void 0;
+	switch (resource.collection) {
+		case "measurements": return byTime(items, "time", !(hasRange && query.revert === "false"));
+		case "events": return byTime(items, "time", !(hasRange && revert));
+		case "alarms": return byTime(items, "time", true);
+		default: return hasRange && revert ? [...items].reverse() : items;
+	}
+}
+/**
+* Measurement, event, alarm, and operation APIs.
+* @param call - The request
+* @param segments - Path segments
+* @param data - Tenant data
+* @param resource - The resource
+*/
+function documents(call, segments, data, resource) {
+	const [, , id, extra] = segments;
+	const { method } = call;
+	const collection = data[resource.collection];
+	const body = call.body ?? {};
+	if (extra !== void 0) return;
+	if (id === "series" && resource.collection === "measurements" && method === "GET") return series(call, data);
+	if (id === void 0) {
+		if (method === "DELETE" && (resource.collection === "measurements" || resource.collection === "events")) {
+			const supported = resource.collection === "measurements" ? [
+				"dateFrom",
+				"dateTo",
+				"fragmentType",
+				"source",
+				"type"
+			] : [
+				"createdFrom",
+				"createdTo",
+				"dateFrom",
+				"dateTo",
+				"fragmentType",
+				"source",
+				"type"
+			];
+			checkQuery(`DELETE ${resource.path}`, call, supported);
+			const dateError = checkDates(call);
+			if (dateError) return dateError;
+			if (resource.collection === "measurements") {
+				if (["dateFrom", "dateTo"].some((name) => call.query[name] !== void 0 && Date.parse(call.query[name]) % 36e5 !== 0)) return apiError(422, "measurement/Invalid Data", "Date from and date to parameters used for delete filter must be truncated to hour!");
+			}
+			let target = call;
+			const { dateFrom, dateTo } = call.query;
+			if (resource.collection === "measurements" && dateFrom !== void 0 && dateFrom === dateTo) target = {
+				...call,
+				query: {
+					...call.query,
+					dateTo: new Date(Date.parse(dateFrom) + 36e5).toISOString()
+				}
+			};
+			for (const document of list(target, data, resource)) {
+				collection.delete(document.id);
+				data.eventBinaries.delete(document.id);
+				publish(data, resource, "DELETE", document);
+			}
+			return new Response(null, { status: 204 });
+		}
+		if (method === "GET") {
+			checkQuery(`GET ${resource.path}`, call, resource.listParams);
+			const dateError = checkDates(call);
+			if (dateError) return dateError;
+			if (resource.collection === "operations" && call.query.status !== void 0 && !C8Y_ENUMS.operationStatus.includes(call.query.status)) return apiError(422, "devicecontrol/Invalid Data", `Invalid status value: ${call.query.status}`);
+			return paged(call, resource.collection, list(call, data, resource).map((document) => renderDocument(data, resource, document)), resource.path);
+		}
+		if (method === "POST") {
+			checkQuery(`POST ${resource.path}`, call, []);
+			if (resource.collection === "measurements" && Array.isArray(body.measurements)) {
+				const created = [];
+				for (const item of body.measurements) {
+					const result = createDocument(data, resource, item);
+					if (result instanceof Response) return result;
+					created.push(result);
+				}
+				return Response.json({ measurements: created.map((document) => renderDocument(data, resource, document)) }, { status: 201 });
+			}
+			const result = createDocument(data, resource, body);
+			return result instanceof Response ? result : Response.json(renderDocument(data, resource, result), { status: 201 });
+		}
+		if (method === "PUT" && resource.collection === "alarms") {
+			checkQuery("PUT /alarm/alarms", call, [
+				"createdFrom",
+				"createdTo",
+				"dateFrom",
+				"dateTo",
+				"resolved",
+				"severity",
+				"source",
+				"status"
+			]);
+			const dateError = checkDates(call);
+			if (dateError) return dateError;
+			if (body.status === void 0) return apiError(422, "alarm/Invalid Data", "Missing status for bulk alarm update");
+			for (const alarm of list(call, data, resource)) {
+				const error = updateDocument(data, resource, alarm, { status: body.status });
+				if (error) return error;
+			}
+			return new Response(null, { status: 200 });
+		}
+		return;
+	}
+	const document = collection.get(id);
+	const detail = `${resource.path}/{id}`;
+	if (method === "GET") {
+		checkQuery(`GET ${detail}`, call, []);
+		if (resource.collection === "measurements") return apiError(405, "measurement/Method Not Allowed", "Reading a single measurement is not supported with time series persistence");
+		if (!document) return notFound$1(resource, id);
+		const rendered = renderDocument(data, resource, document);
+		if (resource.collection === "operations") delete rendered.deviceName;
+		return Response.json(rendered);
+	}
+	if (method === "PUT" && resource.collection !== "measurements") {
+		checkQuery(`PUT ${detail}`, call, []);
+		if (!document) return notFound$1(resource, id);
+		if (resource.collection === "operations" && body.status === void 0) return invalid("Following mandatory fields should be included: status");
+		if (resource.collection === "events") {
+			const error = checkEventUpdate(call, id, body);
+			if (error) return error;
+		}
+		return updateDocument(data, resource, document, body) ?? Response.json(renderDocument(data, resource, document));
+	}
+	if (method === "DELETE" && (resource.collection === "measurements" || resource.collection === "events")) {
+		checkQuery(`DELETE ${detail}`, call, []);
+		if (!document || !collection.delete(id)) return notFound$1(resource, id);
+		data.eventBinaries.delete(id);
+		publish(data, resource, "DELETE", document);
+		return new Response(null, { status: 204 });
+	}
+}
+const INTERVAL_MS = {
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+const AGGREGATION_TYPES = {
+	MINUTELY: "1m",
+	HOURLY: "1h",
+	DAILY: "1d"
+};
+/**
+* Start of the aggregation bucket a time falls into (UTC; weeks start at the
+* Unix epoch's weekday, months/quarters/years on calendar boundaries).
+* @param time - Epoch milliseconds
+* @param interval - e.g. `15m`, `1h`, `1M`
+*/
+function bucketStart(time, interval) {
+	const match = /^([1-9]\d{0,2})([smhdwMqy])$/.exec(interval);
+	if (!match) throw new TypeError(interval);
+	const amount = Number(match[1]);
+	const unit = match[2];
+	if (unit in INTERVAL_MS) {
+		const size = amount * INTERVAL_MS[unit];
+		return Math.floor(time / size) * size;
+	}
+	const date = new Date(time);
+	const months = {
+		M: amount,
+		q: amount * 3,
+		y: amount * 12
+	}[unit];
+	const index = date.getUTCFullYear() * 12 + date.getUTCMonth();
+	const start = Math.floor(index / months) * months;
+	return Date.UTC(Math.floor(start / 12), start % 12, 1);
+}
+function aggregate(values, fn) {
+	const sum = values.reduce((total, value) => total + value, 0);
+	const avg = sum / values.length;
+	const variance = (divisor) => values.reduce((total, value) => total + (value - avg) ** 2, 0) / divisor;
+	switch (fn) {
+		case "min": return Math.min(...values);
+		case "max": return Math.max(...values);
+		case "sum": return sum;
+		case "avg": return avg;
+		case "count": return values.length;
+		case "stdDevPop": return Math.sqrt(variance(values.length));
+		default: return values.length > 1 ? Math.sqrt(variance(values.length - 1)) : 0;
+	}
+}
+/**
+* `GET /measurement/measurements/series`: values of a source's series in a
+* period, optionally aggregated per interval.
+* @param call - The request
+* @param data - Tenant data
+*/
+function series(call, data) {
+	checkQuery("GET /measurement/measurements/series", call, [
+		"aggregationFunction",
+		"aggregationInterval",
+		"aggregationType",
+		"dateFrom",
+		"dateTo",
+		"revert",
+		"series",
+		"source"
+	]);
+	const { query } = call;
+	const params = raw(call).params;
+	if ([
+		"source",
+		"dateFrom",
+		"dateTo"
+	].some((name) => !query[name])) return apiError(400, "measurement/Bad Request", "The query parameters source, dateFrom and dateTo are required for this request.");
+	const dateError = checkDates(call);
+	if (dateError) return dateError;
+	const functions = params.getAll("aggregationFunction");
+	if (query.aggregationType && !Object.hasOwn(AGGREGATION_TYPES, query.aggregationType)) return apiError(400, "measurement/Bad Request", `Invalid value '${query.aggregationType}' for aggregationType. Allowed values: HOURLY, DAILY, MINUTELY`);
+	const unknownFunction = functions.find((fn) => !C8Y_ENUMS.seriesAggregationFunction.includes(fn));
+	if (unknownFunction) return apiError(400, "measurement/Bad Request", `Invalid value '${unknownFunction}' for aggregationFunction. Allowed values: min, max, avg, sum, count, stdDevPop, stdDevSamp`);
+	const interval = query.aggregationInterval ?? (query.aggregationType ? AGGREGATION_TYPES[query.aggregationType] : void 0);
+	if (functions.length > 0 && !interval) return apiError(422, "measurements/Invalid Data", "Cannot specify aggregation functions if `aggregationType` is not provided!");
+	if (interval && !/^[1-9]\d{0,2}[smhdwMqy]$/.test(interval)) return apiError(422, "measurement/Invalid Data", `Invalid aggregation interval: ${interval}`);
+	const wanted = params.getAll("series");
+	const points = [];
+	for (const measurement of data.measurements.values()) {
+		if (sourceId(measurement) !== query.source || !inDateRange(measurement.time, query.dateFrom, query.dateTo)) continue;
+		for (const [fragment, fragmentValue] of Object.entries(measurement)) {
+			if (!fragmentValue || typeof fragmentValue !== "object" || Array.isArray(fragmentValue) || fragment === "source") continue;
+			for (const [name, entry] of Object.entries(fragmentValue)) if (entry && typeof entry === "object" && typeof entry.value === "number") {
+				const key = `${fragment}.${name}`;
+				if (wanted.length === 0 || wanted.includes(key)) points.push({
+					time: Date.parse(String(measurement.time)),
+					key,
+					value: entry.value,
+					unit: entry.unit,
+					type: fragment,
+					name
+				});
+			}
+		}
+	}
+	const seriesList = [];
+	for (const point of points) if (!seriesList.some((item) => item.key === point.key)) seriesList.push({
+		key: point.key,
+		name: point.name,
+		type: point.type,
+		unit: point.unit
+	});
+	const buckets = /* @__PURE__ */ new Map();
+	for (const point of points) {
+		const time = interval ? bucketStart(point.time, interval) : point.time;
+		const bucket = buckets.get(time) ?? /* @__PURE__ */ new Map();
+		bucket.set(point.key, [...bucket.get(point.key) ?? [], point.value]);
+		buckets.set(time, bucket);
+	}
+	const times = [...buckets.keys()].sort((a, b) => a - b);
+	const fns = functions.length > 0 ? functions : ["min", "max"];
+	const values = {};
+	for (const time of times) {
+		const bucket = buckets.get(time);
+		values[new Date(time).toISOString()] = seriesList.map((item) => {
+			const numbers = bucket.get(item.key);
+			if (numbers) return Object.fromEntries(fns.map((fn) => [fn, aggregate(numbers, fn)]));
+			return fns.every((fn) => fn === "sum" || fn === "count") ? Object.fromEntries(fns.map((fn) => [fn, 0])) : null;
+		});
+	}
+	return Response.json({
+		values,
+		series: seriesList.map(({ name, type, unit }) => ({
+			name,
+			type,
+			...unit !== void 0 ? { unit } : {}
+		})),
+		truncated: false
+	});
+}
+// src/testing/api/identity.ts
+function renderExternalId(entry) {
+	return {
+		externalId: entry.externalId,
+		type: entry.type,
+		self: `${baseUrl()}/identity/externalIds/${encodeURIComponent(entry.type)}/${encodeURIComponent(entry.externalId)}`,
+		managedObject: {
+			id: entry.managedObjectId,
+			self: moSelf(entry.managedObjectId)
+		}
+	};
+}
+/**
+* Adds an external id. Fails like the platform on unknown objects or duplicates.
+* @param data - Tenant data
+* @param managedObjectId - Managed object id
+* @param type - External id type, e.g. `c8y_Serial`
+* @param externalId - External id value
+*/
+function addExternalId(data, managedObjectId, type, externalId) {
+	if (!data.managedObjects.has(managedObjectId)) return apiError(404, "identity/Not Found", `Global id not found; global id = ${managedObjectId}`);
+	const existing = data.externalIds.find((entry) => entry.type === type && entry.externalId === externalId);
+	if (existing) return existing.managedObjectId === managedObjectId ? existing : apiError(409, "identity/Duplicate", `ID [type=${type}, value=${externalId}] was already bound to different Global ID.`);
+	const entry = {
+		type,
+		externalId,
+		managedObjectId
+	};
+	data.externalIds.push(entry);
+	return entry;
+}
+/**
+* Identity API: external ids.
+* @param call - The request
+* @param segments - Path segments
+* @param data - Tenant data
+*/
+function identity(call, segments, data) {
+	const [, resource, a, b] = segments;
+	const { method } = call;
+	if (resource === "externalIds" && a !== void 0 && b !== void 0 && segments.length === 4) {
+		const index = data.externalIds.findIndex((entry) => entry.type === a && entry.externalId === b);
+		if (method === "GET") {
+			checkQuery("GET /identity/externalIds/{type}/{externalId}", call, []);
+			return index === -1 ? apiError(404, "identity/Not Found", `External id not found; external id = ID [type=${a}, value=${b}]`) : Response.json(renderExternalId(data.externalIds[index]));
+		}
+		if (method === "DELETE") {
+			checkQuery("DELETE /identity/externalIds/{type}/{externalId}", call, []);
+			if (index === -1) return apiError(404, "identity/Not Found", `External id not found; external id = ID [type=${a}, value=${b}]`);
+			data.externalIds.splice(index, 1);
+			return new Response(null, { status: 204 });
+		}
+		return;
+	}
+	if (resource === "globalIds" && a !== void 0 && b === "externalIds" && segments.length === 4) {
+		if (method === "GET") {
+			checkQuery("GET /identity/globalIds/{id}/externalIds", call, []);
+			const externalIds = data.externalIds.filter((entry) => entry.managedObjectId === a).map(renderExternalId);
+			return Response.json({
+				self: `${baseUrl()}/identity/globalIds/${a}/externalIds`,
+				externalIds
+			});
+		}
+		if (method === "POST") {
+			checkQuery("POST /identity/globalIds/{id}/externalIds", call, []);
+			const body = call.body ?? {};
+			const missing = ["type", "externalId"].find((field) => !body[field]);
+			if (missing) return apiError(422, "undefined/validationError", `post.input.${missing}: must not be empty`);
+			const result = addExternalId(data, a, body.type, body.externalId);
+			return result instanceof Response ? result : Response.json(renderExternalId(result), { status: 201 });
+		}
+	}
+}
+// src/testing/api/binaries.ts
+/**
+* Reads an upload: a multipart body with `object` (JSON) and `file` parts, or
+* a raw body (event attachments, binary replacement).
+* @param call - The request
+* @returns The upload, or an error response
+*/
+async function readUpload(call) {
+	const { bytes, contentType } = raw(call);
+	if (!contentType.startsWith("multipart/")) return {
+		content: {
+			bytes,
+			contentType: contentType || "application/octet-stream",
+			name: "bin"
+		},
+		object: {}
+	};
+	const form = await new Request("http://upload.invalid", {
+		method: "POST",
+		headers: { "content-type": contentType },
+		body: bytes
+	}).formData();
+	const part = form.get("file");
+	if (part === null) return apiError(422, "binaries/Invalid Data", "Missing file part");
+	const file = typeof part === "string" ? new Blob([part]) : part;
+	let object = {};
+	const objectPart = form.get("object");
+	if (typeof objectPart === "string" && objectPart) try {
+		object = JSON.parse(objectPart);
+	} catch {
+		return apiError(422, "binaries/Invalid Data", "The object part is not valid JSON");
+	}
+	const name = typeof object.name === "string" ? object.name : file.name || "bin";
+	return {
+		content: {
+			bytes: new Uint8Array(await file.arrayBuffer()),
+			contentType: file.type || "application/octet-stream",
+			name
+		},
+		object
+	};
+}
+function download(content) {
+	return new Response(content.bytes, { headers: {
+		"content-type": content.contentType,
+		"content-length": String(content.bytes.length),
+		"content-disposition": `attachment; filename="${content.name}"`
+	} });
+}
+/**
+* Creates an inventory binary (a managed object with `c8y_IsBinary`).
+* @param data - Tenant data
+* @param content - File content
+* @param object - Managed object fragments from the upload
+* @param owner - Owner user name
+*/
+function createBinary(data, content, object, owner) {
+	const document = createManagedObject(data, {
+		...object,
+		name: object.name ?? content.name,
+		type: object.type ?? content.contentType,
+		contentType: content.contentType,
+		length: content.bytes.length,
+		c8y_IsBinary: ""
+	}, owner);
+	data.binaries.set(document.id, content);
+	return document;
+}
+/**
+* Inventory binaries API: `/inventory/binaries[/{id}]`.
+* @param call - The request
+* @param segments - Path segments
+* @param data - Tenant data
+*/
+async function inventoryBinaries(call, segments, data) {
+	const [, , id] = segments;
+	const { method } = call;
+	if (id === void 0) {
+		if (method === "POST") {
+			checkQuery("POST /inventory/binaries", call, []);
+			const upload = await readUpload(call);
+			if (upload instanceof Response) return upload;
+			const document = createBinary(data, upload.content, upload.object, call.user ?? "test-user");
+			return Response.json(renderManagedObject(data, document), { status: 201 });
+		}
+		if (method === "GET") {
+			checkQuery("GET /inventory/binaries", call, [
+				"childAdditionId",
+				"childAssetId",
+				"childDeviceId",
+				"currentPage",
+				"ids",
+				"owner",
+				"pageSize",
+				"type",
+				"withTotalPages"
+			]);
+			const { query } = call;
+			const ids = query.ids?.split(",");
+			return paged(call, "managedObjects", ([
+				"childDeviceId",
+				"childAssetId",
+				"childAdditionId"
+			].some((name) => query[name] !== void 0) ? [] : [...data.managedObjects.values()].filter((document) => document.c8y_IsBinary !== void 0 && (ids === void 0 || ids.includes(document.id)) && (query.owner === void 0 || document.owner === query.owner) && (query.type === void 0 || document.type === query.type))).map((document) => renderManagedObject(data, document)), "/inventory/binaries", { statistics: "binaries" });
+		}
+		return;
+	}
+	const document = data.managedObjects.get(id);
+	const content = data.binaries.get(id);
+	if (method === "GET") {
+		checkQuery("GET /inventory/binaries/{id}", call, []);
+		if (!document || !content) return notFound$2(id);
+		const type = typeof document.type === "string" && /^[\w.+-]+\/[\w.+-]+/.test(document.type) ? document.type : "application/octet-stream";
+		return download({
+			...content,
+			contentType: type
+		});
+	}
+	if (method === "PUT") {
+		checkQuery("PUT /inventory/binaries/{id}", call, []);
+		if (!document || !content) return notFound$2(id);
+		const upload = await readUpload(call);
+		if (upload instanceof Response) return upload;
+		data.binaries.set(id, {
+			...upload.content,
+			name: content.name
+		});
+		document.type = upload.content.contentType;
+		document.contentType = upload.content.contentType;
+		document.length = upload.content.bytes.length;
+		document.lastUpdated = store.now();
+		notify(data, "managedobjects", "UPDATE", renderManagedObject(data, document), id);
+		return new Response(null, { status: 201 });
+	}
+	if (method === "DELETE") {
+		checkQuery("DELETE /inventory/binaries/{id}", call, []);
+		if (!deleteManagedObject(data, id)) return notFound$2(id);
+		data.binaries.delete(id);
+		notify(data, "managedobjects", "DELETE", { id }, id);
+		return new Response(null, { status: 204 });
+	}
+	if (method === "POST") return apiError(405, "general/Method Not Allowed", "Request method 'POST' is not supported");
+}
+function renderAttachment(eventId, content) {
+	return {
+		self: `${baseUrl()}/event/events/${eventId}/binaries`,
+		source: eventId,
+		name: content.name,
+		type: content.contentType
+	};
+}
+/**
+* Event attachments: `/event/events/{id}/binaries`.
+* @param call - The request
+* @param eventId - Event id
+* @param data - Tenant data
+*/
+async function eventBinaries(call, eventId, data) {
+	const { method } = call;
+	if (!data.events.has(eventId)) return apiError(404, "event/Not Found", `Finding event from database failed : No event for gid '${eventId}'!`);
+	const existing = data.eventBinaries.get(eventId);
+	if (method === "POST" || method === "PUT") {
+		checkQuery(`${method} /event/events/{id}/binaries`, call, []);
+		if (method === "POST" && existing) return apiError(409, "event/Duplicate", "Binary already exists.");
+		const { contentType } = raw(call);
+		if (/^application\/json/i.test(contentType)) return apiError(400, "event/Bad Request", "Unsupported content type for an attachment: application/json");
+		const upload = await readUpload(call);
+		if (upload instanceof Response) return upload;
+		const multipart = contentType.startsWith("multipart/");
+		const content = {
+			...upload.content,
+			contentType: contentType ? upload.content.contentType : "text/plain;charset=UTF-8",
+			name: multipart ? upload.content.name : eventId
+		};
+		data.eventBinaries.set(eventId, content);
+		return Response.json(renderAttachment(eventId, content), { status: 201 });
+	}
+	if (method === "GET") {
+		checkQuery("GET /event/events/{id}/binaries", call, []);
+		return existing ? download(existing) : apiError(404, "event/Not Found", "Attachment not found");
+	}
+	if (method === "DELETE") {
+		checkQuery("DELETE /event/events/{id}/binaries", call, []);
+		data.eventBinaries.delete(eventId);
+		return new Response(null, { status: 204 });
+	}
+}
+// src/testing/router.ts
+function compileRoute(pattern) {
+	const trimmed = pattern.trim();
+	const spaceIndex = trimmed.indexOf(" ");
+	return {
+		method: spaceIndex === -1 ? void 0 : trimmed.slice(0, spaceIndex).toUpperCase(),
+		segments: splitPath(spaceIndex === -1 ? trimmed : trimmed.slice(spaceIndex + 1).trim())
+	};
+}
+function splitPath(path) {
+	return path.split("?")[0].split("/").filter(Boolean);
+}
+/**
+* Matches a request against a compiled route.
+* @param route - Compiled route
+* @param method - Request method (upper case)
+* @param segments - Request path segments (decoded)
+* @returns Captured params, or `undefined` when the route does not match
+*/
+function matchRoute(route, method, segments) {
+	if (route.method && route.method !== method) return;
+	const params = {};
+	for (let i = 0; i < route.segments.length; i++) {
+		const part = route.segments[i];
+		if (part === "**") {
+			params._ = segments.slice(i).join("/");
+			return params;
+		}
+		const value = segments[i];
+		if (value === void 0) return;
+		if (part === "*") continue;
+		if (part.startsWith(":")) {
+			params[part.slice(1)] = value;
+			continue;
+		}
+		if (part !== value) return;
+	}
+	return segments.length === route.segments.length ? params : void 0;
+}
+// src/testing/api/notifications.ts
+const APIS = [
+	"*",
+	"managedobjects",
+	"measurements",
+	"events",
+	"alarms",
+	"operations"
+];
+const UNSUPPORTED_APIS = ["alarmsWithChildren", "eventsWithChildren"];
+function render(subscription) {
+	const { tenant, ...rest } = subscription;
+	return {
+		nonPersistent: false,
+		...rest,
+		self: `${baseUrl()}/notification2/subscriptions/${subscription.id}`,
+		source: subscription.source ? {
+			id: subscription.source.id,
+			self: moSelf(subscription.source.id)
+		} : {
+			id: tenant,
+			self: `${baseUrl()}/tenant/tenants/${tenant}`
+		}
+	};
+}
+function notFound(id) {
+	return apiError(404, "reliable-notification/Not Found", `Subscription with id '${id}' not found`);
+}
+const NAME = /^[a-z0-9]+$/i;
+/**
+* Notification 2.0 API: subscriptions, tokens, and unsubscribing consumers.
+* The consumer WebSocket itself is `FakeWebSocket` in `../realtime`.
+* @param call - The request
+* @param segments - Path segments
+* @param data - Data of the request's tenant
+*/
+function notifications(call, segments, data) {
+	const [, resource, id] = segments;
+	const { method } = call;
+	const tenant = data.tenant;
+	const body = call.body ?? {};
+	if (resource === "subscriptions" && id === void 0) {
+		if (method === "POST") {
+			checkQuery("POST /notification2/subscriptions", call, []);
+			const missing = checkRequired("POST /notification2/subscriptions", body);
+			if (missing) return missing;
+			const apis = body.subscriptionFilter?.apis ?? ["*"];
+			const unsupported = apis.filter((api) => UNSUPPORTED_APIS.includes(api));
+			if (unsupported.length > 0) throw new UnsupportedRequestError(`subscription api "${unsupported.join(", ")}" is not emulated`);
+			if (apis.some((api) => !APIS.includes(api)) || apis.includes("*") && apis.length > 1) return apiError(422, "reliable-notification/Invalid Data", `Invalid subscription filter apis: ${apis.join(", ")}`);
+			if (!NAME.test(String(body.subscription))) return apiError(422, "reliable-notification/Invalid Data", "The subscription name must be alphanumeric");
+			if (body.context !== "mo" && body.context !== "tenant") return apiError(422, "reliable-notification/Invalid Data", `Invalid context '${body.context}'`);
+			if (body.context === "tenant" && body.source !== void 0) return apiError(422, "reliable-notification/Invalid Data", "A tenant subscription has no source");
+			if (body.context === "mo" && body.source?.id === void 0) return apiError(422, "reliable-notification/Invalid Data", "A managed object subscription needs a source");
+			if (body.context === "mo" && !data.managedObjects.has(String(body.source.id))) return apiError(404, "inventory/Not Found", `Finding device data from database failed : No managedObject for id '${body.source.id}'!`);
+			const sourceId = body.context === "mo" ? String(body.source.id) : void 0;
+			if (realtime.subscriptions.some((item) => item.tenant === tenant && item.subscription === body.subscription && item.source?.id === sourceId)) return apiError(409, "reliable-notification/Duplicate", `Subscription '${body.subscription}' already exists`);
+			const created = realtime.createSubscription({
+				tenant,
+				context: body.context,
+				subscription: body.subscription,
+				...sourceId ? { source: { id: sourceId } } : {},
+				...body.subscriptionFilter ? { subscriptionFilter: body.subscriptionFilter } : {},
+				...body.fragmentsToCopy ? { fragmentsToCopy: body.fragmentsToCopy } : {},
+				...body.nonPersistent !== void 0 ? { nonPersistent: body.nonPersistent } : {}
+			});
+			return Response.json(render(created), { status: 201 });
+		}
+		if (method === "GET") {
+			checkQuery("GET /notification2/subscriptions", call, [
+				"context",
+				"currentPage",
+				"pageSize",
+				"source",
+				"subscription",
+				"withTotalElements",
+				"withTotalPages"
+			]);
+			const { query } = call;
+			return paged(call, "subscriptions", realtime.subscriptions.filter((item) => item.tenant === tenant && (query.subscription === void 0 || item.subscription === query.subscription) && (query.context === void 0 || item.context === query.context) && (query.source === void 0 || item.source?.id === query.source)).map(render), "/notification2/subscriptions");
+		}
+		if (method === "DELETE") {
+			checkQuery("DELETE /notification2/subscriptions", call, ["context", "source"]);
+			realtime.subscriptions = realtime.subscriptions.filter((item) => !(item.tenant === tenant && (call.query.context === void 0 || item.context === call.query.context) && (call.query.source === void 0 || item.source?.id === call.query.source)));
+			return new Response(null, { status: 204 });
+		}
+		return;
+	}
+	if (resource === "subscriptions" && id !== void 0 && segments.length === 3) {
+		const subscription = realtime.subscriptions.find((item) => item.tenant === tenant && item.id === id);
+		if (method === "GET") return subscription ? Response.json(render(subscription)) : notFound(id);
+		if (method === "DELETE") {
+			if (!subscription) return notFound(id);
+			realtime.subscriptions = realtime.subscriptions.filter((item) => item !== subscription);
+			return new Response(null, { status: 204 });
+		}
+		return;
+	}
+	if (resource === "token" && method === "POST" && segments.length === 2) {
+		checkQuery("POST /notification2/token", call, []);
+		if (!body.subscriber || !body.subscription) return apiError(422, "undefined/validationError", "Following mandatory fields should be included: subscriber,subscription");
+		if (!NAME.test(String(body.subscriber))) return apiError(422, "reliable-notification/Invalid Data", "The subscriber name must be alphanumeric");
+		return Response.json({ token: realtime.createToken({
+			tenant,
+			subscription: body.subscription,
+			subscriber: body.subscriber
+		}) });
+	}
+	if (resource === "unsubscribe" && method === "POST" && segments.length === 2) {
+		const token = call.query.token ?? "";
+		if (!token) return apiError(422, "reliable-notification/Invalid Data", "Missing token");
+		const consumers = [...realtime.sockets].filter((socket) => new URL(socket.url).searchParams.get("token") === token);
+		if (!realtime.tokens.has(token) || consumers.length === 0) return apiError(500, "reliable-notification/Internal Server Error", "Unsubscribing the consumer failed");
+		realtime.tokens.delete(token);
+		for (const socket of consumers) socket.close();
+		return Response.json({ result: "DONE" });
+	}
+}
+// src/testing/api/index.ts
+/**
+* Answers a request from the emulated platform APIs (inventory, identity,
+* measurements, events, alarms, operations).
+* @param call - The request
+* @param segments - Decoded path segments
+* @param data - Data of the request's tenant
+* @returns The response, or `undefined` if the endpoint is not emulated
+*/
+async function platformApi(call, segments, data) {
+	const [domain, resource] = segments;
+	if (domain === "inventory" && resource === "binaries") return inventoryBinaries(call, segments, data);
+	if (domain === "event" && resource === "events" && segments[3] === "binaries" && segments.length === 4) return eventBinaries(call, segments[2], data);
+	if (domain === "inventory" && resource === "managedObjects") return inventory(call, segments, data);
+	if (domain === "identity") return identity(call, segments, data);
+	if (domain === "measurement" && resource === "measurements") return documents(call, segments, data, RESOURCES.measurement);
+	if (domain === "event" && resource === "events") return documents(call, segments, data, RESOURCES.event);
+	if (domain === "alarm" && resource === "alarms") return documents(call, segments, data, RESOURCES.alarm);
+	if (domain === "notification2") return notifications(call, segments, data);
+	if (domain === "devicecontrol" && resource === "operations") return documents(call, segments, data, RESOURCES.devicecontrol);
+}
+// src/testing/platform.ts
+/**
+* The in-memory Cumulocity tenant behind `c8y` in `c8y-nitro/testing`.
+* One instance per test file (Vitest isolates modules per file).
+*/
+const platform = {
+	baseline: {},
+	tenant: DEFAULTS.tenant,
+	user: null,
+	subscriptions: [],
+	/**
+	* `${tenant}\u0000${category}\u0000${key}` → value
+	*/
+	options: /* @__PURE__ */ new Map(),
+	handlers: [],
+	calls: [],
+	unhandled: [],
+	onUnhandledRequest: "error",
+	/**
+	* Requests being answered right now.
+	*/
+	inflight: 0,
+	/**
+	* Sets the deployed tenant, subscriptions, and default user from the
+	* baseline before the Nitro app starts, so plugins that run at startup (e.g.
+	* realtime subscriptions) find credentials. Tenant options are applied by
+	* `reset()` once the app's runtime config exists.
+	* @param baseline - Plugin options
+	*/
+	prepare(baseline) {
+		this.baseline = baseline;
+		this.tenant = baseline.tenant ?? DEFAULTS.tenant;
+		this.subscriptions = (baseline.subscriptions ?? [defaultSubscription(this.tenant)]).map((subscription) => ({ ...subscription }));
+		this.setUser(baseline.user === void 0 ? DEFAULTS.user : baseline.user);
+	},
+	/**
+	* Restores the baseline from the plugin config.
+	*/
+	reset() {
+		this.tenant = this.baseline.tenant ?? DEFAULTS.tenant;
+		this.user = null;
+		this.subscriptions = [];
+		this.options.clear();
+		this.handlers = [];
+		this.calls = [];
+		this.unhandled = [];
+		store.reset();
+		this.onUnhandledRequest = this.baseline.onUnhandledRequest ?? "error";
+		this.apply({
+			user: this.baseline.user === void 0 ? DEFAULTS.user : this.baseline.user,
+			subscriptions: this.baseline.subscriptions ?? [defaultSubscription(this.tenant)],
+			tenantOptions: this.baseline.tenantOptions
+		});
+	},
+	/**
+	* Applies a partial state on top of the current one.
+	* @param state - Partial tenant state
+	*/
+	apply(state) {
+		if (state.tenant !== void 0) this.tenant = state.tenant;
+		if (state.user !== void 0) this.setUser(state.user);
+		if (state.subscriptions !== void 0) this.subscriptions = state.subscriptions.map((subscription) => ({ ...subscription }));
+		for (const [key, value] of Object.entries(state.tenantOptions ?? {})) this.setOption(key, value);
+		if (state.onUnhandledRequest !== void 0) this.onUnhandledRequest = state.onUnhandledRequest;
+		syncEnv();
+	},
+	setUser(user) {
+		this.user = user ? {
+			...user,
+			roles: [...user.roles ?? []]
+		} : null;
+		syncEnv();
+	},
+	setOption(key, value, opts = {}) {
+		this.options.set(optionId(opts.tenant ?? this.tenant, opts.category ?? ownCategory(), key), value);
+	},
+	getOption(key, opts = {}) {
+		return this.options.get(optionId(opts.tenant ?? this.tenant, opts.category ?? ownCategory(), key));
+	},
+	deleteOption(key, opts = {}) {
+		return this.options.delete(optionId(opts.tenant ?? this.tenant, opts.category ?? ownCategory(), key));
+	},
+	override(pattern, handler, once = false) {
+		const entry = {
+			route: compileRoute(pattern),
+			pattern,
+			handler,
+			once
+		};
+		this.handlers.push(entry);
+		return () => {
+			this.handlers = this.handlers.filter((item) => item !== entry);
+		};
+	},
+	/**
+	* Answers a request the real `@c8y/client` would send to the platform.
+	* @param request - Request built by the patched FetchClient
+	*/
+	async fetch(request) {
+		this.inflight++;
+		try {
+			return await this.answer(request);
+		} finally {
+			this.inflight--;
+		}
+	},
+	async answer(request) {
+		const url = new URL(request.url);
+		const method = request.method.toUpperCase();
+		const segments = splitPath(url.pathname).map(decodeURIComponent);
+		const path = `/${segments.join("/")}`;
+		const caller = parseBasicAuth(request.headers.get("authorization"));
+		const bytes = request.body ? new Uint8Array(await request.arrayBuffer()) : /* @__PURE__ */ new Uint8Array();
+		const contentType = request.headers.get("content-type") ?? "";
+		const isBinary = contentType.startsWith("multipart/") || contentType.includes("octet-stream");
+		const text = bytes.length > 0 && !isBinary ? new TextDecoder().decode(bytes) : "";
+		let body = text || void 0;
+		try {
+			body = text ? JSON.parse(text) : void 0;
+		} catch {}
+		const call = {
+			method,
+			path,
+			query: Object.fromEntries(url.searchParams),
+			body,
+			headers: Object.fromEntries(request.headers),
+			tenant: url.searchParams.get("targetTenant") ?? caller?.tenant ?? this.tenant,
+			user: caller?.user,
+			params: {}
+		};
+		this.calls.push(call);
+		rawRequests.set(call, {
+			bytes,
+			contentType,
+			params: url.searchParams
+		});
+		for (let i = this.handlers.length - 1; i >= 0; i--) {
+			const entry = this.handlers[i];
+			const params = matchRoute(entry.route, method, segments);
+			if (!params) continue;
+			if (entry.once) this.handlers.splice(i, 1);
+			return toResponse(await entry.handler({
+				...call,
+				params,
+				request
+			}));
+		}
+		const builtIn = builtInRoute(call, segments);
+		if (builtIn) return builtIn;
+		let reason = "endpoint not emulated";
+		try {
+			const response = await platformApi(call, segments, store.tenant(call.tenant));
+			if (response) return response;
+		} catch (error) {
+			if (!(error instanceof UnsupportedRequestError)) throw error;
+			reason = error.message;
+		}
+		const unhandled = {
+			...call,
+			reason
+		};
+		this.unhandled.push(unhandled);
+		if (this.onUnhandledRequest === "warn") console.warn(unhandledMessage([unhandled]));
+		return apiError(501, "c8y-nitro/testing/unsupported", `${method} ${path}: ${reason} by the c8y-nitro/testing fake tenant. Answer it with c8y.override('${method} ${path}', ...).`);
+	}
+};
+function unhandledMessage(calls) {
+	return [
+		`c8y-nitro/testing: ${calls.length} Cumulocity request(s) the fake tenant does not support:`,
+		...calls.map((call) => `  ${call.method} ${call.path} (${call.reason})`),
+		"Answer them with c8y.override('METHOD /path', handler) (see \"What the fake emulates\" in the testing guide), or set onUnhandledRequest to 'warn' or 'ignore'."
+	].join("\n");
+}
+function defaultSubscription(tenant) {
+	return {
+		tenant,
+		user: `service_${tenant}`,
+		password: "service-password"
+	};
+}
+function optionId(tenant, category, key) {
+	return `${tenant}\u0000${category}\u0000${key}`;
+}
+function ownCategory() {
+	return useRuntimeConfig().c8ySettingsCategory;
+}
+/**
+* Keeps the dev and bootstrap env in sync with the tenant and current user.
+*/
+function syncEnv() {
+	process.env.C8Y_BOOTSTRAP_TENANT = platform.tenant;
+	process.env.C8Y_DEVELOPMENT_TENANT = platform.user?.tenant ?? platform.tenant;
+	process.env.C8Y_DEVELOPMENT_USER = platform.user?.userName ?? DEFAULTS.user.userName;
+}
+function parseBasicAuth(header) {
+	if (!header?.startsWith("Basic ")) return;
+	const decoded = Buffer.from(header.slice(6), "base64").toString();
+	const login = decoded.slice(0, decoded.indexOf(":"));
+	const slash = login.indexOf("/");
+	return slash === -1 ? { user: login } : {
+		tenant: login.slice(0, slash),
+		user: login.slice(slash + 1)
+	};
+}
+function toResponse(result) {
+	if (result instanceof Response) return result;
+	if (result === void 0) return new Response(null, { status: 204 });
+	return Response.json(result);
+}
+function optionNotFound(category, key) {
+	return apiError(404, "options/Not Found", `Unable to find option by given key: ${category}/${key}`);
+}
+/**
+* `credentials.` options are encrypted: reads show `<<Encrypted>>`, except for
+* the microservice's own settings category, which the platform decrypts for
+* the service (verified against the platform for other categories).
+* @param category - Option category
+* @param key - Option key
+* @param value - Stored value
+*/
+function readableOption(category, key, value) {
+	return key.startsWith("credentials.") && category !== ownCategory() ? "<<Encrypted>>" : value;
+}
+function encrypted(key, value) {
+	return key.startsWith("credentials.") ? Buffer.from(`fake-cipher:${value}`).toString("hex") : value;
+}
+/**
+* Platform endpoints that c8y-nitro itself relies on.
+* @param call - The recorded request
+* @param segments - Decoded path segments
+*/
+function builtInRoute(call, segments) {
+	const { method } = call;
+	const [a, b, category, key, editable] = segments;
+	if (method === "GET" && a === "user" && b === "currentUser" && segments.length === 2) {
+		const user = platform.user;
+		if (!user) return Response.json({
+			error: "security/Unauthorized",
+			message: "Invalid credentials!"
+		}, { status: 401 });
+		const { roles = [], tenant: _tenant, ...rest } = user;
+		return Response.json({
+			id: user.userName,
+			...rest,
+			effectiveRoles: roles.map((name) => ({
+				id: name,
+				name
+			}))
+		});
+	}
+	if (method === "GET" && a === "tenant" && b === "currentTenant" && segments.length === 2) return Response.json({
+		name: call.tenant,
+		domainName: new URL(process.env.C8Y_BASEURL || DEFAULTS.baseUrl).host
+	});
+	if (method === "GET" && a === "application" && b === "currentApplication" && category === "subscriptions" && segments.length === 3) return Response.json({ users: platform.subscriptions.map(({ tenant, user, password }) => ({
+		tenant,
+		name: user,
+		password
+	})) });
+	if (a === "tenant" && b === "options" && category !== void 0) {
+		const scope = {
+			tenant: call.tenant,
+			category
+		};
+		if (key !== void 0 && editable === "editable" && segments.length === 5) return method === "PUT" ? Response.json({ editable: Boolean(call.body?.editable) }) : void 0;
+		if (key !== void 0 && segments.length === 4) {
+			const self = `${new URL(process.env.C8Y_BASEURL || DEFAULTS.baseUrl).origin}/tenant/options/${encodeURIComponent(category)}/${encodeURIComponent(key)}`;
+			if (method === "GET") {
+				const value = platform.getOption(key, scope);
+				return value === void 0 ? optionNotFound(category, key) : Response.json({
+					self,
+					category,
+					key,
+					value: readableOption(category, key, value)
+				});
+			}
+			if (method === "PUT") {
+				const value = String(call.body?.value ?? "");
+				platform.setOption(key, value, scope);
+				return Response.json({
+					self,
+					category,
+					key,
+					value: encrypted(key, value)
+				});
+			}
+			if (method === "DELETE") return platform.deleteOption(key, scope) ? new Response(null, { status: 204 }) : optionNotFound(category, key);
+			return;
+		}
+		if (segments.length === 3) {
+			if (method === "PUT") {
+				const result = {};
+				for (const [k, v] of Object.entries(call.body ?? {})) {
+					platform.setOption(k, String(v), scope);
+					result[k] = encrypted(k, String(v));
+				}
+				return Response.json(result);
+			}
+			if (method === "GET") {
+				const prefix = optionId(call.tenant, category, "");
+				const result = {};
+				for (const [id, value] of platform.options) if (id.startsWith(prefix)) {
+					const key = id.slice(prefix.length);
+					result[key] = readableOption(category, key, value);
+				}
+				return Response.json(result);
+			}
+		}
+	}
+}
+// src/testing/scope.ts
+/**
+* Scope-aware arrange calls.
+*
+* While Vitest collects a file, `c8y.*` calls do not change state. They
+* register a `beforeEach` in the scope they were called in (file top level or
+* a `describe`), so Vitest's own hook order replays them before every test:
+* outer scopes first, then inner ones, after the reset to the plugin baseline.
+* Inside a test (or a `beforeEach`), calls apply immediately and are undone by
+* the reset before the next test.
+*/
+let phase = "collect";
+/**
+* Called from the setup file's `beforeAll`, which runs after collection.
+*/
+function markRunning() {
+	phase = "run";
+}
+/**
+* The error for test-time APIs in a concurrent test. Vitest 5 has no
+* `.sequential` modifier: a test opts out with `{ concurrent: false }`.
+* @param name - API name for error messages
+* @param test - Name of the concurrent test
+*/
+function concurrentError(name, test) {
+	return /* @__PURE__ */ new Error(`${name} cannot be used in concurrent tests ("${test}"): the fake Cumulocity tenant is shared by all tests of a file. Remove \`.concurrent\`, or pass \`{ concurrent: false }\` to the test or describe (for example when \`sequence.concurrent\` is on).`);
+}
+/**
+* Runs an arrange operation in the scope it was called from.
+* @param name - API name for error messages, e.g. `c8y.user()`
+* @param operation - Applies the change to the fake tenant
+*/
+function arrange(name, operation) {
+	if (phase === "collect") {
+		beforeEach((context) => {
+			if (context.task.concurrent) throw concurrentError(name, context.task.name);
+			store.silent = true;
+			try {
+				operation();
+			} finally {
+				store.silent = false;
+			}
+		});
+		return;
+	}
+	assertActiveTest(name);
+	operation();
+}
+/**
+* Throws when a test-time API is used outside a running test, or in a
+* concurrent test (the fake tenant is shared by the tests of a file).
+* @param name - API name for error messages
+*/
+function assertActiveTest(name) {
+	const test = TestRunner.getCurrentTest();
+	if (!test) throw new Error(`${name} cannot be used in beforeAll() or afterAll(). Call it at file or describe level, in beforeEach(), or inside a test.`);
+	if (test.concurrent) throw concurrentError(name, test.name);
+}
+export { store as S, FakeWebSocket as _, unhandledMessage as a, waitForRealtimeStartup as b, splitPath as c, RESOURCES as d, createDocument as f, renderManagedObject as g, createManagedObject as h, platform as i, createBinary as l, updateDocument as m, assertActiveTest as n, compileRoute as o, renderDocument as p, markRunning as r, matchRoute as s, arrange as t, addExternalId as u, realtime as v, addChild as x, trackInflight as y };