@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/script/js/packages/trellis/telemetry/runtime.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTelemetry = initTelemetry;
+const env_ts_1 = require("./env.js");
+let initialized = false;
+let provider;
+function runtimeImport(specifier) {
+    const load = new Function("specifier", "return import(specifier);");
+    return load(specifier);
+}
+async function loadTracingRuntime() {
+    const [traceNode, otlp, traceBase, resources, semantic] = await Promise.all([
+        runtimeImport(["@opentelemetry", "sdk-trace-node"].join("/")),
+        runtimeImport(["@opentelemetry", "exporter-trace-otlp-http"].join("/")),
+        runtimeImport(["@opentelemetry", "sdk-trace-base"].join("/")),
+        runtimeImport(["@opentelemetry", "resources"].join("/")),
+        runtimeImport(["@opentelemetry", "semantic-conventions"].join("/")),
+    ]);
+    return {
+        NodeTracerProvider: traceNode.NodeTracerProvider,
+        OTLPTraceExporter: otlp.OTLPTraceExporter,
+        BatchSpanProcessor: traceBase.BatchSpanProcessor,
+        ConsoleSpanExporter: traceBase.ConsoleSpanExporter,
+        Resource: resources.Resource,
+        ATTR_SERVICE_NAME: semantic.ATTR_SERVICE_NAME,
+    };
+}
+async function initTracingRuntime(serviceName) {
+    const endpoint = (0, env_ts_1.getEnv)("OTEL_EXPORTER_OTLP_ENDPOINT");
+    const consoleTracing = (0, env_ts_1.getEnv)("OTEL_TRACES_CONSOLE") === "true";
+    if (!endpoint && !consoleTracing) {
+        return;
+    }
+    try {
+        const runtime = await loadTracingRuntime();
+        const spanProcessors = [];
+        if (endpoint) {
+            spanProcessors.push(new runtime.BatchSpanProcessor(new runtime.OTLPTraceExporter({ url: `${endpoint}/v1/traces` })));
+        }
+        else if (consoleTracing) {
+            spanProcessors.push(new runtime.BatchSpanProcessor(new runtime.ConsoleSpanExporter()));
+        }
+        provider = new runtime.NodeTracerProvider({
+            resource: new runtime.Resource({
+                [runtime.ATTR_SERVICE_NAME]: serviceName,
+            }),
+            ...(spanProcessors.length > 0 ? { spanProcessors } : {}),
+        });
+        provider.register();
+    }
+    catch (error) {
+        console.warn("Failed to initialize tracing runtime", error);
+    }
+}
+function initTelemetry(serviceName) {
+    if (initialized)
+        return;
+    initialized = true;
+    void initTracingRuntime(serviceName);
+}

package/script/js/packages/trellis/telemetry/trace.d.ts

@@ -0,0 +1,5 @@
+import type { Context, Span } from "@opentelemetry/api";
+export declare function getTrellisTracer(): import("@opentelemetry/api").Tracer;
+export declare function startClientSpan(method: string, subject: string): Span;
+export declare function startServerSpan(method: string, subject: string, parentContext?: Context): Span;
+//# sourceMappingURL=trace.d.ts.map

package/script/js/packages/trellis/telemetry/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAMxD,wBAAgB,gBAAgB,wCAE/B;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CASrE;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,OAAO,GACtB,IAAI,CAaN"}

package/script/js/packages/trellis/telemetry/trace.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrellisTracer = getTrellisTracer;
+exports.startClientSpan = startClientSpan;
+exports.startServerSpan = startServerSpan;
+const api_1 = require("@opentelemetry/api");
+const core_ts_1 = require("./core.js");
+const TRELLIS_INSTRUMENTATION_SCOPE = "@qlever-llc/trellis";
+function getTrellisTracer() {
+    return (0, core_ts_1.getTracer)(TRELLIS_INSTRUMENTATION_SCOPE);
+}
+function startClientSpan(method, subject) {
+    return getTrellisTracer().startSpan(`rpc.client.${method}`, {
+        kind: api_1.SpanKind.CLIENT,
+        attributes: {
+            "rpc.system": "nats",
+            "rpc.method": method,
+            "messaging.destination": subject,
+        },
+    });
+}
+function startServerSpan(method, subject, parentContext) {
+    return getTrellisTracer().startSpan(`rpc.server.${method}`, {
+        kind: api_1.SpanKind.SERVER,
+        attributes: {
+            "rpc.system": "nats",
+            "rpc.method": method,
+            "messaging.destination": subject,
+        },
+    }, parentContext);
+}

