windmill-cli 1.479.2 → 1.480.0

package/esm/hub.js

@@ -25,27 +25,14 @@ export async function pull(opts) {
     if (uid) {
         headers["X-uid"] = uid;
     }
-    let preList = await fetch(hubBaseUrl + "/resource_types/list", {
+    let list = await fetch(hubBaseUrl + "/resource_types/list", {
         headers,
     }).then((r) => r.json());
-    if (preList && preList.length === 0 && hubBaseUrl !== DEFAULT_HUB_BASE_URL) {
-        preList = await fetch(DEFAULT_HUB_BASE_URL + "/resource_types/list", {
+    if (list && list.length === 0 && hubBaseUrl !== DEFAULT_HUB_BASE_URL) {
+        list = await fetch(DEFAULT_HUB_BASE_URL + "/resource_types/list", {
             headers,
         }).then((r) => r.json());
     }
-    let list = await Promise.all(preList.map((x) => fetch(hubBaseUrl + "/resource_types/" + x.id + "/" + x.name, {
-        headers: {
-            Accept: "application/json",
-        },
-    })))
-        .then((x) => x.map((x) => x.json().catch((e) => {
-        log.info(e);
-        return undefined;
-    })))
-        .then((x) => Promise.all(x))
-        .then((x) => x
-        .filter((x) => x)
-        .map((x) => x.resource_type));
     const resourceTypes = await wmill.listResourceType({
         workspace: workspace.workspaceId,
     });

package/esm/main.js

@@ -34,7 +34,7 @@ export { flow, app, script, workspace, resource, user, variable, hub, folder, sc
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.479.2";
+export const VERSION = "1.480.0";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.479.2",
+  "version": "1.480.0",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/deps/jsr.io/@std/encoding/1.0.4/_base32_common.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Decodes an encoded string with the given lookup table.
+ *
+ * @param b32 The string to encode.
+ * @param lookup The lookup table
+ * @returns The encoded string.
+ */
+export declare function decode(b32: string, lookup: ReadonlyArray<string>): Uint8Array;
+/**
+ * Encodes the given data using the lookup table.
+ *
+ * @param data The data to encode.
+ * @param lookup The lookup table.
+ * @returns The encoded string.
+ */
+export declare function encode(data: ArrayBuffer | Uint8Array | string, lookup: ReadonlyArray<string>): string;
+//# sourceMappingURL=_base32_common.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/_base32_common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_base32_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/_base32_common.ts"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,UAAU,CAqE7E;AA6BD;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,EACvC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAC5B,MAAM,CA6DR"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/_validate_binary_like.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_validate_binary_like.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.8/_validate_binary_like.ts"],"names":[],"mappings":"AAeA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAa9D"}
+{"version":3,"file":"_validate_binary_like.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/_validate_binary_like.ts"],"names":[],"mappings":"AAeA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAa9D"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/ascii85.d.ts

@@ -1,5 +1,3 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * Supported ascii85 standards for {@linkcode EncodeAscii85Options} and
  * {@linkcode DecodeAscii85Options}.
@@ -57,5 +55,5 @@ export type DecodeAscii85Options = Omit<EncodeAscii85Options, "delimiter">;
  * );
  * ```
  */
-export declare function decodeAscii85(ascii85: string, options?: DecodeAscii85Options): Uint8Array_;
+export declare function decodeAscii85(ascii85: string, options?: DecodeAscii85Options): Uint8Array;
 //# sourceMappingURL=ascii85.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/ascii85.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ascii85.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/ascii85.ts"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;AAEpE,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAOD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,EACvC,OAAO,GAAE,oBAAyB,GACjC,MAAM,CA6DR;AAED,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,UAAU,CA4CZ"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base32.d.ts

@@ -1,40 +1,38 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
- * Converts data into a base32-encoded string.
+ * Decodes a base32-encoded string.
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
  *
- * @param data The data to encode.
- * @returns The base32-encoded string.
+ * @param b32 The base32-encoded string to decode.
+ * @returns The decoded data.
  *
  * @example Usage
  * ```ts
- * import { encodeBase32 } from "@std/encoding/base32";
+ * import { decodeBase32 } from "@std/encoding/base32";
  * import { assertEquals } from "@std/assert";
  *
- * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
+ * assertEquals(
+ *   decodeBase32("GZRTMMDDGA======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
  * ```
  */
-export declare function encodeBase32(data: ArrayBuffer | Uint8Array | string): string;
+export declare function decodeBase32(b32: string): Uint8Array;
 /**
- * Decodes a base32-encoded string.
+ * Converts data into a base32-encoded string.
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
  *
- * @param b32 The base32-encoded string to decode.
- * @returns The decoded data.
+ * @param data The data to encode.
+ * @returns The base32-encoded string.
  *
  * @example Usage
  * ```ts
- * import { decodeBase32 } from "@std/encoding/base32";
+ * import { encodeBase32 } from "@std/encoding/base32";
  * import { assertEquals } from "@std/assert";
  *
- * assertEquals(
- *   decodeBase32("GZRTMMDDGA======"),
- *   new TextEncoder().encode("6c60c0"),
- * );
+ * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
  * ```
  */
-export declare function decodeBase32(b32: string): Uint8Array_;
+export declare function encodeBase32(data: ArrayBuffer | Uint8Array | string): string;
 //# sourceMappingURL=base32.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base32.ts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAEpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAE5E"}

package/types/deps/jsr.io/@std/encoding/1.0.4/base32_stream.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Converts a Uint8Array stream into a base32-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase32 } from "@std/encoding/base32";
+ * import { Base32EncoderStream } from "@std/encoding/base32-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base32EncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase32(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export declare class Base32EncoderStream extends TransformStream<Uint8Array, string> {
+    constructor();
+}
+/**
+ * Decodes a base32-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { Base32DecoderStream } from "@std/encoding/base32-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["JBSWY3DPEBLW64TMMQQQ===="])
+ *   .pipeThrough(new Base32DecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello World!");
+ * ```
+ */
+export declare class Base32DecoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+}
+//# sourceMappingURL=base32_stream.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base32_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base32_stream.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;;CAsB3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC;;CAoB3E"}

package/types/deps/jsr.io/@std/encoding/1.0.4/base32hex.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Decodes a base32hex-encoded string.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-7}
+ *
+ * @param b32 The base32hex-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase32Hex } from "@std/encoding/base32hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase32Hex("6PHJCC3360======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
+ * ```
+ */
+export declare function decodeBase32Hex(b32: string): Uint8Array;
+/**
+ * Converts data into a base32hex-encoded string.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-7}
+ *
+ * @param data The data to encode.
+ * @returns The base32hex-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase32Hex } from "@std/encoding/base32hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32Hex("6c60c0"), "6PHJCC3360======");
+ * ```
+ */
+export declare function encodeBase32Hex(data: ArrayBuffer | Uint8Array | string): string;
+//# sourceMappingURL=base32hex.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base32hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base32hex.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAEvD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GACtC,MAAM,CAER"}

package/types/deps/jsr.io/@std/encoding/1.0.4/base32hex_stream.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Converts a Uint8Array stream into a base32hex-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase32Hex } from "@std/encoding/base32hex";
+ * import { Base32HexEncoderStream } from "@std/encoding/base32hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base32HexEncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase32Hex(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export declare class Base32HexEncoderStream extends TransformStream<Uint8Array, string> {
+    constructor();
+}
+/**
+ * Decodes a base32hex-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { Base32HexDecoderStream } from "@std/encoding/base32hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["91IMOR3F5GG7ERRI", "DHI22==="])
+ *   .pipeThrough(new Base32HexDecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello, world!");
+ * ```
+ */
+export declare class Base32HexDecoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+}
+//# sourceMappingURL=base32hex_stream.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base32hex_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32hex_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base32hex_stream.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,sBACX,SAAQ,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;;CAsB5C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,sBACX,SAAQ,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC;;CAsB5C"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base58.d.ts

@@ -1,5 +1,3 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * Converts data into a base58-encoded string.
  *
@@ -36,5 +34,5 @@ export declare function encodeBase58(data: ArrayBuffer | Uint8Array | string): s
  * );
  * ```
  */
-export declare function decodeBase58(b58: string): Uint8Array_;
+export declare function decodeBase58(b58: string): Uint8Array;
 //# sourceMappingURL=base58.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base58.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base58.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAgD5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAkDpD"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base64.d.ts

@@ -1,5 +1,3 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * Converts data into a base64-encoded string.
  *
@@ -36,5 +34,5 @@ export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): s
  * );
  * ```
  */
-export declare function decodeBase64(b64: string): Uint8Array_;
+export declare function decodeBase64(b64: string): Uint8Array;
 //# sourceMappingURL=base64.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base64.ts"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAmC5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQpD"}

package/types/deps/jsr.io/@std/encoding/1.0.4/base64_stream.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Converts a Uint8Array stream into a base64-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { Base64EncoderStream } from "@std/encoding/base64-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base64EncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase64(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export declare class Base64EncoderStream extends TransformStream<Uint8Array, string> {
+    constructor();
+}
+/**
+ * Decodes a base64-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { Base64DecoderStream } from "@std/encoding/base64-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["SGVsbG8s", "IHdvcmxkIQ=="])
+ *   .pipeThrough(new Base64DecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello, world!");
+ * ```
+ */
+export declare class Base64DecoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+}
+//# sourceMappingURL=base64_stream.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base64_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base64_stream.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;;CAsB3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC;;CAoB3E"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base64url.d.ts

