@versori/run 0.1.0-alpha.11 → 0.1.0-alpha.13

package/esm/src/interpreter/memory/compilers/webhook.js

@@ -1,71 +1,136 @@
 // In src/interpreter/memory/compilers/webhook.ts
+import cors from 'cors';
 import { Observable } from 'rxjs';
+import { pipeline } from "node:stream/promises";
 import { WebhookTrigger } from '../../../dsl/triggers/WebhookTrigger.js';
+const DEFAULT_SYNC_ON_SUCCESS = (ctx) => new Response(JSON.stringify(ctx.data), { status: 200 });
+const DEFAULT_SYNC_ON_ERROR = (ctx) => new Response(JSON.stringify({ message: 'Internal server error', error: ctx.data }), {
+    status: 500,
+});
+const DEFAULT_ASYNC_ON_SUCCESS = (ctx) => new Response(JSON.stringify({
+    status: 'accepted',
+    executionId: ctx.executionId,
+    startTime: ctx.startTime,
+}), { status: 202 });
+const DEFAULT_ASYNC_ON_ERROR = (ctx) => new Response(JSON.stringify({
+    message: 'Internal server error',
+    executionId: ctx.executionId,
+    startTime: ctx.startTime,
+}), {
+    status: 500,
+});
 export const webhookCompiler = {
     ctor: WebhookTrigger,
     compile: (ctx, trigger, signal) => {
+        const { response: { mode = 'async', } = {}, cors: corsOptions, } = trigger.options;
+        const isSync = mode === 'sync';
+        const isAsync = mode === 'async';
+        if (!isSync && !isAsync) {
+            throw new Error('Invalid response mode, must be either "sync" or "async"');
+        }
+        let onSuccess = isSync ? DEFAULT_SYNC_ON_SUCCESS : DEFAULT_ASYNC_ON_SUCCESS;
+        let onError = isSync ? DEFAULT_SYNC_ON_ERROR : DEFAULT_ASYNC_ON_ERROR;
+        if (trigger.options.response?.onSuccess) {
+            onSuccess = trigger.options.response.onSuccess;
+        }
+        if (trigger.options.response?.onError) {
+            onError = trigger.options.response.onError;
+        }
+        const ctxOptionsFn = (res) => ({
+            onSuccess: (ctx) => {
+                if (isSync) {
+                    sendResponse(res, onSuccess(ctx));
+                }
+            },
+            onError: (ctx) => {
+                if (isSync) {
+                    sendResponse(res, onError(ctx));
+                }
+            },
+        });
         return new Observable((subscriber) => {
             if (!ctx.router) {
                 throw new Error('Router not available in compiler context');
             }
             // add the webhook endpoint to the router
             ctx.log.info('webhook endpoint added:', { trigger });
+            if (corsOptions) {
+                if (typeof corsOptions === 'boolean') {
+                    ctx.router.use(cors());
+                }
+                else {
+                    ctx.router.use(cors(corsOptions));
+                }
+            }
             // endpoint for sans user because I'm not quite sure how the dynamic routing works
             ctx.router.post(`/${trigger.id}`, (req, res) => {
-                const executionCtx = ctx.contextProvider.create(req.body, undefined);
+                const executionCtx = ctx.contextProvider.create(req.body, ctxOptionsFn(res));
                 try {
                     subscriber.next(executionCtx);
-                    res.status(200).json({ status: 'accepted' });
+                    if (isAsync) {
+                        sendResponse(res, onSuccess(executionCtx));
+                    }
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    executionCtx.log.error('webhook execution error', { error });
-                    res.status(500).json({ status: 'error', message });
+                    executionCtx.log.error('webhook execution error', {
+                        error: JSON.stringify(error),
+                    });
+                    if (isAsync) {
+                        sendResponse(res, onError(executionCtx.withData(error)));
+                    }
                 }
             });
             // this endpoint will trigger the workflow for each activation given by the external user ID
             ctx.router.post(`/${trigger.id}/users/:userId`, async (req, res) => {
-                const userId = req.params.userId || undefined;
-                if (!userId) {
-                    res.status(400).json({ status: 'error', message: 'User ID is required' });
-                    return;
-                }
+                const userId = req.params.userId;
                 const activations = await ctx.connectionProvider.getUserActivations(userId);
-                if (!activations || activations.length === 0) {
-                    res.status(404).json({ status: 'error', message: `No activations found for user: ${userId}` });
-                    return;
-                }
+                const executionCtx = ctx.contextProvider.create(req.body, ctxOptionsFn(res));
+                const errors = [];
                 activations.forEach((activation) => {
-                    const executionCtx = ctx.contextProvider.create(req.body, activation);
+                    const activationCtx = executionCtx.withActivation(activation);
                     try {
-                        subscriber.next(executionCtx);
+                        subscriber.next(activationCtx);
                     }
                     catch (error) {
-                        const message = error instanceof Error ? error.message : 'Unknown error';
-                        executionCtx.log.error('webhook execution error', { error });
-                        res.status(500).json({ status: 'error', message });
+                        activationCtx.log.error('webhook execution error', {
+                            error: JSON.stringify(error),
+                        });
+                        errors.push({
+                            activationId: activation.id,
+                            error,
+                        });
                     }
                 });
-                res.status(200).json({ status: 'accepted' });
+                if (isAsync) {
+                    if (errors.length === 0) {
+                        sendResponse(res, onSuccess(executionCtx));
+                    }
+                    else {
+                        sendResponse(res, onError(executionCtx.withData(errors)));
+                    }
+                }
             });
             // this endpoint will trigger the workflow only for the activation given by its ID
             ctx.router.post(`/${trigger.id}/activations/:activationId`, async (req, res) => {
-                const activationId = req.params.activationId || undefined;
+                const activationId = req.params.activationId;
                 const activation = await ctx.connectionProvider.getActivation(activationId);
-                if (!activation) {
-                    // TODO report back actual errors
-                    res.status(404).json({ status: 'error', message: `No activation found for ID: ${activationId}` });
-                    return;
-                }
-                const executionCtx = ctx.contextProvider.create(req.body, activation);
+                const activationCtx = ctx.contextProvider.create(req.body, {
+                    ...ctxOptionsFn(res),
+                    activation,
+                });
                 try {
-                    subscriber.next(executionCtx);
-                    res.status(200).json({ status: 'accepted' });
+                    subscriber.next(activationCtx);
+                    if (isAsync) {
+                        sendResponse(res, onSuccess(activationCtx));
+                    }
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    executionCtx.log.error('webhook execution error', { error });
-                    res.status(500).json({ status: 'error', message });
+                    activationCtx.log.error('webhook execution error', {
+                        error: JSON.stringify(error),
+                    });
+                    if (isAsync) {
+                        sendResponse(res, onError(activationCtx.withData(error)));
+                    }
                 }
             });
             function cleanup() {
@@ -80,3 +145,12 @@ export const webhookCompiler = {
         });
     },
 };
+function sendResponse(res, response) {
+    res.status(response.status);
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    if (response.body) {
+        pipeline(response.body, res);
+    }
+}

package/esm/src/kv/nats/NatsKeyValueProvider.d.ts

@@ -1,4 +1,4 @@
-import { TlsOptions } from '@nats-io/transport-deno';
+import { TlsOptions } from '../../../deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.js';
 import { DestroyOptions, KeyValue, KeyValueProvider, KVOptions } from '../KeyValue.js';
 export type NatsKeyValueProviderOptions = {
     organizationId: string;
@@ -19,6 +19,7 @@ export declare class NatsKeyValueProvider implements KeyValueProvider, AsyncDisp
     private constructor();
     static newInstance(opts?: Partial<NatsKeyValueProviderOptions>): Promise<NatsKeyValueProvider>;
     static fromEnv(): Promise<NatsKeyValueProvider>;
+    [Symbol.asyncDispose](): PromiseLike<void>;
     kv(options: KVOptions): KeyValue;
     destroy(options: DestroyOptions): Promise<void>;
     private subjectPrefix;

package/esm/src/kv/nats/NatsKeyValueProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NatsKeyValueProvider.d.ts","sourceRoot":"","sources":["../../../../src/src/kv/nats/NatsKeyValueProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EACH,cAAc,EAEd,QAAQ,EACR,gBAAgB,EAChB,SAAS,EACZ,MAAM,gBAAgB,CAAC;AA4CxB,MAAM,MAAM,2BAA2B,GAAG;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE;QACF,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;CACL,CAAC;AAuBF,qBAAa,oBAAqB,YAAW,gBAAgB,EAAE,eAAe;IAEtE,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IALzB,OAAO;WAQM,WAAW,CACpB,IAAI,GAAE,OAAO,CAAC,2BAA2B,CAAM,GAChD,OAAO,CAAC,oBAAoB,CAAC;IA0BhC,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAQ/C,EAAE,CAAC,OAAO,EAAE,SAAS,GAAG,QAAQ;IAqB1B,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBrD,OAAO,CAAC,aAAa;CAYxB"}
+{"version":3,"file":"NatsKeyValueProvider.d.ts","sourceRoot":"","sources":["../../../../src/src/kv/nats/NatsKeyValueProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,UAAU,EAAE,MAAM,+DAA+D,CAAC;AACxH,OAAO,EACH,cAAc,EAEd,QAAQ,EACR,gBAAgB,EAChB,SAAS,EACZ,MAAM,gBAAgB,CAAC;AA4CxB,MAAM,MAAM,2BAA2B,GAAG;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE;QACF,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;CACL,CAAC;AAuBF,qBAAa,oBAAqB,YAAW,gBAAgB,EAAE,eAAe;IAEtE,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IALzB,OAAO;WAQM,WAAW,CACpB,IAAI,GAAE,OAAO,CAAC,2BAA2B,CAAM,GAChD,OAAO,CAAC,oBAAoB,CAAC;IA0BhC,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAI/C,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC;IAI1C,EAAE,CAAC,OAAO,EAAE,SAAS,GAAG,QAAQ;IAqB1B,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBrD,OAAO,CAAC,aAAa;CAYxB"}

package/esm/src/kv/nats/NatsKeyValueProvider.js

@@ -1,6 +1,6 @@
 import { JetStreamApiCodes, JetStreamApiError } from '../../../deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.js';
 import { Kvm } from '../../../deps/jsr.io/@nats-io/kv/3.0.2/src/mod.js';
-import { connect, credsAuthenticator } from '@nats-io/transport-deno';
+import { connect, credsAuthenticator } from '../../../deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.js';
 import { isKVOptionsExecution, } from '../KeyValue.js';
 import { NatsKeyValue } from './NatsKeyValue.js';
 function getOptionsFromEnv() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versori/run",
-  "version": "v0.1.0-alpha.11",
+  "version": "0.1.0-alpha.13",
   "description": "Versori Run",
   "homepage": "https://github.com/versori/versori-run#readme",
   "repository": {
@@ -28,6 +28,7 @@
     "@connectrpc/connect-node": "^2.0.1",
     "cron": "3.5.0",
     "express": "^4.18.3",
+    "lru-cache": "^11.0.2",
     "rxjs": "^7.8.1",
     "tweetnacl": "1.0.3"
   },

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/connect.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectionOptions, NatsConnection } from "../../../nats-core/3.0.2/src/internal_mod.js";
+export declare function connect(opts?: ConnectionOptions): Promise<NatsConnection>;
+//# sourceMappingURL=connect.d.ts.map

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/connect.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EAGf,MAAM,8CAA8C,CAAC;AAStD,wBAAgB,OAAO,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAiB7E"}

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/connect.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+/*
+ * Copyright 2020-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const deno_transport_js_1 = require("./deno_transport.js");
+const internal_mod_js_1 = require("../../../nats-core/3.0.2/src/internal_mod.js");
+function connect(opts = {}) {
+    if ((0, internal_mod_js_1.hasWsProtocol)(opts)) {
+        return Promise.reject(internal_mod_js_1.errors.InvalidArgumentError.format(`servers`, `deno client doesn't support websockets, use the 'wsconnect' function instead`));
+    }
+    (0, internal_mod_js_1.setTransportFactory)({
+        factory: () => {
+            return new deno_transport_js_1.DenoTransport();
+        },
+        dnsResolveFn: deno_transport_js_1.denoResolveHost,
+    });
+    return internal_mod_js_1.NatsConnectionImpl.connect(opts);
+}

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/deno_transport.d.ts

@@ -0,0 +1,35 @@
+import type { ConnectionOptions, ServerInfo, Transport } from "../../../nats-core/3.0.2/src/internal_mod.js";
+export declare class DenoTransport implements Transport {
+    version: string;
+    lang: string;
+    closeError?: Error;
+    private options;
+    private buf;
+    private encrypted;
+    private done;
+    private closedNotification;
+    private conn;
+    private frames;
+    private pendingWrite;
+    constructor();
+    connect(hp: {
+        hostname: string;
+        port: number;
+        tlsName: string;
+    }, options: ConnectionOptions): Promise<void>;
+    get isClosed(): boolean;
+    peekInfo(): Promise<ServerInfo>;
+    loadTlsOptions(hostname: string): Promise<Deno.StartTlsOptions>;
+    startTLS(hostname: string): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array>;
+    maybeWriteFrame(): void;
+    send(frame: Uint8Array): void;
+    isEncrypted(): boolean;
+    close(err?: Error): Promise<void>;
+    disconnect(): void;
+    _closed(err?: Error, internal?: boolean): Promise<void>;
+    closed(): Promise<void | Error>;
+    discard(): void;
+}
+export declare function denoResolveHost(s: string): Promise<string[]>;
+//# sourceMappingURL=deno_transport.d.ts.map

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/deno_transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno_transport.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/deno_transport.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,iBAAiB,EAEjB,UAAU,EAEV,SAAS,EACV,MAAM,8CAA8C,CAAC;AAUtD,qBAAa,aAAc,YAAW,SAAS;IAC7C,OAAO,EAAE,MAAM,CAAW;IAC1B,IAAI,EAAE,MAAM,CAAQ;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,kBAAkB,CAAsC;IAChE,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,YAAY,CAAuB;;IAQrC,OAAO,CACX,EAAE,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EACvD,OAAO,EAAE,iBAAiB;IA4C5B,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAEK,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAgC/B,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC;IAoB/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,UAAU,CAAC;IA2BlE,eAAe,IAAI,IAAI;IAuBvB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAU7B,WAAW,IAAI,OAAO;IAItB,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjC,UAAU;IAKJ,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,QAAQ,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC1D,MAAM,IAAI,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC;IAI/B,OAAO;CAGR;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAelE"}

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/deno_transport.js

@@ -0,0 +1,333 @@
+"use strict";
+/*
+ * Copyright 2020-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenoTransport = void 0;
+exports.denoResolveHost = denoResolveHost;
+const internal_mod_js_1 = require("../../../nats-core/3.0.2/src/internal_mod.js");
+const mod_js_1 = require("../../../../@std/io/0.225.2/mod.js");
+const version_js_1 = require("./version.js");
+const VERSION = version_js_1.version;
+const LANG = "nats.deno";
+const ReadBufferSize = 1024 * 256;
+class DenoTransport {
+    constructor() {
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: VERSION
+        });
+        Object.defineProperty(this, "lang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: LANG
+        });
+        Object.defineProperty(this, "closeError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "buf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "encrypted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "closedNotification", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, internal_mod_js_1.deferred)()
+        });
+        Object.defineProperty(this, "conn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "frames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendingWrite", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.buf = new Uint8Array(ReadBufferSize);
+        this.frames = [];
+        this.pendingWrite = null;
+    }
+    async connect(hp, options) {
+        this.options = options;
+        const { tls } = this.options;
+        const { handshakeFirst } = tls || {};
+        try {
+            if (handshakeFirst === true) {
+                const opts = await this.loadTlsOptions(hp.hostname);
+                const ctls = {
+                    caCerts: opts.caCerts,
+                    hostname: hp.hostname,
+                    port: hp.port,
+                };
+                this.conn = await Deno.connectTls(ctls);
+                this.encrypted = true;
+                // do nothing yet.
+            }
+            else {
+                this.conn = await Deno.connect(hp);
+            }
+            if (this.done) {
+                this.conn.close();
+            }
+            const info = await this.peekInfo();
+            (0, internal_mod_js_1.checkOptions)(info, this.options);
+            const { tls_required: tlsRequired, tls_available: tlsAvailable } = info;
+            const desired = tlsAvailable === true && options.tls !== null;
+            if (!handshakeFirst && (tlsRequired || desired)) {
+                const tlsn = hp.tlsName ? hp.tlsName : hp.hostname;
+                await this.startTLS(tlsn);
+            }
+            if (this.done) {
+                this.conn.close();
+            }
+        }
+        catch (err) {
+            this.conn?.close();
+            const _err = err;
+            throw new internal_mod_js_1.errors.ConnectionError(_err.message.toLowerCase(), {
+                cause: err,
+            });
+        }
+    }
+    get isClosed() {
+        return this.done;
+    }
+    async peekInfo() {
+        const inbound = new internal_mod_js_1.DataBuffer();
+        let pm;
+        while (true) {
+            const c = await this.conn.read(this.buf);
+            if (c === null) {
+                // EOF
+                throw new Error("socket closed while expecting INFO");
+            }
+            else if (c) {
+                const frame = this.buf.subarray(0, c);
+                if (this.options.debug) {
+                    console.info(`> ${(0, internal_mod_js_1.render)(frame)}`);
+                }
+                inbound.fill(frame);
+                const raw = inbound.peek();
+                pm = (0, internal_mod_js_1.extractProtocolMessage)(raw);
+                if (pm !== "") {
+                    break;
+                }
+            }
+        }
+        // reset the buffer to previously read, so the client
+        // can validate the info matches the connection
+        this.buf = new Uint8Array(inbound.drain());
+        // expecting the info protocol
+        const m = internal_mod_js_1.INFO.exec(pm);
+        if (!m) {
+            throw new Error("unexpected response from server");
+        }
+        return JSON.parse(m[1]);
+    }
+    async loadTlsOptions(hostname) {
+        const tls = this.options && this.options.tls
+            ? this.options.tls
+            : {};
+        // these options are not available in Deno
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.ca", tls.ca);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.cert", tls.cert);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.certFile", tls.certFile);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.key", tls.key);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.keyFile", tls.keyFile);
+        const sto = { hostname };
+        if (tls.caFile) {
+            const ca = await Deno.readTextFile(tls.caFile);
+            sto.caCerts = [ca];
+        }
+        return sto;
+    }
+    async startTLS(hostname) {
+        const sto = await (this.loadTlsOptions(hostname));
+        this.conn = await Deno.startTls(
+        //@ts-ignore: just the conn
+        this.conn, sto);
+        // this is necessary because the startTls process doesn't
+        // reject a bad certificate, however the next write will.
+        // to identify this as the error, we force it
+        await this.conn.write(internal_mod_js_1.Empty);
+        this.encrypted = true;
+    }
+    async *[Symbol.asyncIterator]() {
+        let reason;
+        // yield what we initially read
+        yield this.buf;
+        while (!this.done) {
+            try {
+                this.buf = new Uint8Array(ReadBufferSize);
+                const c = await this.conn.read(this.buf);
+                if (c === null) {
+                    break;
+                }
+                if (c) {
+                    const frame = this.buf.subarray(0, c);
+                    if (this.options.debug) {
+                        console.info(`> ${(0, internal_mod_js_1.render)(frame)}`);
+                    }
+                    yield frame;
+                }
+            }
+            catch (err) {
+                reason = err;
+                break;
+            }
+        }
+        this._closed(reason).then().catch();
+    }
+    maybeWriteFrame() {
+        if (this.pendingWrite) {
+            return;
+        }
+        const frame = this.frames.shift();
+        if (!frame) {
+            return;
+        }
+        this.pendingWrite = (0, mod_js_1.writeAll)(this.conn, frame).then(() => {
+            this.pendingWrite = null;
+            this.maybeWriteFrame();
+        }).then(() => {
+            if (this.options.debug) {
+                console.info(`< ${(0, internal_mod_js_1.render)(frame)}`);
+            }
+        }).catch((err) => {
+            if (this.options.debug) {
+                console.error(`!!! ${(0, internal_mod_js_1.render)(frame)}: ${err}`);
+            }
+        });
+    }
+    send(frame) {
+        // if we are closed, don't do anything
+        if (this.done) {
+            return;
+        }
+        // push the frame
+        this.frames.push(frame);
+        this.maybeWriteFrame();
+    }
+    isEncrypted() {
+        return this.encrypted;
+    }
+    close(err) {
+        return this._closed(err, false);
+    }
+    disconnect() {
+        this._closed(undefined, true)
+            .then().catch();
+    }
+    async _closed(err, internal = true) {
+        if (this.done) {
+            // it is possible for close to be called before the connection
+            // ever happens or after the protocol requested a close (async connection/upgrade)
+            // so even if we already cleaned up, attempt to close the connection
+            try {
+                this.conn?.close();
+            }
+            catch (_err) {
+                // ignored
+            }
+            return;
+        }
+        this.done = true;
+        this.closeError = err;
+        if (!err && internal) {
+            try {
+                // this is a noop but gives us a place to hang
+                // a close and ensure that we sent all before closing
+                // we wait for the operation to fail or succeed
+                this.frames.push(internal_mod_js_1.Empty);
+                this.maybeWriteFrame();
+                if (this.pendingWrite) {
+                    await this.pendingWrite;
+                }
+            }
+            catch (err) {
+                if (this.options.debug) {
+                    console.log("transport close terminated with an error", err);
+                }
+            }
+        }
+        try {
+            this.conn?.close();
+        }
+        catch (_err) {
+            // ignored
+        }
+        if (internal) {
+            this.closedNotification.resolve(err);
+        }
+    }
+    closed() {
+        return this.closedNotification;
+    }
+    discard() {
+        // ignored - this is not required, as there's no throttling
+    }
+}
+exports.DenoTransport = DenoTransport;
+async function denoResolveHost(s) {
+    const a = Deno.resolveDns(s, "A");
+    const aaaa = Deno.resolveDns(s, "AAAA");
+    const ips = [];
+    const w = await Promise.allSettled([a, aaaa]);
+    if (w[0].status === "fulfilled") {
+        ips.push(...w[0].value);
+    }
+    if (w[1].status === "fulfilled") {
+        ips.push(...w[1].value);
+    }
+    if (ips.length === 0) {
+        ips.push(s);
+    }
+    return ips;
+}

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.d.ts

@@ -0,0 +1,3 @@
+export { connect } from "./connect.js";
+export * from "../../../nats-core/3.0.2/src/mod.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,qCAAqC,CAAC"}