package/script/js/packages/trellis/telemetry/trellis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trellis.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/trellis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/script/js/packages/trellis/telemetry/trellis.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServerSpan = exports.startClientSpan = exports.getTrellisTracer = void 0;
+var trace_ts_1 = require("./trace.js");
+Object.defineProperty(exports, "getTrellisTracer", { enumerable: true, get: function () { return trace_ts_1.getTrellisTracer; } });
+Object.defineProperty(exports, "startClientSpan", { enumerable: true, get: function () { return trace_ts_1.startClientSpan; } });
+Object.defineProperty(exports, "startServerSpan", { enumerable: true, get: function () { return trace_ts_1.startServerSpan; } });

package/script/js/packages/trellis/tracing.d.ts

@@ -0,0 +1,4 @@
+export type { HeaderCarrier, NatsHeadersLike } from "./telemetry/mod.ts";
+export { configureErrorTraceId, context, createMapCarrier, createNatsHeaderCarrier, extractTraceContext, getActiveSpan, getTrellisTracer as getTracer, injectTraceContext, SpanKind, SpanStatusCode, startClientSpan, startServerSpan, trace, withSpan, withSpanAsync } from "./telemetry/mod.ts";
+export declare function initTracing(serviceName: string): void;
+//# sourceMappingURL=tracing.d.ts.map

package/script/js/packages/trellis/tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../../../tracing.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAC,qBAAqB,EAC3B,OAAO,EACP,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,aAAa,EAAC,gBAAgB,IAAI,SAAS,EAC3C,kBAAkB,EAClB,QAAQ,EACR,cAAc,EAAC,eAAe,EAAE,eAAe,EAC/C,KAAK,EACL,QAAQ,EACR,aAAa,EACd,MAAM,oBAAoB,CAAC;AAC5B,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAErD"}

package/script/js/packages/trellis/tracing.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSpanAsync = exports.withSpan = exports.trace = exports.startServerSpan = exports.startClientSpan = exports.SpanStatusCode = exports.SpanKind = exports.injectTraceContext = exports.getTracer = exports.getActiveSpan = exports.extractTraceContext = exports.createNatsHeaderCarrier = exports.createMapCarrier = exports.context = exports.configureErrorTraceId = void 0;
+exports.initTracing = initTracing;
+var mod_ts_1 = require("./telemetry/mod.js");
+Object.defineProperty(exports, "configureErrorTraceId", { enumerable: true, get: function () { return mod_ts_1.configureErrorTraceId; } });
+Object.defineProperty(exports, "context", { enumerable: true, get: function () { return mod_ts_1.context; } });
+Object.defineProperty(exports, "createMapCarrier", { enumerable: true, get: function () { return mod_ts_1.createMapCarrier; } });
+Object.defineProperty(exports, "createNatsHeaderCarrier", { enumerable: true, get: function () { return mod_ts_1.createNatsHeaderCarrier; } });
+Object.defineProperty(exports, "extractTraceContext", { enumerable: true, get: function () { return mod_ts_1.extractTraceContext; } });
+Object.defineProperty(exports, "getActiveSpan", { enumerable: true, get: function () { return mod_ts_1.getActiveSpan; } });
+Object.defineProperty(exports, "getTracer", { enumerable: true, get: function () { return mod_ts_1.getTrellisTracer; } });
+Object.defineProperty(exports, "injectTraceContext", { enumerable: true, get: function () { return mod_ts_1.injectTraceContext; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return mod_ts_1.SpanKind; } });
+Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return mod_ts_1.SpanStatusCode; } });
+Object.defineProperty(exports, "startClientSpan", { enumerable: true, get: function () { return mod_ts_1.startClientSpan; } });
+Object.defineProperty(exports, "startServerSpan", { enumerable: true, get: function () { return mod_ts_1.startServerSpan; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return mod_ts_1.trace; } });
+Object.defineProperty(exports, "withSpan", { enumerable: true, get: function () { return mod_ts_1.withSpan; } });
+Object.defineProperty(exports, "withSpanAsync", { enumerable: true, get: function () { return mod_ts_1.withSpanAsync; } });
+function initTracing(serviceName) {
+    void Promise.resolve().then(() => __importStar(require("./telemetry/init.js"))).then((mod) => mod.initTracing(serviceName));
+}

