@evalops/maestro 0.10.20 → 0.10.21

package/node_modules/@bufbuild/protobuf/dist/esm/types.d.ts

@@ -1,128 +0,0 @@
-import type { GenEnum as GenEnumV1, GenExtension as GenExtensionV1, GenMessage as GenMessageV1 } from "./codegenv1/types.js";
-import type { GenEnum as GenEnumV2, GenExtension as GenExtensionV2, GenMessage as GenMessageV2 } from "./codegenv2/types.js";
-import type { DescEnum, DescExtension, DescMessage, DescMethod } from "./descriptors.js";
-import type { OneofADT } from "./reflect/guard.js";
-import type { WireType } from "./wire/index.js";
-import type { JsonValue } from "./json-value.js";
-/**
- * The type `Message` contains the properties shared by all messages.
- */
-export type Message<TypeName extends string = string> = {
-    /**
-     * The fully qualified Protobuf type-name of the message.
-     */
-    readonly $typeName: TypeName;
-    /**
-     * Unknown fields and extensions stored on the message.
-     */
-    $unknown?: UnknownField[] | undefined;
-};
-/**
- * Extract the message type from a message descriptor.
- */
-export type MessageShape<Desc extends DescMessage> = Desc extends GenMessageV1<infer RuntimeShapeV1> ? RuntimeShapeV1 : Desc extends GenMessageV2<infer RuntimeShape> ? RuntimeShape : Message;
-/**
- * Extract the message JSON type from a message descriptor.
- *
- * JSON types are only available for code generated with the plugin option
- * `json_types=true`. If JSON types are unavailable, this type falls back to the
- * `JsonValue` type.
- */
-export type MessageJsonType<Desc extends DescMessage> = Desc extends GenMessageV1<Message, infer JsonTypeV1 extends JsonValue> ? JsonTypeV1 : Desc extends GenMessageV2<Message, {
-    jsonType: infer JsonType extends JsonValue;
-}> ? JsonType : JsonValue;
-/**
- * Extract the message Valid type from a message descriptor.
- *
- * Valid types are only available for code generated with the plugin option
- * `valid_types`. If Valid types are unavailable, this type falls back to the
- * regular message shape.
- */
-export type MessageValidType<Desc extends DescMessage> = Desc extends GenMessageV1<infer RuntimeShapeV1> ? RuntimeShapeV1 : Desc extends GenMessageV2<Message, {
-    validType: infer ValidType extends Message;
-}> ? ValidType : Desc extends GenMessageV2<infer RuntimeShape> ? RuntimeShape : Message;
-/**
- * Extract the init type from a message descriptor.
- * The init type is accepted by the function create().
- */
-export type MessageInitShape<Desc extends DescMessage> = Desc extends GenMessageV1<infer RuntimeShape> ? MessageInit<RuntimeShape> : Desc extends GenMessageV2<infer RuntimeShape> ? MessageInit<RuntimeShape> : Record<string, unknown>;
-/**
- * Extract the enum type of from an enum descriptor.
- */
-export type EnumShape<Desc extends DescEnum> = Desc extends GenEnumV1<infer RuntimeShape> ? RuntimeShape : Desc extends GenEnumV2<infer RuntimeShape> ? RuntimeShape : number;
-/**
- * Extract the enum JSON type from a enum descriptor.
- */
-export type EnumJsonType<Desc extends DescEnum> = Desc extends GenEnumV1<number, infer JsonType> ? JsonType : Desc extends GenEnumV2<number, infer JsonType> ? JsonType : string | null;
-/**
- * Extract the value type from an extension descriptor.
- */
-export type ExtensionValueShape<Desc extends DescExtension> = Desc extends GenExtensionV1<Message, infer RuntimeShape> ? RuntimeShape : Desc extends GenExtensionV2<Message, infer RuntimeShape> ? RuntimeShape : unknown;
-/**
- * Extract the type of the extended message from an extension descriptor.
- */
-export type Extendee<Desc extends DescExtension> = Desc extends GenExtensionV1<infer Extendee> ? Extendee : Desc extends GenExtensionV2<infer Extendee> ? Extendee : Message;
-/**
- * Unknown fields are fields that were not recognized during parsing, or
- * extension.
- */
-export type UnknownField = {
-    readonly no: number;
-    readonly wireType: WireType;
-    readonly data: Uint8Array;
-};
-/**
- * Describes a streaming RPC declaration.
- */
-export type DescMethodStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodClientStreaming<I, O> | DescMethodServerStreaming<I, O> | DescMethodBiDiStreaming<I, O>;
-/**
- * Describes a unary RPC declaration.
- */
-export type DescMethodUnary<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"unary", I, O>;
-/**
- * Describes a server streaming RPC declaration.
- */
-export type DescMethodServerStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"server_streaming", I, O>;
-/**
- * Describes a client streaming RPC declaration.
- */
-export type DescMethodClientStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"client_streaming", I, O>;
-/**
- * Describes a bidi streaming RPC declaration.
- */
-export type DescMethodBiDiStreaming<I extends DescMessage = DescMessage, O extends DescMessage = DescMessage> = DescMethodTyped<"bidi_streaming", I, O>;
-/**
- * The init type for a message, which makes all fields optional.
- * The init type is accepted by the function create().
- */
-type MessageInit<T extends Message> = T | {
-    [P in keyof T as P extends "$unknown" ? never : P]?: P extends "$typeName" ? never : FieldInit<T[P]>;
-};
-type FieldInit<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<FieldInit<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<FieldInit<U>> : F extends Message ? MessageInit<F> : F extends OneofSelectedMessage<infer C, infer V> ? {
-    case: C;
-    value: MessageInit<V>;
-} : F extends OneofADT ? F : F extends MapWithMessage<infer V> ? {
-    [key: string | number]: MessageInit<V>;
-} : F;
-type MapWithMessage<V extends Message> = {
-    [key: string | number]: V;
-};
-type OneofSelectedMessage<K extends string, M extends Message> = {
-    case: K;
-    value: M;
-};
-type DescMethodTyped<K extends DescMethod["methodKind"], I extends DescMessage, O extends DescMessage> = Omit<DescMethod, "methodKind" | "input" | "output"> & {
-    /**
-     * One of the four available method types.
-     */
-    readonly methodKind: K;
-    /**
-     * The message type for requests.
-     */
-    readonly input: I;
-    /**
-     * The message type for responses.
-     */
-    readonly output: O;
-};
-export {};