@@ -1,5 +1,3 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * Convert data into a base64url-encoded string.
  *
@@ -36,5 +34,5 @@ export declare function encodeBase64Url(data: ArrayBuffer | Uint8Array | string)
  * );
  * ```
  */
-export declare function decodeBase64Url(b64url: string): Uint8Array_;
+export declare function decodeBase64Url(b64url: string): Uint8Array;
 //# sourceMappingURL=base64url.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base64url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base64url.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GACtC,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAE1D"}

package/types/deps/jsr.io/@std/encoding/1.0.4/base64url_stream.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Converts a Uint8Array stream into a base64url-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase64Url } from "@std/encoding/base64url";
+ * import { Base64UrlEncoderStream } from "@std/encoding/base64url-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base64UrlEncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase64Url(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export declare class Base64UrlEncoderStream extends TransformStream<Uint8Array, string> {
+    constructor();
+}
+/**
+ * Decodes a base64url-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase64Url } from "@std/encoding/base64url";
+ * import { Base64UrlDecoderStream } from "@std/encoding/base64url-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["SGVsbG8s", "IHdvcmxkIQ"])
+ *   .pipeThrough(new Base64UrlDecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello, world!");
+ * ```
+ */
+export declare class Base64UrlDecoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+}
+//# sourceMappingURL=base64url_stream.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/base64url_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64url_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/base64url_stream.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,sBACX,SAAQ,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;;CAsB5C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,sBACX,SAAQ,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC;;CAsB5C"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/hex.d.ts

