@sequenceholdings/artifact-studio 0.8.0 → 0.8.1

package/dist/tunnel/redis.js

@@ -4,6 +4,9 @@ import { redisIdentifier as identifier, redisNamespaceSchema as namespaceSchema,
 import { RelaySocket } from './redis-socket.js';
 import { deriveRelayFrameKey, RelayFrameAuthenticator } from './redis-auth.js';
 export { RedisTunnelOwnership } from './redis-ownership.js';
+// Broker stream IDs are UUIDs. This authenticated, otherwise-unused ACK is ignored by old
+// owners and never forwarded to the developer. It negotiates cancel-as-completion-receipt.
+const DRAIN_CAPABILITY_ID = 'relay-drain-v1';
 /** Internal Redis channels contain authorized application traffic. Deploy them
  * on the environment's private, authenticated Redis and disable command replay.
  * Every message is authenticated with a gateway-only key: other Redis clients
@@ -12,6 +15,10 @@ export class RedisTunnelRelay {
     options;
     started = false;
     closed = false;
+    draining = false;
+    drainSealed = false;
+    drainWork = Promise.resolve();
+    drainWaiters = new Set();
     attached = new Map();
     connected = new Map();
     frames;
@@ -165,10 +172,14 @@ export class RedisTunnelRelay {
     }
     async attachOwned(input, socket) {
         this.assertStarted();
+        if (this.draining)
+            throw new Error('Tunnel relay is draining');
         const lease = await this.verifiedLease(input);
         if (!(await this.current(lease, this.options.nodeId)) || socket.readyState !== 1)
             throw new Error('Tunnel is owned by another node');
         this.assertStarted();
+        if (this.draining)
+            throw new Error('Tunnel relay is draining');
         const previous = this.attached.get(lease.sessionId);
         if (previous && previous.lease.epoch >= lease.epoch)
             throw new Error('Duplicate tunnel owner');
@@ -242,6 +253,10 @@ export class RedisTunnelRelay {
         }
         const remote = owner.remotes.get(message.connection);
         if (message.type === 'open') {
+            if (this.draining && (this.drainSealed || message.source !== this.options.nodeId)) {
+                await this.publish(message.source, this.envelope(owner.lease, message.connection, 'close', 'requester'));
+                return;
+            }
             if (remote || owner.remotes.size >= DEFAULT_TUNNEL_LIMITS.maxStreams)
                 throw new Error('Duplicate or excessive tunnel connections');
             owner.remotes.set(message.connection, { nodeId: message.source, connection: message.connection, lastSeen: Date.now() });
@@ -272,6 +287,11 @@ export class RedisTunnelRelay {
         if (message.type === 'ready') {
             if (connection.socket.readyState !== 0)
                 throw new Error('Duplicate tunnel ready');
+            // Publish before exposing the socket, preserving marker-before-request ordering even
+            // when this node is also the owner. Old owners ignore ACKs for unknown stream IDs.
+            await this.publish(connection.ownerNode, this.envelope(connection.lease, message.connection, 'frame', 'owner', JSON.stringify({ type: 'ack', id: DRAIN_CAPABILITY_ID, bytes: 1 })));
+            if (this.connected.get(message.connection) !== connection || connection.socket.readyState !== 0)
+                return;
             clearTimeout(connection.timer);
             connection.socket.readyState = 1;
             connection.resolve(connection.socket);
@@ -287,6 +307,11 @@ export class RedisTunnelRelay {
         const frame = parseTunnelFrame(raw);
         if (frame.type === 'ready' || frame.type === 'response' || frame.type === 'ws-open')
             throw new Error('Invalid requester frame direction');
+        if (frame.id === DRAIN_CAPABILITY_ID) {
+            if (frame.type === 'ack' && frame.bytes === 1)
+                remote.receipts = true;
+            return;
+        }
         const route = owner.streams.get(frame.id);
         if (frame.type === 'request') {
             if (route || owner.streams.size >= DEFAULT_TUNNEL_LIMITS.maxStreams) {
@@ -294,13 +319,37 @@ export class RedisTunnelRelay {
                 await this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'close', 'requester'));
                 return;
             }
-            owner.streams.set(frame.id, remote);
+            const refused = this.draining && (this.drainSealed || remote.nodeId !== this.options.nodeId || frame.websocket);
+            if (refused && frame.websocket) {
+                // Upgrades cannot consume HTTP response frames. Cancel only this stream; no
+                // route or completion receipt is needed because it never reached the developer.
+                await this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'frame', 'requester', JSON.stringify({ type: 'cancel', id: frame.id })));
+                return;
+            }
+            owner.streams.set(frame.id, { ...remote, websocket: frame.websocket, ended: refused });
+            if (refused) {
+                await this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'frame', 'requester', JSON.stringify({ type: 'response', id: frame.id, status: 503, headers: { 'cache-control': 'no-store' } })));
+                await this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'frame', 'requester', JSON.stringify({ type: 'end', id: frame.id })));
+                if (!remote.receipts)
+                    owner.streams.delete(frame.id);
+                this.notifyDrained();
+                return;
+            }
         }
         else if (!route || route.connection !== remote.connection || route.nodeId !== remote.nodeId)
             return;
-        if (frame.type === 'cancel' || frame.type === 'ws-close')
-            owner.streams.delete(frame.id);
+        if (route?.ended) {
+            if (frame.type === 'cancel' || frame.type === 'ws-close') {
+                owner.streams.delete(frame.id);
+                this.notifyDrained();
+            }
+            return;
+        }
         await this.writeDeveloper(owner, raw);
+        if (frame.type === 'cancel' || frame.type === 'ws-close') {
+            owner.streams.delete(frame.id);
+            this.notifyDrained();
+        }
     }
     writeDeveloper(owner, raw) {
         if (owner.stopped || owner.socket.readyState !== 1 || owner.socket.bufferedAmount + Buffer.byteLength(raw) > DEFAULT_TUNNEL_LIMITS.maxBufferedBytes) {
@@ -336,9 +385,15 @@ export class RedisTunnelRelay {
             const remote = owner.streams.get(frame.id);
             if (!remote)
                 return;
+            if (remote.ended)
+                return;
+            const retainReceipt = frame.type === 'end' && !remote.websocket && remote.receipts;
+            if (retainReceipt)
+                remote.ended = true;
             await this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'frame', 'requester', raw));
-            if (frame.type === 'end' || frame.type === 'cancel' || frame.type === 'ws-close')
+            if (!retainReceipt && (frame.type === 'end' || frame.type === 'cancel' || frame.type === 'ws-close'))
                 owner.streams.delete(frame.id);
+            this.notifyDrained();
         }).catch(() => this.closeOwner(owner)).finally(() => { owner.queuedBytes -= bytes; });
     }
     closeRemote(owner, remote) {
@@ -349,6 +404,7 @@ export class RedisTunnelRelay {
             owner.streams.delete(id);
             void this.writeDeveloper(owner, JSON.stringify({ type: 'cancel', id })).catch(() => this.closeOwner(owner));
         }
+        this.notifyDrained();
     }
     closeOwner(owner) {
         if (owner.stopped)
@@ -362,6 +418,7 @@ export class RedisTunnelRelay {
             void this.publish(remote.nodeId, this.envelope(owner.lease, remote.connection, 'close', 'requester')).catch(() => undefined);
         owner.remotes.clear();
         owner.streams.clear();
+        this.notifyDrained();
         void this.options.ownership.release(owner.lease.sessionId, owner.lease.epoch, this.options.nodeId).catch(() => undefined);
     }
     closeConnection(id, connection) {
@@ -387,6 +444,47 @@ export class RedisTunnelRelay {
                     return this.publish(remote.nodeId, { type: 'revoke', destination: 'owner', source: this.options.nodeId, connection: randomUUID(), sessionId, epoch: remote.epoch });
             }).catch(() => undefined);
     }
+    /** Reject new remote requests, but allow same-node work already admitted by the HTTP
+     * gateway until drain() seals it. Security checks and ownership timers stay live. */
+    beginDrain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        const cancellations = [];
+        for (const owner of this.attached.values())
+            for (const [id, route] of owner.streams) {
+                if (!route.websocket)
+                    continue;
+                route.ended = true;
+                const frame = JSON.stringify({ type: 'cancel', id });
+                cancellations.push(Promise.all([
+                    this.writeDeveloper(owner, frame),
+                    this.publish(route.nodeId, this.envelope(owner.lease, route.connection, 'frame', 'requester', frame)),
+                ]).then(() => { owner.streams.delete(id); this.notifyDrained(); }).catch(() => this.closeOwner(owner)));
+            }
+        this.drainWork = Promise.all(cancellations).then(() => undefined);
+    }
+    notifyDrained() {
+        if (!this.drainWaiters.size)
+            return;
+        for (const owner of this.attached.values())
+            if (owner.streams.size)
+                return;
+        for (const resolve of this.drainWaiters)
+            resolve();
+        this.drainWaiters.clear();
+    }
+    /** Updated requesters acknowledge consumed final responses with cancel. Keep those bounded
+     * routes even before drain starts to cover an end-vs-shutdown race. Legacy requesters retain
+     * the previous publish-only completion behavior; they never acquire a new receipt wait. */
+    async drain() {
+        this.beginDrain();
+        this.drainSealed = true;
+        await this.receiving;
+        await this.drainWork;
+        await new Promise((resolve) => { this.drainWaiters.add(resolve); this.notifyDrained(); });
+        await this.publishing;
+    }
     async close() {
         if (this.closed)
             return;

package/dist/tunnel/transport.d.ts

@@ -13,5 +13,8 @@ export interface TunnelRelay {
     attach(lease: TunnelLease, socket: TunnelSocket): Promise<void>;
     connect(lease: TunnelLease): Promise<TunnelSocket>;
     disconnect(sessionId: string): void;
+    /** Optional for custom adapters; built-in Redis retains owned finite streams during drain. */
+    beginDrain?(): void;
+    drain?(): Promise<void>;
     close(): Promise<void>;
 }

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "SDK types and CLI library for building Artifact Studio apps. Driven via `seq-studio artifact <sub>` (@sequenceholdings/studio-cli), which runs the `./cli` runCli export.",
   "type": "module",
   "exports": {
@@ -167,9 +167,9 @@
     "google-auth-library": "^10.5.0",
     "server-only": "0.0.1",
     "parse5": "7.3.0",
+    "@sequenceholdings/lattice-form-renderer": "0.2.0",
     "@sequenceholdings/storage": "0.1.1",
-    "@sequenceholdings/orm": "2.6.1",
-    "@sequenceholdings/lattice-form-renderer": "0.2.0"
+    "@sequenceholdings/orm": "2.6.2"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",