@milaboratories/pl-client 2.18.4 → 3.0.0

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api_types.ts

@@ -33,13 +33,17 @@ export interface Tx {
  */
 export interface Resource {
     /**
-     * @generated from protobuf field: uint64 id = 2
+     * @generated from protobuf field: uint64 resource_id = 2
      */
-    id: bigint;
+    resourceId: bigint;
+    /**
+     * @generated from protobuf field: optional bytes resource_signature = 18
+     */
+    resourceSignature?: Uint8Array;
     /**
      * @generated from protobuf field: bytes canonical_id = 17
      */
-    canonicalId: Uint8Array; // could be empty, it depends on resource lifecycle state
+    canonicalId: Uint8Array; // could be empty; it depends on the resource lifecycle state
     /**
      * @generated from protobuf field: MiLaboratories.PL.API.Resource.Kind kind = 3
      */
@@ -144,17 +148,24 @@ export interface Field {
      */
     features?: Resource_Features;
     /**
-     * _resolved_ value of field or _assigned_ if the field was assigned to a resource.
-     * If field refers to another field, it will get
-     * value only when this chain of references ends up with direct resource
-     * reference. At that moment all fields in the chain will get their values
+     * _resolved_ value of a field or _assigned_ if the field was assigned to a resource.
+     * If a field refers to another field, it will get
+     * a value only when this chain of references ends up with a direct resource
+     * reference. At that moment, all fields in the chain will get their values
      * resolved and will start to refer to the same resource directly.
      *
      * @generated from protobuf field: uint64 value = 5
      */
     value: bigint;
     /**
-     * If the value was empty, assigned or finally resolved.
+     * Signature for value resource ID, inheriting the parent resource's color.
+     * Populated server-side when the parent resource has a known color in the current TX.
+     *
+     * @generated from protobuf field: optional bytes value_signature = 10
+     */
+    valueSignature?: Uint8Array;
+    /**
+     * Whether the value is empty, assigned, or finally resolved.
      *
      * @generated from protobuf field: MiLaboratories.PL.API.Field.ValueStatus value_status = 7
      */
@@ -166,12 +177,18 @@ export interface Field {
      */
     valueIsFinal: boolean;
     /**
-     * Resource error resource id if any.
-     * Is intended to report problems _from_ platform to client.
+     * Error resource ID, if any.
+     * Is intended to report problems _from_ the platform to the client.
      *
      * @generated from protobuf field: uint64 error = 6
      */
     error: bigint;
+    /**
+     * Signature for error resource ID, inheriting the parent resource's color.
+     *
+     * @generated from protobuf field: optional bytes error_signature = 11
+     */
+    errorSignature?: Uint8Array;
 }
 /**
  * @generated from protobuf enum MiLaboratories.PL.API.Field.ValueStatus
@@ -301,6 +318,10 @@ export interface Notification_Events {
      * @generated from protobuf field: bool dynamic_changed = 10
      */
     dynamicChanged: boolean;
+    /**
+     * @generated from protobuf field: bool resource_recovered = 17
+     */
+    resourceRecovered: boolean;
 }
 /**
  * @generated from protobuf message MiLaboratories.PL.API.Notification.FieldChange
@@ -372,6 +393,67 @@ export interface ResourceSchema {
      * @generated from protobuf field: repeated MiLaboratories.PL.API.FieldSchema fields = 2
      */
     fields: FieldSchema[];
+    /**
+     * Access restriction flags for non-controller roles
+     *
+     * @generated from protobuf field: optional MiLaboratories.PL.API.ResourceSchema.AccessFlags access_flags = 3
+     */
+    accessFlags?: ResourceSchema_AccessFlags;
+    /**
+     * @generated from protobuf field: bool free_inputs = 4
+     */
+    freeInputs: boolean; // if true, skip automatic input locking on creation
+    /**
+     * @generated from protobuf field: bool free_outputs = 5
+     */
+    freeOutputs: boolean; // if true, skip automatic output locking on creation
+}
+/**
+ * @generated from protobuf message MiLaboratories.PL.API.ResourceSchema.AccessFlags
+ */
+export interface ResourceSchema_AccessFlags {
+    /**
+     * Deny-list approach: default = allowed (true)
+     * Controllers set these to false to restrict non-controller roles (role='u', role='w')
+     *
+     * @generated from protobuf field: optional bool create_resource = 1
+     */
+    createResource?: boolean; // default: true (creation allowed)
+    /**
+     * IMPORTANT: read_fields=false with write_fields=true is a forbidden combination
+     *
+     * @generated from protobuf field: optional bool read_fields = 2
+     */
+    readFields?: boolean; // default: true (reads allowed)
+    /**
+     * @generated from protobuf field: optional bool write_fields = 3
+     */
+    writeFields?: boolean; // default: true (writes allowed)
+    /**
+     * IMPORTANT: read_kv=false with write_kv=true is a forbidden combination
+     *
+     * @generated from protobuf field: optional bool read_kv = 4
+     */
+    readKv?: boolean; // if unset, falls back to read_fields
+    /**
+     * @generated from protobuf field: optional bool write_kv = 5
+     */
+    writeKv?: boolean; // if unset, falls back to write_fields
+    /**
+     * Per-field-type overrides (map: field_type → bool)
+     * When defined for a field type, overrides resource-level flags
+     *
+     * @generated from protobuf field: map<uint32, bool> read_by_field_type = 6
+     */
+    readByFieldType: {
+        [key: number]: boolean;
+    };
+    /**
+     * @generated from protobuf field: map<uint32, bool> write_by_field_type = 7
+     */
+    writeByFieldType: {
+        [key: number]: boolean;
+    };
 }
 /**
  * @generated from protobuf message MiLaboratories.PL.API.FieldSchema
@@ -466,7 +548,8 @@ export const Tx = new Tx$Type();
 class Resource$Type extends MessageType<Resource> {
     constructor() {
         super("MiLaboratories.PL.API.Resource", [
-            { no: 2, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "resource_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 18, name: "resource_signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
             { no: 17, name: "canonical_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
             { no: 3, name: "kind", kind: "enum", T: () => ["MiLaboratories.PL.API.Resource.Kind", Resource_Kind, "KIND_"] },
             { no: 4, name: "type", kind: "message", T: () => ResourceType },
@@ -486,7 +569,7 @@ class Resource$Type extends MessageType<Resource> {
     }
     create(value?: PartialMessage<Resource>): Resource {
         const message = globalThis.Object.create((this.messagePrototype!));
-        message.id = 0n;
+        message.resourceId = 0n;
         message.canonicalId = new Uint8Array(0);
         message.kind = 0;
         message.data = new Uint8Array(0);
@@ -507,8 +590,11 @@ class Resource$Type extends MessageType<Resource> {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* uint64 id */ 2:
-                    message.id = reader.uint64().toBigInt();
+                case /* uint64 resource_id */ 2:
+                    message.resourceId = reader.uint64().toBigInt();
+                    break;
+                case /* optional bytes resource_signature */ 18:
+                    message.resourceSignature = reader.bytes();
                     break;
                 case /* bytes canonical_id */ 17:
                     message.canonicalId = reader.bytes();
@@ -567,9 +653,9 @@ class Resource$Type extends MessageType<Resource> {
         return message;
     }
     internalBinaryWrite(message: Resource, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* uint64 id = 2; */
-        if (message.id !== 0n)
-            writer.tag(2, WireType.Varint).uint64(message.id);
+        /* uint64 resource_id = 2; */
+        if (message.resourceId !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.resourceId);
         /* MiLaboratories.PL.API.Resource.Kind kind = 3; */
         if (message.kind !== 0)
             writer.tag(3, WireType.Varint).int32(message.kind);
@@ -615,6 +701,9 @@ class Resource$Type extends MessageType<Resource> {
         /* bytes canonical_id = 17; */
         if (message.canonicalId.length)
             writer.tag(17, WireType.LengthDelimited).bytes(message.canonicalId);
+        /* optional bytes resource_signature = 18; */
+        if (message.resourceSignature !== undefined)
+            writer.tag(18, WireType.LengthDelimited).bytes(message.resourceSignature);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -680,9 +769,11 @@ class Field$Type extends MessageType<Field> {
             { no: 2, name: "type", kind: "enum", T: () => ["MiLaboratories.PL.Base.FieldType", FieldType] },
             { no: 3, name: "features", kind: "message", T: () => Resource_Features },
             { no: 5, name: "value", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 10, name: "value_signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
             { no: 7, name: "value_status", kind: "enum", T: () => ["MiLaboratories.PL.API.Field.ValueStatus", Field_ValueStatus] },
             { no: 8, name: "value_is_final", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-            { no: 6, name: "error", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+            { no: 6, name: "error", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "error_signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
         ]);
     }
     create(value?: PartialMessage<Field>): Field {
@@ -713,6 +804,9 @@ class Field$Type extends MessageType<Field> {
                 case /* uint64 value */ 5:
                     message.value = reader.uint64().toBigInt();
                     break;
+                case /* optional bytes value_signature */ 10:
+                    message.valueSignature = reader.bytes();
+                    break;
                 case /* MiLaboratories.PL.API.Field.ValueStatus value_status */ 7:
                     message.valueStatus = reader.int32();
                     break;
@@ -722,6 +816,9 @@ class Field$Type extends MessageType<Field> {
                 case /* uint64 error */ 6:
                     message.error = reader.uint64().toBigInt();
                     break;
+                case /* optional bytes error_signature */ 11:
+                    message.errorSignature = reader.bytes();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -755,6 +852,12 @@ class Field$Type extends MessageType<Field> {
         /* bool value_is_final = 8; */
         if (message.valueIsFinal !== false)
             writer.tag(8, WireType.Varint).bool(message.valueIsFinal);
+        /* optional bytes value_signature = 10; */
+        if (message.valueSignature !== undefined)
+            writer.tag(10, WireType.LengthDelimited).bytes(message.valueSignature);
+        /* optional bytes error_signature = 11; */
+        if (message.errorSignature !== undefined)
+            writer.tag(11, WireType.LengthDelimited).bytes(message.errorSignature);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -910,7 +1013,8 @@ class Notification_Events$Type extends MessageType<Notification_Events> {
             { no: 8, name: "output_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 9, name: "all_outputs_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 14, name: "generic_otw_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-            { no: 10, name: "dynamic_changed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+            { no: 10, name: "dynamic_changed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 17, name: "resource_recovered", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
     create(value?: PartialMessage<Notification_Events>): Notification_Events {
@@ -930,6 +1034,7 @@ class Notification_Events$Type extends MessageType<Notification_Events> {
         message.allOutputsSet = false;
         message.genericOtwSet = false;
         message.dynamicChanged = false;
+        message.resourceRecovered = false;
         if (value !== undefined)
             reflectionMergePartial<Notification_Events>(this, message, value);
         return message;
@@ -984,6 +1089,9 @@ class Notification_Events$Type extends MessageType<Notification_Events> {
                 case /* bool dynamic_changed */ 10:
                     message.dynamicChanged = reader.bool();
                     break;
+                case /* bool resource_recovered */ 17:
+                    message.resourceRecovered = reader.bool();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -1041,6 +1149,9 @@ class Notification_Events$Type extends MessageType<Notification_Events> {
         /* bool field_got_error = 16; */
         if (message.fieldGotError !== false)
             writer.tag(16, WireType.Varint).bool(message.fieldGotError);
+        /* bool resource_recovered = 17; */
+        if (message.resourceRecovered !== false)
+            writer.tag(17, WireType.Varint).bool(message.resourceRecovered);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1298,12 +1409,17 @@ class ResourceSchema$Type extends MessageType<ResourceSchema> {
     constructor() {
         super("MiLaboratories.PL.API.ResourceSchema", [
             { no: 1, name: "type", kind: "message", T: () => ResourceType },
-            { no: 2, name: "fields", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldSchema }
+            { no: 2, name: "fields", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldSchema },
+            { no: 3, name: "access_flags", kind: "message", T: () => ResourceSchema_AccessFlags },
+            { no: 4, name: "free_inputs", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "free_outputs", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
     create(value?: PartialMessage<ResourceSchema>): ResourceSchema {
         const message = globalThis.Object.create((this.messagePrototype!));
         message.fields = [];
+        message.freeInputs = false;
+        message.freeOutputs = false;
         if (value !== undefined)
             reflectionMergePartial<ResourceSchema>(this, message, value);
         return message;
@@ -1319,6 +1435,15 @@ class ResourceSchema$Type extends MessageType<ResourceSchema> {
                 case /* repeated MiLaboratories.PL.API.FieldSchema fields */ 2:
                     message.fields.push(FieldSchema.internalBinaryRead(reader, reader.uint32(), options));
                     break;
+                case /* optional MiLaboratories.PL.API.ResourceSchema.AccessFlags access_flags */ 3:
+                    message.accessFlags = ResourceSchema_AccessFlags.internalBinaryRead(reader, reader.uint32(), options, message.accessFlags);
+                    break;
+                case /* bool free_inputs */ 4:
+                    message.freeInputs = reader.bool();
+                    break;
+                case /* bool free_outputs */ 5:
+                    message.freeOutputs = reader.bool();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -1337,6 +1462,15 @@ class ResourceSchema$Type extends MessageType<ResourceSchema> {
         /* repeated MiLaboratories.PL.API.FieldSchema fields = 2; */
         for (let i = 0; i < message.fields.length; i++)
             FieldSchema.internalBinaryWrite(message.fields[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional MiLaboratories.PL.API.ResourceSchema.AccessFlags access_flags = 3; */
+        if (message.accessFlags)
+            ResourceSchema_AccessFlags.internalBinaryWrite(message.accessFlags, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* bool free_inputs = 4; */
+        if (message.freeInputs !== false)
+            writer.tag(4, WireType.Varint).bool(message.freeInputs);
+        /* bool free_outputs = 5; */
+        if (message.freeOutputs !== false)
+            writer.tag(5, WireType.Varint).bool(message.freeOutputs);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1348,6 +1482,128 @@ class ResourceSchema$Type extends MessageType<ResourceSchema> {
  */
 export const ResourceSchema = new ResourceSchema$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ResourceSchema_AccessFlags$Type extends MessageType<ResourceSchema_AccessFlags> {
+    constructor() {
+        super("MiLaboratories.PL.API.ResourceSchema.AccessFlags", [
+            { no: 1, name: "create_resource", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "read_fields", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "write_fields", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 4, name: "read_kv", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "write_kv", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "read_by_field_type", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "scalar", T: 8 /*ScalarType.BOOL*/ } },
+            { no: 7, name: "write_by_field_type", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "scalar", T: 8 /*ScalarType.BOOL*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<ResourceSchema_AccessFlags>): ResourceSchema_AccessFlags {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.readByFieldType = {};
+        message.writeByFieldType = {};
+        if (value !== undefined)
+            reflectionMergePartial<ResourceSchema_AccessFlags>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ResourceSchema_AccessFlags): ResourceSchema_AccessFlags {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional bool create_resource */ 1:
+                    message.createResource = reader.bool();
+                    break;
+                case /* optional bool read_fields */ 2:
+                    message.readFields = reader.bool();
+                    break;
+                case /* optional bool write_fields */ 3:
+                    message.writeFields = reader.bool();
+                    break;
+                case /* optional bool read_kv */ 4:
+                    message.readKv = reader.bool();
+                    break;
+                case /* optional bool write_kv */ 5:
+                    message.writeKv = reader.bool();
+                    break;
+                case /* map<uint32, bool> read_by_field_type */ 6:
+                    this.binaryReadMap6(message.readByFieldType, reader, options);
+                    break;
+                case /* map<uint32, bool> write_by_field_type */ 7:
+                    this.binaryReadMap7(message.writeByFieldType, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    private binaryReadMap6(map: ResourceSchema_AccessFlags["readByFieldType"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof ResourceSchema_AccessFlags["readByFieldType"] | undefined, val: ResourceSchema_AccessFlags["readByFieldType"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.uint32();
+                    break;
+                case 2:
+                    val = reader.bool();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for MiLaboratories.PL.API.ResourceSchema.AccessFlags.read_by_field_type");
+            }
+        }
+        map[key ?? 0] = val ?? false;
+    }
+    private binaryReadMap7(map: ResourceSchema_AccessFlags["writeByFieldType"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof ResourceSchema_AccessFlags["writeByFieldType"] | undefined, val: ResourceSchema_AccessFlags["writeByFieldType"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.uint32();
+                    break;
+                case 2:
+                    val = reader.bool();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for MiLaboratories.PL.API.ResourceSchema.AccessFlags.write_by_field_type");
+            }
+        }
+        map[key ?? 0] = val ?? false;
+    }
+    internalBinaryWrite(message: ResourceSchema_AccessFlags, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional bool create_resource = 1; */
+        if (message.createResource !== undefined)
+            writer.tag(1, WireType.Varint).bool(message.createResource);
+        /* optional bool read_fields = 2; */
+        if (message.readFields !== undefined)
+            writer.tag(2, WireType.Varint).bool(message.readFields);
+        /* optional bool write_fields = 3; */
+        if (message.writeFields !== undefined)
+            writer.tag(3, WireType.Varint).bool(message.writeFields);
+        /* optional bool read_kv = 4; */
+        if (message.readKv !== undefined)
+            writer.tag(4, WireType.Varint).bool(message.readKv);
+        /* optional bool write_kv = 5; */
+        if (message.writeKv !== undefined)
+            writer.tag(5, WireType.Varint).bool(message.writeKv);
+        /* map<uint32, bool> read_by_field_type = 6; */
+        for (let k of globalThis.Object.keys(message.readByFieldType))
+            writer.tag(6, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k)).tag(2, WireType.Varint).bool(message.readByFieldType[k as any]).join();
+        /* map<uint32, bool> write_by_field_type = 7; */
+        for (let k of globalThis.Object.keys(message.writeByFieldType))
+            writer.tag(7, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k)).tag(2, WireType.Varint).bool(message.writeByFieldType[k as any]).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.ResourceSchema.AccessFlags
+ */
+export const ResourceSchema_AccessFlags = new ResourceSchema_AccessFlags$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class FieldSchema$Type extends MessageType<FieldSchema> {
     constructor() {
         super("MiLaboratories.PL.API.FieldSchema", [

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/base_types.ts

@@ -31,6 +31,10 @@ export interface FieldRef {
      * @generated from protobuf field: uint64 resource_id = 2
      */
     resourceId: bigint;
+    /**
+     * @generated from protobuf field: optional bytes resource_signature = 4
+     */
+    resourceSignature?: Uint8Array;
     /**
      * @generated from protobuf field: string field_name = 3
      */
@@ -129,6 +133,7 @@ class FieldRef$Type extends MessageType<FieldRef> {
     constructor() {
         super("MiLaboratories.PL.Base.FieldRef", [
             { no: 2, name: "resource_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "resource_signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
             { no: 3, name: "field_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
@@ -148,6 +153,9 @@ class FieldRef$Type extends MessageType<FieldRef> {
                 case /* uint64 resource_id */ 2:
                     message.resourceId = reader.uint64().toBigInt();
                     break;
+                case /* optional bytes resource_signature */ 4:
+                    message.resourceSignature = reader.bytes();
+                    break;
                 case /* string field_name */ 3:
                     message.fieldName = reader.string();
                     break;
@@ -169,6 +177,9 @@ class FieldRef$Type extends MessageType<FieldRef> {
         /* string field_name = 3; */
         if (message.fieldName !== "")
             writer.tag(3, WireType.LengthDelimited).string(message.fieldName);
+        /* optional bytes resource_signature = 4; */
+        if (message.resourceSignature !== undefined)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.resourceSignature);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/import.ts

@@ -27,8 +27,8 @@ import { BytesValue } from "../../../../../google/protobuf/wrappers";
 import { Any } from "../../../../../google/protobuf/any";
 import { Empty } from "../../../../../google/protobuf/empty";
 /**
- * Makes protobuf to forcefully compile all well-known types into code (for TS)
- * or just add dependencies on them (for go)
+ * Forces protobuf to compile all well-known types into code (for TS)
+ * or just adds dependencies on them (for go)
  *
  * @generated from protobuf message MiLaboratories.PL._Stub._ImportWellKnown
  */

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/resource_types.ts

@@ -137,6 +137,10 @@ export interface NotificationFilter_EventFilter {
      * @generated from protobuf field: optional bool resource_ready = 5
      */
     resourceReady?: boolean;
+    /**
+     * @generated from protobuf field: optional bool resource_recovered = 18
+     */
+    resourceRecovered?: boolean;
     /**
      * @generated from protobuf field: optional bool resource_duplicate = 6
      */
@@ -485,6 +489,7 @@ class NotificationFilter_EventFilter$Type extends MessageType<NotificationFilter
             { no: 2, name: "resource_created", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
             { no: 3, name: "resource_deleted", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
             { no: 5, name: "resource_ready", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 18, name: "resource_recovered", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
             { no: 6, name: "resource_duplicate", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
             { no: 16, name: "resource_error", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
             { no: 13, name: "inputs_locked", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
@@ -522,6 +527,9 @@ class NotificationFilter_EventFilter$Type extends MessageType<NotificationFilter
                 case /* optional bool resource_ready */ 5:
                     message.resourceReady = reader.bool();
                     break;
+                case /* optional bool resource_recovered */ 18:
+                    message.resourceRecovered = reader.bool();
+                    break;
                 case /* optional bool resource_duplicate */ 6:
                     message.resourceDuplicate = reader.bool();
                     break;
@@ -618,6 +626,9 @@ class NotificationFilter_EventFilter$Type extends MessageType<NotificationFilter
         /* optional bool field_got_error = 17; */
         if (message.fieldGotError !== undefined)
             writer.tag(17, WireType.Varint).bool(message.fieldGotError);
+        /* optional bool resource_recovered = 18; */
+        if (message.resourceRecovered !== undefined)
+            writer.tag(18, WireType.Varint).bool(message.resourceRecovered);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/src/proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/ws-test.ts

@@ -3,7 +3,7 @@
 // tslint:disable
 //
 //
-// This is dirty implementation of custom protocol for fast WebSocket support testing in
+// This is a dirty implementation of a custom protocol for fast WebSocket support testing in
 // environments with ZScaler or other similar MITM corporate proxies.
 //
 //
@@ -32,11 +32,11 @@ export interface PingWS_Request {
     /**
      * @generated from protobuf field: int32 replies_count = 2
      */
-    repliesCount: number; // amount of Response messages to send (0 - send nothing)
+    repliesCount: number; // number of Response messages to send (0 - send nothing)
     /**
      * @generated from protobuf field: bool close = 3
      */
-    close: boolean; // make server to close connection after sending responses
+    close: boolean; // make the server close connection after sending responses
 }
 /**
  * @generated from protobuf message MiLaboratories.PL.WSTest.PingWS.Response

package/src/proto-grpc/google/protobuf/descriptor.ts

@@ -1260,8 +1260,6 @@ export enum FieldOptions_JSType {
 }
 /**
  * If set to RETENTION_SOURCE, the option will be omitted from the binary.
- * Note: as of January 2023, support for this is in progress and does not yet
- * have an effect (b/264593489).
  *
  * @generated from protobuf enum google.protobuf.FieldOptions.OptionRetention
  */
@@ -1282,8 +1280,7 @@ export enum FieldOptions_OptionRetention {
 /**
  * This indicates the types of entities that the field may apply to when used
  * as an option. If it is unset, then the field may be freely used as an
- * option on any kind of entity. Note: as of January 2023, support for this is
- * in progress and does not yet have an effect (b/264593489).
+ * option on any kind of entity.
  *
  * @generated from protobuf enum google.protobuf.FieldOptions.OptionTargetType
  */
@@ -2070,7 +2067,7 @@ export enum Edition {
     EDITION_2024 = 1001,
     /**
      * Placeholder editions for testing feature resolution.  These should not be
-     * used or relyed on outside of tests.
+     * used or relied on outside of tests.
      *
      * @generated from protobuf enum value: EDITION_1_TEST_ONLY = 1;
      */

package/src/proto-grpc/google/protobuf/struct.ts

@@ -178,7 +178,7 @@ class Struct$Type extends MessageType<Struct> {
     /**
      * Encode `Struct` to JSON object.
      */
-    internalJsonWrite(message: Struct, _options: JsonWriteOptions): JsonValue {
+    internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue {
         let json: JsonObject = {};
         for (let [k, v] of Object.entries(message.fields)) {
             json[k] = Value.toJson(v);