package/node_modules/@bufbuild/protobuf/dist/esm/types.js

@@ -1,14 +0,0 @@
-// Copyright 2021-2026 Buf Technologies, Inc.
-//
-// 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.
-export {};

package/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.d.ts

@@ -1,23 +0,0 @@
-/**
- * Decodes a base64 string to a byte array.
- *
- * - ignores white-space, including line breaks and tabs
- * - allows inner padding (can decode concatenated base64 strings)
- * - does not require padding
- * - understands base64url encoding:
- *   "-" instead of "+",
- *   "_" instead of "/",
- *   no padding
- */
-export declare function base64Decode(base64Str: string): Uint8Array<ArrayBuffer>;
-/**
- * Encode a byte array to a base64 string.
- *
- * By default, this function uses the standard base64 encoding with padding.
- *
- * To encode without padding, use encoding = "std_raw".
- *
- * To encode with the URL encoding, use encoding = "url", which replaces the
- * characters +/ by their URL-safe counterparts -_, and omits padding.
- */
-export declare function base64Encode(bytes: Uint8Array, encoding?: "std" | "std_raw" | "url"): string;

package/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js

@@ -1,152 +0,0 @@
-// Copyright 2021-2026 Buf Technologies, Inc.
-//
-// 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.
-/**
- * Decodes a base64 string to a byte array.
- *
- * - ignores white-space, including line breaks and tabs
- * - allows inner padding (can decode concatenated base64 strings)
- * - does not require padding
- * - understands base64url encoding:
- *   "-" instead of "+",
- *   "_" instead of "/",
- *   no padding
- */
-export function base64Decode(base64Str) {
-    const table = getDecodeTable();
-    // estimate byte size, not accounting for inner padding and whitespace
-    let es = (base64Str.length * 3) / 4;
-    if (base64Str[base64Str.length - 2] == "=")
-        es -= 2;
-    else if (base64Str[base64Str.length - 1] == "=")
-        es -= 1;
-    let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
-    groupPos = 0, // position in base64 group
-    b, // current byte
-    p = 0; // previous byte
-    for (let i = 0; i < base64Str.length; i++) {
-        b = table[base64Str.charCodeAt(i)];
-        if (b === undefined) {
-            switch (base64Str[i]) {
-                // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
-                case "=":
-                    groupPos = 0; // reset state when padding found
-                case "\n":
-                case "\r":
-                case "\t":
-                case " ":
-                    continue; // skip white-space, and padding
-                default:
-                    throw Error("invalid base64 string");
-            }
-        }
-        switch (groupPos) {
-            case 0:
-                p = b;
-                groupPos = 1;
-                break;
-            case 1:
-                bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
-                p = b;
-                groupPos = 2;
-                break;
-            case 2:
-                bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
-                p = b;
-                groupPos = 3;
-                break;
-            case 3:
-                bytes[bytePos++] = ((p & 3) << 6) | b;
-                groupPos = 0;
-                break;
-        }
-    }
-    if (groupPos == 1)
-        throw Error("invalid base64 string");
-    return bytes.subarray(0, bytePos);
-}
-/**
- * Encode a byte array to a base64 string.
- *
- * By default, this function uses the standard base64 encoding with padding.
- *
- * To encode without padding, use encoding = "std_raw".
- *
- * To encode with the URL encoding, use encoding = "url", which replaces the
- * characters +/ by their URL-safe counterparts -_, and omits padding.
- */
-export function base64Encode(bytes, encoding = "std") {
-    const table = getEncodeTable(encoding);
-    const pad = encoding == "std";
-    let base64 = "", groupPos = 0, // position in base64 group
-    b, // current byte
-    p = 0; // carry over from previous byte
-    for (let i = 0; i < bytes.length; i++) {
-        b = bytes[i];
-        switch (groupPos) {
-            case 0:
-                base64 += table[b >> 2];
-                p = (b & 3) << 4;
-                groupPos = 1;
-                break;
-            case 1:
-                base64 += table[p | (b >> 4)];
-                p = (b & 15) << 2;
-                groupPos = 2;
-                break;
-            case 2:
-                base64 += table[p | (b >> 6)];
-                base64 += table[b & 63];
-                groupPos = 0;
-                break;
-        }
-    }
-    // add output padding
-    if (groupPos) {
-        base64 += table[p];
-        if (pad) {
-            base64 += "=";
-            if (groupPos == 1)
-                base64 += "=";
-        }
-    }
-    return base64;
-}
-// lookup table from base64 character to byte
-let encodeTableStd;
-let encodeTableUrl;
-// lookup table from base64 character *code* to byte because lookup by number is fast
-let decodeTable;
-function getEncodeTable(encoding) {
-    if (!encodeTableStd) {
-        encodeTableStd =
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-        encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_");
-    }
-    return encoding == "url"
-        ? // biome-ignore lint/style/noNonNullAssertion: TS fails to narrow down
-            encodeTableUrl
-        : encodeTableStd;
-}
-function getDecodeTable() {
-    if (!decodeTable) {
-        decodeTable = [];
-        const encodeTable = getEncodeTable("std");
-        for (let i = 0; i < encodeTable.length; i++)
-            decodeTable[encodeTable[i].charCodeAt(0)] = i;
-        // support base64url variants
-        decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+");
-        decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/");
-    }
-    return decodeTable;
-}