package/script/js/packages/trellis/transfer.d.ts

@@ -0,0 +1,114 @@
+import { type Result as ResultType } from "@qlever-llc/result";
+import { type MsgHdrs, type NatsConnection } from "@nats-io/nats-core";
+import Type, { type Static } from "typebox";
+import { TransferError } from "./errors/TransferError.ts";
+export declare const FileInfoSchema: Type.TObject<{
+    key: Type.TString;
+    size: Type.TInteger;
+    updatedAt: Type.TString;
+    digest: Type.TOptional<Type.TString>;
+    contentType: Type.TOptional<Type.TString>;
+    metadata: Type.TRecord<"^.*$", Type.TString>;
+}>;
+export type FileInfo = Static<typeof FileInfoSchema>;
+export declare const UploadTransferGrantSchema: Type.TObject<{
+    kind: Type.TLiteral<"upload">;
+    maxBytes: Type.TOptional<Type.TInteger>;
+    contentType: Type.TOptional<Type.TString>;
+    metadata: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    type: Type.TLiteral<"TransferGrant">;
+    service: Type.TString;
+    sessionKey: Type.TString;
+    transferId: Type.TString;
+    subject: Type.TString;
+    expiresAt: Type.TString;
+    chunkBytes: Type.TInteger;
+}>;
+export declare const DownloadTransferGrantSchema: Type.TObject<{
+    kind: Type.TLiteral<"download">;
+    info: Type.TObject<{
+        key: Type.TString;
+        size: Type.TInteger;
+        updatedAt: Type.TString;
+        digest: Type.TOptional<Type.TString>;
+        contentType: Type.TOptional<Type.TString>;
+        metadata: Type.TRecord<"^.*$", Type.TString>;
+    }>;
+    type: Type.TLiteral<"TransferGrant">;
+    service: Type.TString;
+    sessionKey: Type.TString;
+    transferId: Type.TString;
+    subject: Type.TString;
+    expiresAt: Type.TString;
+    chunkBytes: Type.TInteger;
+}>;
+export declare const TransferGrantSchema: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"upload">;
+    maxBytes: Type.TOptional<Type.TInteger>;
+    contentType: Type.TOptional<Type.TString>;
+    metadata: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    type: Type.TLiteral<"TransferGrant">;
+    service: Type.TString;
+    sessionKey: Type.TString;
+    transferId: Type.TString;
+    subject: Type.TString;
+    expiresAt: Type.TString;
+    chunkBytes: Type.TInteger;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"download">;
+    info: Type.TObject<{
+        key: Type.TString;
+        size: Type.TInteger;
+        updatedAt: Type.TString;
+        digest: Type.TOptional<Type.TString>;
+        contentType: Type.TOptional<Type.TString>;
+        metadata: Type.TRecord<"^.*$", Type.TString>;
+    }>;
+    type: Type.TLiteral<"TransferGrant">;
+    service: Type.TString;
+    sessionKey: Type.TString;
+    transferId: Type.TString;
+    subject: Type.TString;
+    expiresAt: Type.TString;
+    chunkBytes: Type.TInteger;
+}>]>;
+export type UploadTransferGrant = Static<typeof UploadTransferGrantSchema>;
+export type DownloadTransferGrant = Static<typeof DownloadTransferGrantSchema>;
+export type TransferGrant = Static<typeof TransferGrantSchema>;
+export type TransferBody = Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+type TrellisTransferAuth = {
+    sessionKey: string;
+    sign(data: Uint8Array): Promise<Uint8Array> | Uint8Array;
+};
+declare class BaseTransferHandle {
+    #private;
+    protected constructor(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number);
+    protected get nc(): NatsConnection;
+    protected get auth(): TrellisTransferAuth;
+    protected get timeoutMs(): number;
+    protected validateGrant(grant: TransferGrant, operation: string): ResultType<void, TransferError>;
+    protected buildHeaders(subject: string, payload: Uint8Array, seq?: number, eof?: boolean): Promise<MsgHdrs>;
+}
+export declare class UploadTransferHandle extends BaseTransferHandle {
+    #private;
+    constructor(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number, grant: UploadTransferGrant);
+    put(body: TransferBody): Promise<ResultType<FileInfo, TransferError>>;
+}
+export declare class DownloadTransferHandle extends BaseTransferHandle {
+    #private;
+    constructor(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number, grant: DownloadTransferGrant);
+    getBytes(): Promise<ResultType<Uint8Array, TransferError>>;
+}
+export type TransferHandle = UploadTransferHandle | DownloadTransferHandle;
+export declare function createTransferHandle(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number, grant: UploadTransferGrant): UploadTransferHandle;
+export declare function createTransferHandle(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number, grant: DownloadTransferGrant): DownloadTransferHandle;
+export declare function createTransferHandle(nc: NatsConnection, auth: TrellisTransferAuth, timeoutMs: number, grant: TransferGrant): TransferHandle;
+export declare function verifyTransferMessage(args: {
+    expectedSessionKey: string;
+    subject: string;
+    payload: Uint8Array;
+    proof?: string | null;
+    sessionKey?: string | null;
+}): Promise<boolean>;
+export {};
+//# sourceMappingURL=transfer.d.ts.map

