@superdurable/dex 0.8.0 → 0.9.0

package/README.md

@@ -480,3 +480,14 @@ publisher with organization `superdurable`, repository `dex`, workflow
 Future releases use short-lived OIDC credentials and require no `NPM_TOKEN`.
 After verifying the first OIDC release, configure npm publishing access to
 require 2FA and disallow token-based publication.
+
+## Server protocol compatibility
+
+Worker startup calls `GetServerInfo`, negotiates the highest common protocol,
+synchronizes Attribute indexes, and then binds WorkerService. The initial
+TypeScript SDK interval is `[1,1]`. Missing information, invalid or disjoint
+intervals, and RPC failures stop startup before binding.
+
+The build generates the diagnostic SDK version from `package.json`, so the
+runtime value follows the version stamped by the release workflow. The artifact
+version does not participate in compatibility decisions.

package/dist/src/gen/dex.d.ts

@@ -190,6 +190,15 @@ export declare enum SubFlowCompletionDeliveryStatus {
     SUB_FLOW_COMPLETION_DELIVERY_STATUS_PARENT_CLOSED_OR_NOT_FOUND = 2,
     UNRECOGNIZED = -1
 }
+/** Describes the Dex Server release and the inclusive protocol range it supports. */
+export interface ServerInfo {
+    /** Identifies the Server artifact for diagnostics. Compatibility uses only the protocol range. */
+    serverVersion: string;
+    /** Oldest protocol version still accepted by this Server. */
+    minimumSupportedProtocolVersion: number;
+    /** Newest protocol version implemented by this Server. */
+    currentProtocolVersion: number;
+}
 export interface Value {
     kind: //
     /** Hydrate from blob storage, then replace with string_value. */
@@ -1433,6 +1442,7 @@ export interface InvokeRpcUpdateResult {
 export interface StepExecutionNumbers {
     numbers: number[];
 }
+export declare const ServerInfo: MessageFns<ServerInfo>;
 export declare const Value: MessageFns<Value>;
 export declare const EncodedObject: MessageFns<EncodedObject>;
 export declare const AttributeWrite: MessageFns<AttributeWrite>;
@@ -1623,6 +1633,16 @@ export declare const StepExecutionNumbers: MessageFns<StepExecutionNumbers>;
 /** Hosted by Dex server; SDKs call these RPCs. */
 export type FlowServiceService = typeof FlowServiceService;
 export declare const FlowServiceService: {
+    /** Returns diagnostic release metadata and the Server's inclusive protocol interval. */
+    readonly getServerInfo: {
+        readonly path: "/dex.FlowService/GetServerInfo";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: Empty) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => Empty;
+        readonly responseSerialize: (value: ServerInfo) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ServerInfo;
+    };
     readonly startFlow: {
         readonly path: "/dex.FlowService/StartFlow";
         readonly requestStream: false;
@@ -1859,6 +1879,8 @@ export declare const FlowServiceService: {
     };
 };
 export interface FlowServiceServer extends UntypedServiceImplementation {
+    /** Returns diagnostic release metadata and the Server's inclusive protocol interval. */
+    getServerInfo: handleUnaryCall<Empty, ServerInfo>;
     startFlow: handleUnaryCall<StartFlowRequest, StartFlowResponse>;
     publishToChannel: handleUnaryCall<PublishToChannelRequest, Empty>;
     getChannelMessages: handleUnaryCall<GetChannelMessagesRequest, GetChannelMessagesResponse>;
@@ -1887,6 +1909,10 @@ export interface FlowServiceServer extends UntypedServiceImplementation {
     healthCheck: handleUnaryCall<Empty, HealthInfo>;
 }
 export interface FlowServiceClient extends Client {
+    /** Returns diagnostic release metadata and the Server's inclusive protocol interval. */
+    getServerInfo(request: Empty, callback: (error: ServiceError | null, response: ServerInfo) => void): ClientUnaryCall;
+    getServerInfo(request: Empty, metadata: Metadata, callback: (error: ServiceError | null, response: ServerInfo) => void): ClientUnaryCall;
+    getServerInfo(request: Empty, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ServerInfo) => void): ClientUnaryCall;
     startFlow(request: StartFlowRequest, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;
     startFlow(request: StartFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;
     startFlow(request: StartFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;

package/dist/src/gen/dex.js

@@ -219,6 +219,69 @@ export var SubFlowCompletionDeliveryStatus;
     SubFlowCompletionDeliveryStatus[SubFlowCompletionDeliveryStatus["SUB_FLOW_COMPLETION_DELIVERY_STATUS_PARENT_CLOSED_OR_NOT_FOUND"] = 2] = "SUB_FLOW_COMPLETION_DELIVERY_STATUS_PARENT_CLOSED_OR_NOT_FOUND";
     SubFlowCompletionDeliveryStatus[SubFlowCompletionDeliveryStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(SubFlowCompletionDeliveryStatus || (SubFlowCompletionDeliveryStatus = {}));
+function createBaseServerInfo() {
+    return { serverVersion: "", minimumSupportedProtocolVersion: 0, currentProtocolVersion: 0 };
+}
+export const ServerInfo = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.serverVersion !== "") {
+            writer.uint32(10).string(message.serverVersion);
+        }
+        if (message.minimumSupportedProtocolVersion !== 0) {
+            writer.uint32(16).uint32(message.minimumSupportedProtocolVersion);
+        }
+        if (message.currentProtocolVersion !== 0) {
+            writer.uint32(24).uint32(message.currentProtocolVersion);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseServerInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.serverVersion = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.minimumSupportedProtocolVersion = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.currentProtocolVersion = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return ServerInfo.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseServerInfo();
+        message.serverVersion = object.serverVersion ?? "";
+        message.minimumSupportedProtocolVersion = object.minimumSupportedProtocolVersion ?? 0;
+        message.currentProtocolVersion = object.currentProtocolVersion ?? 0;
+        return message;
+    },
+};
 function createBaseValue() {
     return { kind: undefined };
 }
@@ -14400,6 +14463,16 @@ export const StepExecutionNumbers = {
     },
 };
 export const FlowServiceService = {
+    /** Returns diagnostic release metadata and the Server's inclusive protocol interval. */
+    getServerInfo: {
+        path: "/dex.FlowService/GetServerInfo",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
+        requestDeserialize: (value) => Empty.decode(value),
+        responseSerialize: (value) => Buffer.from(ServerInfo.encode(value).finish()),
+        responseDeserialize: (value) => ServerInfo.decode(value),
+    },
     startFlow: {
         path: "/dex.FlowService/StartFlow",
         requestStream: false,