package/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.d.ts

@@ -1,266 +0,0 @@
-/**
- * Protobuf binary format wire types.
- *
- * A wire type provides just enough information to find the length of the
- * following value.
- *
- * See https://developers.google.com/protocol-buffers/docs/encoding#structure
- */
-export declare enum WireType {
-    /**
-     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
-     */
-    Varint = 0,
-    /**
-     * Used for fixed64, sfixed64, double.
-     * Always 8 bytes with little-endian byte order.
-     */
-    Bit64 = 1,
-    /**
-     * Used for string, bytes, embedded messages, packed repeated fields
-     *
-     * Only repeated numeric types (types which use the varint, 32-bit,
-     * or 64-bit wire types) can be packed. In proto3, such fields are
-     * packed by default.
-     */
-    LengthDelimited = 2,
-    /**
-     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
-     * in editions with message_encoding = DELIMITED.
-     */
-    StartGroup = 3,
-    /**
-     * End of a tag-delimited aggregate.
-     */
-    EndGroup = 4,
-    /**
-     * Used for fixed32, sfixed32, float.
-     * Always 4 bytes with little-endian byte order.
-     */
-    Bit32 = 5
-}
-/**
- * Maximum value for a 32-bit floating point value (Protobuf FLOAT).
- */
-export declare const FLOAT32_MAX = 3.4028234663852886e+38;
-/**
- * Minimum value for a 32-bit floating point value (Protobuf FLOAT).
- */
-export declare const FLOAT32_MIN = -3.4028234663852886e+38;
-/**
- * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32).
- */
-export declare const UINT32_MAX = 4294967295;
-/**
- * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
- */
-export declare const INT32_MAX = 2147483647;
-/**
- * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32).
- */
-export declare const INT32_MIN = -2147483648;
-export declare class BinaryWriter {
-    private readonly encodeUtf8;
-    /**
-     * We cannot allocate a buffer for the entire output
-     * because we don't know its size.
-     *
-     * So we collect smaller chunks of known size and
-     * concat them later.
-     *
-     * Use `raw()` to push data to this array. It will flush
-     * `buf` first.
-     */
-    private chunks;
-    /**
-     * A growing buffer for byte values. If you don't know
-     * the size of the data you are writing, push to this
-     * array.
-     */
-    protected buf: number[];
-    /**
-     * Previous fork states.
-     */
-    private stack;
-    constructor(encodeUtf8?: (text: string) => Uint8Array);
-    /**
-     * Return all bytes written and reset this writer.
-     */
-    finish(): Uint8Array<ArrayBuffer>;
-    /**
-     * Start a new fork for length-delimited data like a message
-     * or a packed repeated field.
-     *
-     * Must be joined later with `join()`.
-     */
-    fork(): this;
-    /**
-     * Join the last fork. Write its length and bytes, then
-     * return to the previous state.
-     */
-    join(): this;
-    /**
-     * Writes a tag (field number and wire type).
-     *
-     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
-     *
-     * Generated code should compute the tag ahead of time and call `uint32()`.
-     */
-    tag(fieldNo: number, type: WireType): this;
-    /**
-     * Write a chunk of raw bytes.
-     */
-    raw(chunk: Uint8Array): this;
-    /**
-     * Write a `uint32` value, an unsigned 32 bit varint.
-     */
-    uint32(value: number): this;
-    /**
-     * Write a `int32` value, a signed 32 bit varint.
-     */
-    int32(value: number): this;
-    /**
-     * Write a `bool` value, a varint.
-     */
-    bool(value: boolean): this;
-    /**
-     * Write a `bytes` value, length-delimited arbitrary data.
-     */
-    bytes(value: Uint8Array): this;
-    /**
-     * Write a `string` value, length-delimited data converted to UTF-8 text.
-     */
-    string(value: string): this;
-    /**
-     * Write a `float` value, 32-bit floating point number.
-     */
-    float(value: number): this;
-    /**
-     * Write a `double` value, a 64-bit floating point number.
-     */
-    double(value: number): this;
-    /**
-     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
-     */
-    fixed32(value: number): this;
-    /**
-     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
-     */
-    sfixed32(value: number): this;
-    /**
-     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
-     */
-    sint32(value: number): this;
-    /**
-     * Write a `sfixed64` value, a signed, fixed-length 64-bit integer.
-     */
-    sfixed64(value: string | number | bigint): this;
-    /**
-     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
-     */
-    fixed64(value: string | number | bigint): this;
-    /**
-     * Write a `int64` value, a signed 64-bit varint.
-     */
-    int64(value: string | number | bigint): this;
-    /**
-     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
-     */
-    sint64(value: string | number | bigint): this;
-    /**
-     * Write a `uint64` value, an unsigned 64-bit varint.
-     */
-    uint64(value: string | number | bigint): this;
-}
-export declare class BinaryReader {
-    private readonly decodeUtf8;
-    /**
-     * Current position.
-     */
-    pos: number;
-    /**
-     * Number of bytes available in this reader.
-     */
-    readonly len: number;
-    protected readonly buf: Uint8Array;
-    private readonly view;
-    constructor(buf: Uint8Array, decodeUtf8?: (bytes: Uint8Array, strict?: boolean) => string);
-    /**
-     * Reads a tag - field number and wire type. Tags are uint32 varints; values
-     * that do not fit in uint32 are rejected.
-     */
-    tag(): [number, WireType];
-    /**
-     * Skip one element and return the skipped data.
-     *
-     * When skipping StartGroup, provide the tags field number to check for
-     * matching field number in the EndGroup tag.
-     */
-    skip(wireType: WireType, fieldNo?: number): Uint8Array;
-    protected varint64: () => [number, number];
-    /**
-     * Throws error if position in byte array is out of range.
-     */
-    protected assertBounds(): void;
-    /**
-     * Read a `uint32` field, an unsigned 32 bit varint.
-     */
-    uint32: () => number;
-    /**
-     * Read a `int32` field, a signed 32 bit varint.
-     */
-    int32(): number;
-    /**
-     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
-     */
-    sint32(): number;
-    /**
-     * Read a `int64` field, a signed 64-bit varint.
-     */
-    int64(): bigint | string;
-    /**
-     * Read a `uint64` field, an unsigned 64-bit varint.
-     */
-    uint64(): bigint | string;
-    /**
-     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
-     */
-    sint64(): bigint | string;
-    /**
-     * Read a `bool` field, a variant.
-     */
-    bool(): boolean;
-    /**
-     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
-     */
-    fixed32(): number;
-    /**
-     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
-     */
-    sfixed32(): number;
-    /**
-     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
-     */
-    fixed64(): bigint | string;
-    /**
-     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
-     */
-    sfixed64(): bigint | string;
-    /**
-     * Read a `float` field, 32-bit floating point number.
-     */
-    float(): number;
-    /**
-     * Read a `double` field, a 64-bit floating point number.
-     */
-    double(): number;
-    /**
-     * Read a `bytes` field, length-delimited arbitrary data.
-     */
-    bytes(): Uint8Array;
-    /**
-     * Read a `string` field, length-delimited data converted to UTF-8 text. If
-     * `strict` is true, throw on invalid UTF-8 instead of substituting U+FFFD.
-     */
-    string(strict?: boolean): string;
-}