package/script/js/packages/trellis/transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../../../transfer.ts"],"names":[],"mappings":"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"}

package/script/js/packages/trellis/transfer.js

@@ -0,0 +1,363 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BaseTransferHandle_nc, _BaseTransferHandle_auth, _BaseTransferHandle_timeoutMs, _UploadTransferHandle_grant, _DownloadTransferHandle_grant;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadTransferHandle = exports.UploadTransferHandle = exports.TransferGrantSchema = exports.DownloadTransferGrantSchema = exports.UploadTransferGrantSchema = exports.FileInfoSchema = void 0;
+exports.createTransferHandle = createTransferHandle;
+exports.verifyTransferMessage = verifyTransferMessage;
+const result_1 = require("@qlever-llc/result");
+const nats_core_1 = require("@nats-io/nats-core");
+const typebox_1 = __importDefault(require("typebox"));
+const proof_ts_1 = require("./auth/proof.js");
+const utils_ts_1 = require("./auth/utils.js");
+const TransferError_ts_1 = require("./errors/TransferError.js");
+const TRANSFER_SEQUENCE_HEADER = "trellis-transfer-seq";
+const TRANSFER_EOF_HEADER = "trellis-transfer-eof";
+exports.FileInfoSchema = typebox_1.default.Object({
+    key: typebox_1.default.String({ minLength: 1 }),
+    size: typebox_1.default.Integer({ minimum: 0 }),
+    updatedAt: typebox_1.default.String({ minLength: 1 }),
+    digest: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+    contentType: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+    metadata: typebox_1.default.Record(typebox_1.default.String({ minLength: 1 }), typebox_1.default.String()),
+}, { additionalProperties: false });
+const TransferGrantBaseSchema = typebox_1.default.Object({
+    type: typebox_1.default.Literal("TransferGrant"),
+    service: typebox_1.default.String({ minLength: 1 }),
+    sessionKey: typebox_1.default.String({ minLength: 1 }),
+    transferId: typebox_1.default.String({ minLength: 1 }),
+    subject: typebox_1.default.String({ minLength: 1 }),
+    expiresAt: typebox_1.default.String({ minLength: 1 }),
+    chunkBytes: typebox_1.default.Integer({ minimum: 1 }),
+}, { additionalProperties: false });
+exports.UploadTransferGrantSchema = typebox_1.default.Object({
+    ...TransferGrantBaseSchema.properties,
+    kind: typebox_1.default.Literal("upload"),
+    maxBytes: typebox_1.default.Optional(typebox_1.default.Integer({ minimum: 1 })),
+    contentType: typebox_1.default.Optional(typebox_1.default.String({ minLength: 1 })),
+    metadata: typebox_1.default.Optional(typebox_1.default.Record(typebox_1.default.String({ minLength: 1 }), typebox_1.default.String())),
+}, { additionalProperties: false });
+exports.DownloadTransferGrantSchema = typebox_1.default.Object({
+    ...TransferGrantBaseSchema.properties,
+    kind: typebox_1.default.Literal("download"),
+    info: exports.FileInfoSchema,
+}, { additionalProperties: false });
+exports.TransferGrantSchema = typebox_1.default.Union([
+    exports.UploadTransferGrantSchema,
+    exports.DownloadTransferGrantSchema,
+]);
+async function createTransferProof(auth, subject, payload) {
+    const payloadHash = await (0, utils_ts_1.sha256)(payload);
+    const proofOk = await auth.sign(await (0, utils_ts_1.sha256)(buildTransferProofInput(auth.sessionKey, subject, payloadHash)));
+    return (0, utils_ts_1.base64urlEncode)(proofOk);
+}
+function buildTransferProofInput(sessionKey, subject, payloadHash) {
+    const enc = new TextEncoder();
+    const sessionKeyBytes = enc.encode(sessionKey);
+    const subjectBytes = enc.encode(subject);
+    const buf = new Uint8Array(4 + sessionKeyBytes.length + 4 + subjectBytes.length + 4 + payloadHash.length);
+    const view = new DataView(buf.buffer);
+    let offset = 0;
+    view.setUint32(offset, sessionKeyBytes.length);
+    offset += 4;
+    buf.set(sessionKeyBytes, offset);
+    offset += sessionKeyBytes.length;
+    view.setUint32(offset, subjectBytes.length);
+    offset += 4;
+    buf.set(subjectBytes, offset);
+    offset += subjectBytes.length;
+    view.setUint32(offset, payloadHash.length);
+    offset += 4;
+    buf.set(payloadHash, offset);
+    return buf;
+}
+function expired(expiresAt) {
+    return Date.now() >= Date.parse(expiresAt);
+}
+function asUint8Array(body) {
+    return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function streamFromAsyncIterable(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await iterator.return?.(reason);
+        },
+    });
+}
+function streamFromBody(body) {
+    if (body instanceof Uint8Array || body instanceof ArrayBuffer) {
+        const bytes = asUint8Array(body);
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(bytes);
+                controller.close();
+            },
+        });
+    }
+    return body instanceof ReadableStream ? body : streamFromAsyncIterable(body);
+}
+async function* chunkBody(body, chunkBytes) {
+    const reader = streamFromBody(body).getReader();
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                return;
+            }
+            let offset = 0;
+            while (offset < next.value.length) {
+                const end = Math.min(offset + chunkBytes, next.value.length);
+                yield next.value.slice(offset, end);
+                offset = end;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseTransferAck(msg, operation) {
+    if (msg.headers?.get("status") === "error") {
+        return result_1.Result.err(deserializeTransferError(msg, operation));
+    }
+    try {
+        const value = JSON.parse(msg.string());
+        return result_1.Result.ok(value);
+    }
+    catch (cause) {
+        return result_1.Result.err(new TransferError_ts_1.TransferError({ operation, cause }));
+    }
+}
+function deserializeTransferError(msg, operation) {
+    try {
+        const value = JSON.parse(msg.string());
+        return new TransferError_ts_1.TransferError({
+            operation: value.operation ?? operation,
+            context: value.context,
+            cause: value.message ? new Error(value.message) : undefined,
+        });
+    }
+    catch (cause) {
+        return new TransferError_ts_1.TransferError({ operation, cause });
+    }
+}
+async function collectDownload(nc, inbox, timeoutMs) {
+    const sub = nc.subscribe(inbox);
+    const iterator = sub[Symbol.asyncIterator]();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const next = await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    clearTimeout(timer);
+                    reject(new TransferError_ts_1.TransferError({ operation: "get", context: { reason: "timeout" } }));
+                }, timeoutMs);
+                iterator.next().then((value) => {
+                    clearTimeout(timer);
+                    resolve(value);
+                }, (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+            });
+            if (next.done) {
+                return result_1.Result.err(new TransferError_ts_1.TransferError({ operation: "get", context: { reason: "stream_closed" } }));
+            }
+            const msg = next.value;
+            if (msg.headers?.get("status") === "error") {
+                return result_1.Result.err(deserializeTransferError(msg, "get"));
+            }
+            if (msg.data.length > 0) {
+                chunks.push(msg.data);
+                total += msg.data.length;
+            }
+            if (msg.headers?.get(TRANSFER_EOF_HEADER) === "true") {
+                const merged = new Uint8Array(total);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    merged.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                return result_1.Result.ok(merged);
+            }
+        }
+    }
+    catch (cause) {
+        return result_1.Result.err(cause instanceof TransferError_ts_1.TransferError ? cause : new TransferError_ts_1.TransferError({ operation: "get", cause }));
+    }
+    finally {
+        sub.unsubscribe();
+    }
+}
+class BaseTransferHandle {
+    constructor(nc, auth, timeoutMs) {
+        _BaseTransferHandle_nc.set(this, void 0);
+        _BaseTransferHandle_auth.set(this, void 0);
+        _BaseTransferHandle_timeoutMs.set(this, void 0);
+        __classPrivateFieldSet(this, _BaseTransferHandle_nc, nc, "f");
+        __classPrivateFieldSet(this, _BaseTransferHandle_auth, auth, "f");
+        __classPrivateFieldSet(this, _BaseTransferHandle_timeoutMs, timeoutMs, "f");
+    }
+    get nc() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_nc, "f");
+    }
+    get auth() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f");
+    }
+    get timeoutMs() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_timeoutMs, "f");
+    }
+    validateGrant(grant, operation) {
+        if (expired(grant.expiresAt)) {
+            return result_1.Result.err(new TransferError_ts_1.TransferError({ operation, context: { reason: "expired", transferId: grant.transferId } }));
+        }
+        if (grant.sessionKey !== __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey) {
+            return result_1.Result.err(new TransferError_ts_1.TransferError({
+                operation,
+                context: {
+                    reason: "session_mismatch",
+                    expectedSessionKey: grant.sessionKey,
+                    actualSessionKey: __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey,
+                },
+            }));
+        }
+        return result_1.Result.ok(undefined);
+    }
+    async buildHeaders(subject, payload, seq, eof) {
+        const headers = (0, nats_core_1.headers)();
+        headers.set("session-key", __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey);
+        headers.set("proof", await createTransferProof(__classPrivateFieldGet(this, _BaseTransferHandle_auth, "f"), subject, payload));
+        if (seq !== undefined) {
+            headers.set(TRANSFER_SEQUENCE_HEADER, String(seq));
+        }
+        if (eof) {
+            headers.set(TRANSFER_EOF_HEADER, "true");
+        }
+        return headers;
+    }
+}
+_BaseTransferHandle_nc = new WeakMap(), _BaseTransferHandle_auth = new WeakMap(), _BaseTransferHandle_timeoutMs = new WeakMap();
+class UploadTransferHandle extends BaseTransferHandle {
+    constructor(nc, auth, timeoutMs, grant) {
+        super(nc, auth, timeoutMs);
+        _UploadTransferHandle_grant.set(this, void 0);
+        __classPrivateFieldSet(this, _UploadTransferHandle_grant, grant, "f");
+    }
+    async put(body) {
+        const valid = this.validateGrant(__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f"), "put").take();
+        if ((0, result_1.isErr)(valid)) {
+            return result_1.Result.err(valid.error);
+        }
+        let sentBytes = 0;
+        let seq = 0;
+        let completed = null;
+        for await (const chunk of chunkBody(body, __classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").chunkBytes)) {
+            sentBytes += chunk.length;
+            if (__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").maxBytes !== undefined && sentBytes > __classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").maxBytes) {
+                return result_1.Result.err(new TransferError_ts_1.TransferError({
+                    operation: "put",
+                    context: {
+                        reason: "max_bytes_exceeded",
+                        maxBytes: __classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").maxBytes,
+                        attemptedBytes: sentBytes,
+                    },
+                }));
+            }
+            const headers = await this.buildHeaders(__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").subject, chunk, seq, false);
+            const response = await result_1.AsyncResult.try(() => this.nc.request(__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").subject, chunk, { timeout: this.timeoutMs, headers })).take();
+            if ((0, result_1.isErr)(response)) {
+                return result_1.Result.err(new TransferError_ts_1.TransferError({ operation: "put", cause: response.error }));
+            }
+            const ack = parseTransferAck(response, "put").take();
+            if ((0, result_1.isErr)(ack)) {
+                return result_1.Result.err(ack.error);
+            }
+            if (ack.status === "complete") {
+                completed = ack.info;
+            }
+            seq += 1;
+        }
+        const finalHeaders = await this.buildHeaders(__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").subject, new Uint8Array(), seq, true);
+        const finalResponse = await result_1.AsyncResult.try(() => this.nc.request(__classPrivateFieldGet(this, _UploadTransferHandle_grant, "f").subject, new Uint8Array(), {
+            timeout: this.timeoutMs,
+            headers: finalHeaders,
+        })).take();
+        if ((0, result_1.isErr)(finalResponse)) {
+            return result_1.Result.err(new TransferError_ts_1.TransferError({ operation: "put", cause: finalResponse.error }));
+        }
+        const finalAck = parseTransferAck(finalResponse, "put").take();
+        if ((0, result_1.isErr)(finalAck)) {
+            return result_1.Result.err(finalAck.error);
+        }
+        if (finalAck.status !== "complete") {
+            return result_1.Result.err(new TransferError_ts_1.TransferError({ operation: "put", context: { reason: "missing_completion" } }));
+        }
+        return result_1.Result.ok(finalAck.info ?? completed);
+    }
+}
+exports.UploadTransferHandle = UploadTransferHandle;
+_UploadTransferHandle_grant = new WeakMap();
+class DownloadTransferHandle extends BaseTransferHandle {
+    constructor(nc, auth, timeoutMs, grant) {
+        super(nc, auth, timeoutMs);
+        _DownloadTransferHandle_grant.set(this, void 0);
+        __classPrivateFieldSet(this, _DownloadTransferHandle_grant, grant, "f");
+    }
+    async getBytes() {
+        const valid = this.validateGrant(__classPrivateFieldGet(this, _DownloadTransferHandle_grant, "f"), "get").take();
+        if ((0, result_1.isErr)(valid)) {
+            return result_1.Result.err(valid.error);
+        }
+        const inbox = (0, nats_core_1.createInbox)(`_INBOX.${this.auth.sessionKey.slice(0, 16)}`);
+        const payload = new Uint8Array();
+        const headers = await this.buildHeaders(__classPrivateFieldGet(this, _DownloadTransferHandle_grant, "f").subject, payload);
+        try {
+            this.nc.publish(__classPrivateFieldGet(this, _DownloadTransferHandle_grant, "f").subject, payload, { headers, reply: inbox });
+            await this.nc.flush();
+        }
+        catch (cause) {
+            return result_1.Result.err(new TransferError_ts_1.TransferError({ operation: "get", cause }));
+        }
+        return await collectDownload(this.nc, inbox, this.timeoutMs);
+    }
+}
+exports.DownloadTransferHandle = DownloadTransferHandle;
+_DownloadTransferHandle_grant = new WeakMap();
+function createTransferHandle(nc, auth, timeoutMs, grant) {
+    return grant.kind === "upload"
+        ? new UploadTransferHandle(nc, auth, timeoutMs, grant)
+        : new DownloadTransferHandle(nc, auth, timeoutMs, grant);
+}
+async function verifyTransferMessage(args) {
+    if (!args.proof || !args.sessionKey || args.sessionKey !== args.expectedSessionKey) {
+        return false;
+    }
+    return await (0, proof_ts_1.verifyProof)(args.expectedSessionKey, {
+        sessionKey: args.sessionKey,
+        subject: args.subject,
+        payloadHash: await (0, utils_ts_1.sha256)(args.payload),
+    }, args.proof);
+}