@projectqai/proto 0.0.48 → 0.0.50

package/device.ts

@@ -1,7 +1,7 @@
 import { createClient, type Client, ConnectError, Code } from "@connectrpc/connect";
 import { createTransport } from "@connectrpc/connect/protocol-connect";
 import type { UniversalClientFn } from "@connectrpc/connect/protocol";
-import { create, clone } from "@bufbuild/protobuf";
+import { create, clone, type JsonObject, type JsonValue } from "@bufbuild/protobuf";
 import {
 	WorldService,
 	EntitySchema,
@@ -114,14 +114,14 @@ export function push(client: WorldClient, ...entities: Entity[]) {
 
 // Schema → typed config inference
 
-type SchemaProperty = { readonly type: string; readonly default?: unknown; readonly [key: string]: unknown };
+type SchemaProperty = Record<string, JsonValue> & { readonly type: string; readonly default?: JsonValue };
 type SchemaProperties = Readonly<Record<string, SchemaProperty>>;
 
 type InferProperty<P extends SchemaProperty> =
 	P extends { type: "string" } ? string :
 	P extends { type: "boolean" } ? boolean :
 	P extends { type: "number" | "integer" } ? number :
-	unknown;
+	JsonValue;
 
 export type InferConfig<S extends SchemaProperties> = {
 	[K in keyof S]?: InferProperty<S[K]>;
@@ -141,13 +141,13 @@ function extractConfig<S extends SchemaProperties>(entity: Entity, schema: S): I
 
 export type HealthResult = boolean | Record<number, { label: string; value: number | bigint }>;
 
-export interface AttachOptions<S extends SchemaProperties> {
+export interface AttachOptions<S extends SchemaProperties = Record<string, never>> {
 	id: string;
 	label?: string;
 	controller?: string;
 	device?: { category?: string };
 	icon?: string;
-	schema: S;
+	schema?: S;
 	/** Default config to push on attach so the plugin starts without manual
 	 *  configuration. Pushed with fresh=0 so it won't overwrite an existing config. */
 	config?: InferConfig<S>;
@@ -182,11 +182,12 @@ function sleep(ms: number, signal: AbortSignal): Promise<void> {
  * `false` to skip the heartbeat (device expires via TTL), or a metrics map
  * to push metrics alongside the heartbeat.
  */
-export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>) {
+export async function attach<S extends SchemaProperties = Record<string, never>>(opts: AttachOptions<S>) {
 	const client = connect();
 	const entityID = opts.id;
 	const interval = opts.interval ?? DEFAULT_INTERVAL;
 	const health = opts.health ?? (() => true);
+	const schema = (opts.schema ?? {}) as S;
 
 	const entity = create(EntitySchema, {
 		id: entityID,
@@ -195,7 +196,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 		...(opts.device && { device: create(DeviceComponentSchema, opts.device) }),
 		...(opts.icon && { interactivity: create(InteractivityComponentSchema, { icon: opts.icon }) }),
 		configurable: create(ConfigurableComponentSchema, {
-			schema: { type: "object", properties: opts.schema as Record<string, unknown> },
+			schema: { type: "object", properties: schema } as JsonObject,
 		}),
 	});
 
@@ -208,7 +209,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 		await push(client, create(EntitySchema, {
 			id: entityID,
 			config: create(ConfigurationComponentSchema, {
-				value: opts.config as Record<string, unknown>,
+				value: opts.config as JsonObject,
 			}),
 			lifetime: create(LifetimeSchema, {
 				fresh: create(TimestampSchema, { seconds: 0n }),
@@ -226,9 +227,11 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 
 	const pushHeartbeat = (result?: Record<number, { label: string; value: number | bigint }>) => {
 		const state = initialized ? DeviceState.DeviceStateActive : DeviceState.DeviceStatePending;
+		const device = entity.device ? clone(DeviceComponentSchema, entity.device) : create(DeviceComponentSchema);
+		device.state = state;
 		const e = create(EntitySchema, {
 			id: entityID,
-			device: create(DeviceComponentSchema, { ...entity.device, state }),
+			device,
 			lifetime: create(LifetimeSchema, {
 				until: create(TimestampSchema, { seconds: BigInt(Math.floor((Date.now() + interval + 1_000) / 1000)) }),
 			}),
@@ -238,7 +241,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 				metrics: Object.entries(result).map(([idStr, { label, value }]) =>
 					typeof value === "bigint"
 						? create(MetricSchema, { id: Number(idStr), label, kind: MetricKind.MetricKindCount, unit: MetricUnit.MetricUnitCount, val: { case: "uint64", value } })
-						: create(MetricSchema, { id: Number(idStr), label, kind: MetricKind.MetricKindGauge, unit: MetricUnit.MetricUnitNone, val: { case: "float", value } }),
+						: create(MetricSchema, { id: Number(idStr), label, kind: MetricKind.MetricKindUnspecified, unit: MetricUnit.MetricUnitUnspecified, val: { case: "float", value } }),
 				),
 			});
 		}
@@ -296,7 +299,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 				await pushState(e, ConfigurableState.ConfigurableStateStarting);
 
 				try {
-					if (opts.init) await opts.init(client, extractConfig(e, opts.schema), childSignal);
+					if (opts.init) await opts.init(client, extractConfig(e, schema), childSignal);
 				} catch (err) {
 					if (childSignal.aborted || isCanceled(err)) return;
 					console.error(`init failed entity=${entityID}`, err);
@@ -309,7 +312,7 @@ export async function attach<S extends SchemaProperties>(opts: AttachOptions<S>)
 				await pushState(e, ConfigurableState.ConfigurableStateActive);
 
 				try {
-					await opts.run(client, extractConfig(e, opts.schema), childSignal);
+					await opts.run(client, extractConfig(e, schema), childSignal);
 				} catch (err) {
 					if (childSignal.aborted || isCanceled(err)) return;
 					console.error(`error, restarting entity=${entityID}`, err);

package/dist/metrics_pb.d.ts

@@ -11,6 +11,75 @@ import type { Timestamp } from "@bufbuild/protobuf/wkt";
  */
 export declare const file_metrics: GenFile;
 
+/**
+ * @generated from message world.MetricRange
+ */
+export declare type MetricRange = Message<"world.MetricRange"> & {
+  /**
+   * @generated from oneof world.MetricRange.min
+   */
+  min: {
+    /**
+     * @generated from field: double min_double = 1;
+     */
+    value: number;
+    case: "minDouble";
+  } | {
+    /**
+     * @generated from field: float min_float = 2;
+     */
+    value: number;
+    case: "minFloat";
+  } | {
+    /**
+     * @generated from field: sint64 min_sint64 = 3;
+     */
+    value: bigint;
+    case: "minSint64";
+  } | {
+    /**
+     * @generated from field: uint64 min_uint64 = 4;
+     */
+    value: bigint;
+    case: "minUint64";
+  } | { case: undefined; value?: undefined };
+
+  /**
+   * @generated from oneof world.MetricRange.max
+   */
+  max: {
+    /**
+     * @generated from field: double max_double = 10;
+     */
+    value: number;
+    case: "maxDouble";
+  } | {
+    /**
+     * @generated from field: float max_float = 11;
+     */
+    value: number;
+    case: "maxFloat";
+  } | {
+    /**
+     * @generated from field: sint64 max_sint64 = 12;
+     */
+    value: bigint;
+    case: "maxSint64";
+  } | {
+    /**
+     * @generated from field: uint64 max_uint64 = 13;
+     */
+    value: bigint;
+    case: "maxUint64";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message world.MetricRange.
+ * Use `create(MetricRangeSchema)` to create a new message.
+ */
+export declare const MetricRangeSchema: GenMessage<MetricRange>;
+
 /**
  * @generated from message world.Metric
  */
@@ -44,6 +113,16 @@ export declare type Metric = Message<"world.Metric"> & {
    */
   measuredAt?: Timestamp;
 
+  /**
+   * @generated from field: optional world.MetricRange range = 6;
+   */
+  range?: MetricRange;
+
+  /**
+   * @generated from field: optional world.SensorClip clipping = 7;
+   */
+  clipping?: SensorClip;
+
   /**
    * @generated from oneof world.Metric.val
    */
@@ -861,6 +940,35 @@ export enum MetricUnit {
  */
 export declare const MetricUnitSchema: GenEnum<MetricUnit>;
 
+/**
+ * @generated from enum world.SensorClip
+ */
+export enum SensorClip {
+  /**
+   * @generated from enum value: SensorClipNone = 0;
+   */
+  SensorClipNone = 0,
+
+  /**
+   * actual value may be higher than reported due to sensor range exceeded
+   *
+   * @generated from enum value: SensorClipHigh = 1;
+   */
+  SensorClipHigh = 1,
+
+  /**
+   * actual value may be lower than reported due to sensor range exceeded
+   *
+   * @generated from enum value: SensorClipLow = 2;
+   */
+  SensorClipLow = 2,
+}
+
+/**
+ * Describes the enum world.SensorClip.
+ */
+export declare const SensorClipSchema: GenEnum<SensorClip>;
+
 /**
  * @generated from enum world.AlertLevel
  */

package/dist/metrics_pb.js

@@ -9,21 +9,28 @@ import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt";
  * Describes the file metrics.proto.
  */
 export const file_metrics = /*@__PURE__*/
-  fileDesc("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", [file_google_protobuf_timestamp]);
+  fileDesc("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", [file_google_protobuf_timestamp]);
+
+/**
+ * Describes the message world.MetricRange.
+ * Use `create(MetricRangeSchema)` to create a new message.
+ */
+export const MetricRangeSchema = /*@__PURE__*/
+  messageDesc(file_metrics, 0);
 
 /**
  * Describes the message world.Metric.
  * Use `create(MetricSchema)` to create a new message.
  */
 export const MetricSchema = /*@__PURE__*/
-  messageDesc(file_metrics, 0);
+  messageDesc(file_metrics, 1);
 
 /**
  * Describes the message world.MetricComponent.
  * Use `create(MetricComponentSchema)` to create a new message.
  */
 export const MetricComponentSchema = /*@__PURE__*/
-  messageDesc(file_metrics, 1);
+  messageDesc(file_metrics, 2);
 
 /**
  * Describes the enum world.MetricKind.
@@ -49,11 +56,23 @@ export const MetricUnitSchema = /*@__PURE__*/
 export const MetricUnit = /*@__PURE__*/
   tsEnum(MetricUnitSchema);
 
+/**
+ * Describes the enum world.SensorClip.
+ */
+export const SensorClipSchema = /*@__PURE__*/
+  enumDesc(file_metrics, 2);
+
+/**
+ * @generated from enum world.SensorClip
+ */
+export const SensorClip = /*@__PURE__*/
+  tsEnum(SensorClipSchema);
+
 /**
  * Describes the enum world.AlertLevel.
  */
 export const AlertLevelSchema = /*@__PURE__*/
-  enumDesc(file_metrics, 2);
+  enumDesc(file_metrics, 3);
 
 /**
  * @generated from enum world.AlertLevel

package/dist/world_pb.d.ts

@@ -4,7 +4,7 @@
 
 import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
 import type { JsonObject, Message } from "@bufbuild/protobuf";
-import type { MetricComponent } from "./metrics_pb.js";
+import type { MetricComponent, MetricKind } from "./metrics_pb.js";
 import type { Timestamp } from "@bufbuild/protobuf/wkt";
 import type { LocalGeometry, PlanarGeometry } from "./geometry_pb.js";
 
@@ -2725,6 +2725,46 @@ export declare type ChannelFilter = Message<"world.ChannelFilter"> & {
  */
 export declare const ChannelFilterSchema: GenMessage<ChannelFilter>;
 
+/**
+ * @generated from message world.SortOption
+ */
+export declare type SortOption = Message<"world.SortOption"> & {
+  /**
+   * @generated from field: world.SortField field = 1;
+   */
+  field: SortField;
+
+  /**
+   * @generated from field: bool descending = 2;
+   */
+  descending: boolean;
+
+  /**
+   * for SortFieldMetric*
+   *
+   * @generated from oneof world.SortOption.metric_selector
+   */
+  metricSelector: {
+    /**
+     * @generated from field: uint32 metric_id = 20;
+     */
+    value: number;
+    case: "metricId";
+  } | {
+    /**
+     * @generated from field: world.MetricKind metric_kind = 21;
+     */
+    value: MetricKind;
+    case: "metricKind";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message world.SortOption.
+ * Use `create(SortOptionSchema)` to create a new message.
+ */
+export declare const SortOptionSchema: GenMessage<SortOption>;
+
 /**
  * @generated from message world.WatchBehavior
  */
@@ -2770,6 +2810,13 @@ export declare type ListEntitiesRequest = Message<"world.ListEntitiesRequest"> &
    */
   filter?: EntityFilter;
 
+  /**
+   * sort by. more than 2 are actually ignored
+   *
+   * @generated from field: repeated world.SortOption sort = 3;
+   */
+  sort: SortOption[];
+
   /**
    * @generated from field: optional world.WatchBehavior behaviour = 4;
    */
@@ -3594,6 +3641,209 @@ export enum ConfigurableState {
  */
 export declare const ConfigurableStateSchema: GenEnum<ConfigurableState>;
 
+/**
+ * @generated from enum world.SortField
+ */
+export enum SortField {
+  /**
+   * @generated from enum value: SortFieldUnspecified = 0;
+   */
+  SortFieldUnspecified = 0,
+
+  /**
+   * @generated from enum value: SortFieldLabel = 1;
+   */
+  SortFieldLabel = 1,
+
+  /**
+   * @generated from enum value: SortFieldPriority = 2;
+   */
+  SortFieldPriority = 2,
+
+  /**
+   * lifetime
+   *
+   * @generated from enum value: SortFieldLifetimeFrom = 10;
+   */
+  SortFieldLifetimeFrom = 10,
+
+  /**
+   * @generated from enum value: SortFieldLifetimeUntil = 11;
+   */
+  SortFieldLifetimeUntil = 11,
+
+  /**
+   * @generated from enum value: SortFieldLifetimeFresh = 12;
+   */
+  SortFieldLifetimeFresh = 12,
+
+  /**
+   * geo
+   *
+   * @generated from enum value: SortFieldGeoLatitude = 20;
+   */
+  SortFieldGeoLatitude = 20,
+
+  /**
+   * @generated from enum value: SortFieldGeoLongitude = 21;
+   */
+  SortFieldGeoLongitude = 21,
+
+  /**
+   * @generated from enum value: SortFieldGeoAltitude = 22;
+   */
+  SortFieldGeoAltitude = 22,
+
+  /**
+   * classification
+   *
+   * @generated from enum value: SortFieldClassificationIdentity = 30;
+   */
+  SortFieldClassificationIdentity = 30,
+
+  /**
+   * @generated from enum value: SortFieldClassificationDimension = 31;
+   */
+  SortFieldClassificationDimension = 31,
+
+  /**
+   * bearing
+   *
+   * @generated from enum value: SortFieldBearingAzimuth = 50;
+   */
+  SortFieldBearingAzimuth = 50,
+
+  /**
+   * @generated from enum value: SortFieldBearingElevation = 51;
+   */
+  SortFieldBearingElevation = 51,
+
+  /**
+   * administrative
+   *
+   * @generated from enum value: SortFieldAdministrativeLength = 70;
+   */
+  SortFieldAdministrativeLength = 70,
+
+  /**
+   * @generated from enum value: SortFieldAdministrativeWidth = 71;
+   */
+  SortFieldAdministrativeWidth = 71,
+
+  /**
+   * @generated from enum value: SortFieldAdministrativeHeight = 72;
+   */
+  SortFieldAdministrativeHeight = 72,
+
+  /**
+   * @generated from enum value: SortFieldAdministrativeTonnage = 73;
+   */
+  SortFieldAdministrativeTonnage = 73,
+
+  /**
+   * @generated from enum value: SortFieldAdministrativeEnginePower = 74;
+   */
+  SortFieldAdministrativeEnginePower = 74,
+
+  /**
+   * @generated from enum value: SortFieldAdministrativeYearBuilt = 75;
+   */
+  SortFieldAdministrativeYearBuilt = 75,
+
+  /**
+   * link
+   *
+   * @generated from enum value: SortFieldLinkRssi = 90;
+   */
+  SortFieldLinkRssi = 90,
+
+  /**
+   * @generated from enum value: SortFieldLinkSnr = 91;
+   */
+  SortFieldLinkSnr = 91,
+
+  /**
+   * @generated from enum value: SortFieldLinkLastLatency = 92;
+   */
+  SortFieldLinkLastLatency = 92,
+
+  /**
+   * @generated from enum value: SortFieldLinkAvgLatency = 93;
+   */
+  SortFieldLinkAvgLatency = 93,
+
+  /**
+   * @generated from enum value: SortFieldLinkQuality = 94;
+   */
+  SortFieldLinkQuality = 94,
+
+  /**
+   * @generated from enum value: SortFieldLinkLastSeen = 95;
+   */
+  SortFieldLinkLastSeen = 95,
+
+  /**
+   * @generated from enum value: SortFieldLinkPacketRate = 96;
+   */
+  SortFieldLinkPacketRate = 96,
+
+  /**
+   * power
+   *
+   * @generated from enum value: SortFieldPowerBatteryCharge = 100;
+   */
+  SortFieldPowerBatteryCharge = 100,
+
+  /**
+   * @generated from enum value: SortFieldPowerVoltage = 101;
+   */
+  SortFieldPowerVoltage = 101,
+
+  /**
+   * @generated from enum value: SortFieldPowerRemainingSeconds = 102;
+   */
+  SortFieldPowerRemainingSeconds = 102,
+
+  /**
+   * @generated from enum value: SortFieldPowerCurrent = 103;
+   */
+  SortFieldPowerCurrent = 103,
+
+  /**
+   * @generated from enum value: SortFieldPowerCapacityUsed = 104;
+   */
+  SortFieldPowerCapacityUsed = 104,
+
+  /**
+   * device
+   *
+   * @generated from enum value: SortFieldDeviceState = 130;
+   */
+  SortFieldDeviceState = 130,
+
+  /**
+   * metric
+   *
+   * @generated from enum value: SortFieldMetricValue = 150;
+   */
+  SortFieldMetricValue = 150,
+
+  /**
+   * @generated from enum value: SortFieldMetricMeasuredAt = 151;
+   */
+  SortFieldMetricMeasuredAt = 151,
+
+  /**
+   * @generated from enum value: SortFieldMetricAlertLevel = 152;
+   */
+  SortFieldMetricAlertLevel = 152,
+}
+
+/**
+ * Describes the enum world.SortField.
+ */
+export declare const SortFieldSchema: GenEnum<SortField>;
+
 /**
  * @generated from enum world.EntityChange
  */

package/dist/world_pb.js

@@ -11,7 +11,7 @@ import { file_metrics } from "./metrics_pb.js";
  * Describes the file world.proto.
  */
 export const file_world = /*@__PURE__*/
-  fileDesc("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", [file_geometry, file_google_protobuf_struct, file_google_protobuf_timestamp, file_metrics]);
+  fileDesc("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", [file_geometry, file_google_protobuf_struct, file_google_protobuf_timestamp, file_metrics]);
 
 /**
  * Describes the message world.Entity.
@@ -517,138 +517,145 @@ export const ConfigurationFilterSchema = /*@__PURE__*/
 export const ChannelFilterSchema = /*@__PURE__*/
   messageDesc(file_world, 71);
 
+/**
+ * Describes the message world.SortOption.
+ * Use `create(SortOptionSchema)` to create a new message.
+ */
+export const SortOptionSchema = /*@__PURE__*/
+  messageDesc(file_world, 72);
+
 /**
  * Describes the message world.WatchBehavior.
  * Use `create(WatchBehaviorSchema)` to create a new message.
  */
 export const WatchBehaviorSchema = /*@__PURE__*/
-  messageDesc(file_world, 72);
+  messageDesc(file_world, 73);
 
 /**
  * Describes the message world.ListEntitiesRequest.
  * Use `create(ListEntitiesRequestSchema)` to create a new message.
  */
 export const ListEntitiesRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 73);
+  messageDesc(file_world, 74);
 
 /**
  * Describes the message world.ListEntitiesResponse.
  * Use `create(ListEntitiesResponseSchema)` to create a new message.
  */
 export const ListEntitiesResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 74);
+  messageDesc(file_world, 75);
 
 /**
  * Describes the message world.EntityChangeRequest.
  * Use `create(EntityChangeRequestSchema)` to create a new message.
  */
 export const EntityChangeRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 75);
+  messageDesc(file_world, 76);
 
 /**
  * Describes the message world.ExpireEntityRequest.
  * Use `create(ExpireEntityRequestSchema)` to create a new message.
  */
 export const ExpireEntityRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 76);
+  messageDesc(file_world, 77);
 
 /**
  * Describes the message world.ExpireEntityResponse.
  * Use `create(ExpireEntityResponseSchema)` to create a new message.
  */
 export const ExpireEntityResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 77);
+  messageDesc(file_world, 78);
 
 /**
  * Describes the message world.EntityChangeResponse.
  * Use `create(EntityChangeResponseSchema)` to create a new message.
  */
 export const EntityChangeResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 78);
+  messageDesc(file_world, 79);
 
 /**
  * Describes the message world.EntityChangeEvent.
  * Use `create(EntityChangeEventSchema)` to create a new message.
  */
 export const EntityChangeEventSchema = /*@__PURE__*/
-  messageDesc(file_world, 79);
+  messageDesc(file_world, 80);
 
 /**
  * Describes the message world.EntityChangeBatch.
  * Use `create(EntityChangeBatchSchema)` to create a new message.
  */
 export const EntityChangeBatchSchema = /*@__PURE__*/
-  messageDesc(file_world, 80);
+  messageDesc(file_world, 81);
 
 /**
  * Describes the message world.GetEntityRequest.
  * Use `create(GetEntityRequestSchema)` to create a new message.
  */
 export const GetEntityRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 81);
+  messageDesc(file_world, 82);
 
 /**
  * Describes the message world.GetEntityResponse.
  * Use `create(GetEntityResponseSchema)` to create a new message.
  */
 export const GetEntityResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 82);
+  messageDesc(file_world, 83);
 
 /**
  * Describes the message world.GetLocalNodeRequest.
  * Use `create(GetLocalNodeRequestSchema)` to create a new message.
  */
 export const GetLocalNodeRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 83);
+  messageDesc(file_world, 84);
 
 /**
  * Describes the message world.GetLocalNodeResponse.
  * Use `create(GetLocalNodeResponseSchema)` to create a new message.
  */
 export const GetLocalNodeResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 84);
+  messageDesc(file_world, 85);
 
 /**
  * Describes the message world.ObserverRequest.
  * Use `create(ObserverRequestSchema)` to create a new message.
  */
 export const ObserverRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 85);
+  messageDesc(file_world, 86);
 
 /**
  * Describes the message world.ObserverState.
  * Use `create(ObserverStateSchema)` to create a new message.
  */
 export const ObserverStateSchema = /*@__PURE__*/
-  messageDesc(file_world, 86);
+  messageDesc(file_world, 87);
 
 /**
  * Describes the message world.RunTaskRequest.
  * Use `create(RunTaskRequestSchema)` to create a new message.
  */
 export const RunTaskRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 87);
+  messageDesc(file_world, 88);
 
 /**
  * Describes the message world.RunTaskResponse.
  * Use `create(RunTaskResponseSchema)` to create a new message.
  */
 export const RunTaskResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 88);
+  messageDesc(file_world, 89);
 
 /**
  * Describes the message world.HardResetRequest.
  * Use `create(HardResetRequestSchema)` to create a new message.
  */
 export const HardResetRequestSchema = /*@__PURE__*/
-  messageDesc(file_world, 89);
+  messageDesc(file_world, 90);
 
 /**
  * Describes the message world.HardResetResponse.
  * Use `create(HardResetResponseSchema)` to create a new message.
  */
 export const HardResetResponseSchema = /*@__PURE__*/
-  messageDesc(file_world, 90);
+  messageDesc(file_world, 91);
 
 /**
  * Describes the enum world.Priority.
@@ -794,11 +801,23 @@ export const ConfigurableStateSchema = /*@__PURE__*/
 export const ConfigurableState = /*@__PURE__*/
   tsEnum(ConfigurableStateSchema);
 
+/**
+ * Describes the enum world.SortField.
+ */
+export const SortFieldSchema = /*@__PURE__*/
+  enumDesc(file_world, 12);
+
+/**
+ * @generated from enum world.SortField
+ */
+export const SortField = /*@__PURE__*/
+  tsEnum(SortFieldSchema);
+
 /**
  * Describes the enum world.EntityChange.
  */
 export const EntityChangeSchema = /*@__PURE__*/
-  enumDesc(file_world, 12);
+  enumDesc(file_world, 13);
 
 /**
  * @generated from enum world.EntityChange
@@ -810,7 +829,7 @@ export const EntityChange = /*@__PURE__*/
  * Describes the enum world.EntityComponent.
  */
 export const EntityComponentSchema = /*@__PURE__*/
-  enumDesc(file_world, 13);
+  enumDesc(file_world, 14);
 
 /**
  * Proto field numbers of Entity component fields.
@@ -825,7 +844,7 @@ export const EntityComponent = /*@__PURE__*/
  * Describes the enum world.TaskStatus.
  */
 export const TaskStatusSchema = /*@__PURE__*/
-  enumDesc(file_world, 14);
+  enumDesc(file_world, 15);
 
 /**
  * @generated from enum world.TaskStatus

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectqai/proto",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "author": "projectq-release-bot",
   "type": "module",
   "exports": {