@@ -1,5 +1,3 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * Converts data into a hex-encoded string.
  *
@@ -35,5 +33,5 @@ export declare function encodeHex(src: string | Uint8Array | ArrayBuffer): strin
  * );
  * ```
  */
-export declare function decodeHex(src: string): Uint8Array_;
+export declare function decodeHex(src: string): Uint8Array;
 //# sourceMappingURL=hex.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/hex.ts"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAUxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAiBjD"}

package/types/deps/jsr.io/@std/encoding/1.0.4/hex_stream.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Converts a Uint8Array stream into a hex-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-8}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeHex } from "@std/encoding/hex";
+ * import { HexEncoderStream } from "@std/encoding/hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new HexEncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeHex(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export declare class HexEncoderStream extends TransformStream<Uint8Array, string> {
+    constructor();
+}
+/**
+ * Decodes a hex-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-8}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { HexDecoderStream } from "@std/encoding/hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["48656c6c6f2c", "20776f726c6421"])
+ *   .pipeThrough(new HexDecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello, world!");
+ * ```
+ */
+export declare class HexDecoderStream extends TransformStream<string, Uint8Array> {
+    constructor();
+}
+//# sourceMappingURL=hex_stream.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/hex_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/hex_stream.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAiB,SAAQ,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;;CAQxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAiB,SAAQ,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC;;CAoBxE"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/mod.d.ts

@@ -14,9 +14,15 @@
  */
 export * from "./ascii85.js";
 export * from "./base32.js";
+export * from "./base32_stream.js";
+export * from "./base32hex.js";
+export * from "./base32hex_stream.js";
 export * from "./base58.js";
 export * from "./base64.js";
+export * from "./base64_stream.js";
 export * from "./base64url.js";
+export * from "./base64url_stream.js";
 export * from "./hex.js";
+export * from "./hex_stream.js";
 export * from "./varint.js";
 //# sourceMappingURL=mod.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/types/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/varint.d.ts

@@ -21,8 +21,6 @@
  *
  * @module
  */
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
 /**
  * The maximum value of an unsigned 64-bit integer.
  * Equivalent to `2n**64n - 1n`
@@ -116,5 +114,5 @@ export declare function decodeVarint32(buf: Uint8Array, offset?: number): [numbe
  * assertEquals(encodeVarint(42n, buf), [new Uint8Array([42]), 1]);
  * ```
  */
-export declare function encodeVarint(num: bigint | number, buf?: Uint8Array, offset?: number): [Uint8Array_, number];
+export declare function encodeVarint(num: bigint | number, buf?: Uint8Array, offset?: number): [Uint8Array, number];
 //# sourceMappingURL=varint.d.ts.map

package/types/deps/jsr.io/@std/encoding/1.0.4/varint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varint.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.4/varint.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH;;;GAGG;AACH,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC;;GAEG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAahC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA6D1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAe5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,GAAG,GAAE,UAA2C,EAChD,MAAM,SAAI,GACT,CAAC,UAAU,EAAE,MAAM,CAAC,CAuBtB"}

package/types/deps.d.ts

@@ -12,7 +12,7 @@ export { CompletionsCommand } from "./deps/jsr.io/@windmill-labs/cliffy-command/
 export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.15/mod.js";
 export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.0.8/mod.js";
 export * as path from "./deps/jsr.io/@std/path/1.0.8/mod.js";
-export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.8/mod.js";
+export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.4/mod.js";
 export { writeAllSync } from "./deps/jsr.io/@std/io/0.225.2/write_all.js";
 export { copy } from "./deps/jsr.io/@std/io/0.225.2/copy.js";
 export { readAll } from "./deps/jsr.io/@std/io/0.225.2/read_all.js";

package/types/hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hub.d.ts","sourceRoot":"","sources":["../src/hub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAO,MAAM,WAAW,CAAC;AAKzC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAK3C,wBAAsB,IAAI,CAAC,IAAI,EAAE,aAAa,iBA0G7C;AAED,QAAA,MAAM,OAAO;;;;;;oBAKS,CAAC;AAEvB,eAAe,OAAO,CAAC"}
+{"version":3,"file":"hub.d.ts","sourceRoot":"","sources":["../src/hub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAO,MAAM,WAAW,CAAC;AAKzC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAa3C,wBAAsB,IAAI,CAAC,IAAI,EAAE,aAAa,iBAwE7C;AAED,QAAA,MAAM,OAAO;;;;;;oBAKS,CAAC;AAEvB,eAAe,OAAO,CAAC"}

package/types/main.d.ts

@@ -20,7 +20,7 @@ import { pull as hubPull } from "./hub.js";
 import { pull, push } from "./sync.js";
 import { add as workspaceAdd } from "./workspace.js";
 export { flow, app, script, workspace, resource, user, variable, hub, folder, schedule, trigger, sync, instance, dev, hubPull, pull, push, workspaceAdd, };
-export declare const VERSION = "1.479.2";
+export declare const VERSION = "1.480.0";
 declare const command: Command<{
     workspace?: (import("./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/mod.js").StringType & string) | undefined;
 } & {