@restatedev/restate-sdk-integration-client 0.0.0-stage → 1.18.0

package/dist/generated/dev/restate/ingress/ingestion/v1/ingestion_svc_pb.js

@@ -0,0 +1,131 @@
+import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv2";
+
+//#region src/generated/dev/restate/ingress/ingestion/v1/ingestion_svc_pb.ts
+/**
+* Describes the file dev/restate/ingress/ingestion/v1/ingestion_svc.proto.
+*/
+const file_dev_restate_ingress_ingestion_v1_ingestion_svc = /* @__PURE__ */ fileDesc("CjRkZXYvcmVzdGF0ZS9pbmdyZXNzL2luZ2VzdGlvbi92MS9pbmdlc3Rpb25fc3ZjLnByb3RvEiBkZXYucmVzdGF0ZS5pbmdyZXNzLmluZ2VzdGlvbi52MSLSAQoOSW5nZXN0aW9uU3RhcnQSEwoLcHJvZHVjZXJfaWQYASABKAkSEwoLaW50ZWdyYXRpb24YAiABKAkSTwoSZGVkdXBsaWNhdGlvbl9tb2RlGAMgASgOMjMuZGV2LnJlc3RhdGUuaW5ncmVzcy5pbmdlc3Rpb24udjEuRGVkdXBsaWNhdGlvbk1vZGUSRQoIZGVmYXVsdHMYBCABKAsyMy5kZXYucmVzdGF0ZS5pbmdyZXNzLmluZ2VzdGlvbi52MS5Jbmdlc3Rpb25EZWZhdWx0cyK+AgoRSW5nZXN0aW9uRGVmYXVsdHMSEgoFc2NvcGUYAiABKAlIAIgBARIWCglsaW1pdF9rZXkYAyABKAlIAYgBARIUCgdzZXJ2aWNlGAQgASgJSAKIAQESFAoHaGFuZGxlchgFIAEoCUgDiAEBEhAKA2tleRgGIAEoCUgEiAEBElEKB2hlYWRlcnMYCCADKAsyQC5kZXYucmVzdGF0ZS5pbmdyZXNzLmluZ2VzdGlvbi52MS5Jbmdlc3Rpb25EZWZhdWx0cy5IZWFkZXJzRW50cnkaLgoMSGVhZGVyc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAFCCAoGX3Njb3BlQgwKCl9saW1pdF9rZXlCCgoIX3NlcnZpY2VCCgoIX2hhbmRsZXJCBgoEX2tleUoECAcQCCK2BAoTSW5nZXN0aW9uSW52b2NhdGlvbhIOCgZvZmZzZXQYASABKAQSEgoFc2NvcGUYAiABKAlIAIgBARIWCglsaW1pdF9rZXkYAyABKAlIAYgBARIUCgdzZXJ2aWNlGAQgASgJSAKIAQESFAoHaGFuZGxlchgFIAEoCUgDiAEBEhAKA2tleRgGIAEoCUgEiAEBEhwKD2lkZW1wb3RlbmN5X2tleRgHIAEoCUgFiAEBEmgKEmFkZGl0aW9uYWxfaGVhZGVycxgIIAMoCzJMLmRldi5yZXN0YXRlLmluZ3Jlc3MuaW5nZXN0aW9uLnYxLkluZ2VzdGlvbkludm9jYXRpb24uQWRkaXRpb25hbEhlYWRlcnNFbnRyeRIeChFpbnZva2VfdGltZV90c19tcxgKIAEoBEgGiAEBEhgKC3RyYWNlcGFyZW50GAsgASgJSAeIAQESFwoKdHJhY2VzdGF0ZRgMIAEoCUgIiAEBEg8KB3BheWxvYWQYDSABKAwaOAoWQWRkaXRpb25hbEhlYWRlcnNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBQggKBl9zY29wZUIMCgpfbGltaXRfa2V5QgoKCF9zZXJ2aWNlQgoKCF9oYW5kbGVyQgYKBF9rZXlCEgoQX2lkZW1wb3RlbmN5X2tleUIUChJfaW52b2tlX3RpbWVfdHNfbXNCDgoMX3RyYWNlcGFyZW50Qg0KC190cmFjZXN0YXRlIvMBChBJbmdlc3Rpb25SZXF1ZXN0EkEKBXN0YXJ0GAEgASgLMjAuZGV2LnJlc3RhdGUuaW5ncmVzcy5pbmdlc3Rpb24udjEuSW5nZXN0aW9uU3RhcnRIABJHCghkZWZhdWx0cxgCIAEoCzIzLmRldi5yZXN0YXRlLmluZ3Jlc3MuaW5nZXN0aW9uLnYxLkluZ2VzdGlvbkRlZmF1bHRzSAASSwoKaW52b2NhdGlvbhgDIAEoCzI1LmRldi5yZXN0YXRlLmluZ3Jlc3MuaW5nZXN0aW9uLnYxLkluZ2VzdGlvbkludm9jYXRpb25IAEIGCgRraW5kIicKDFdpbmRvd1VwZGF0ZRIXCg9pbmNyZW1lbnRfYnl0ZXMYASABKA0iiQEKBUVycm9yEh4KEWludm9jYXRpb25fb2Zmc2V0GAEgASgESACIAQESOQoEa2luZBgCIAEoDjIrLmRldi5yZXN0YXRlLmluZ3Jlc3MuaW5nZXN0aW9uLnYxLkVycm9yS2luZBIPCgdtZXNzYWdlGAMgASgJQhQKEl9pbnZvY2F0aW9uX29mZnNldCLSAQoRSW5nZXN0aW9uUmVzcG9uc2USGwoObGFzdF9jb21taXR0ZWQYASABKARIAYgBARJHCg13aW5kb3dfdXBkYXRlGAIgASgLMi4uZGV2LnJlc3RhdGUuaW5ncmVzcy5pbmdlc3Rpb24udjEuV2luZG93VXBkYXRlSAASOAoFZXJyb3IYAyABKAsyJy5kZXYucmVzdGF0ZS5pbmdyZXNzLmluZ2VzdGlvbi52MS5FcnJvckgAQgoKCHJlc3BvbnNlQhEKD19sYXN0X2NvbW1pdHRlZCozChFEZWR1cGxpY2F0aW9uTW9kZRIMCghESVNBQkxFRBAAEhAKDE9GRlNFVF9CQVNFRBABKqsBCglFcnJvcktpbmQSFgoSRVJST1JfS0lORF9VTktOT1dOEAASHAoYRVJST1JfS0lORF9TSFVUVElOR19ET1dOEAESFgoSRVJST1JfS0lORF9HT19BV0FZEAISGAoURVJST1JfS0lORF9OT1RfRk9VTkQQAxIaChZFUlJPUl9LSU5EX0JBRF9SRVFVRVNUEAQSGgoWRVJST1JfS0lORF9VTkFWQUlMQUJMRRAFMoUBCgxJbmdlc3Rpb25TdmMSdQoGSW5nZXN0EjIuZGV2LnJlc3RhdGUuaW5ncmVzcy5pbmdlc3Rpb24udjEuSW5nZXN0aW9uUmVxdWVzdBozLmRldi5yZXN0YXRlLmluZ3Jlc3MuaW5nZXN0aW9uLnYxLkluZ2VzdGlvblJlc3BvbnNlKAEwAUIsChhkZXYucmVzdGF0ZS5pbmdlc3Rpb24udjFCDkluZ2VzdGlvblByb3RvUAFiBnByb3RvMw");
+/**
+* Describes the message dev.restate.ingress.ingestion.v1.IngestionDefaults.
+* Use `create(IngestionDefaultsSchema)` to create a new message.
+*/
+const IngestionDefaultsSchema = /* @__PURE__ */ messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 1);
+/**
+* Describes the message dev.restate.ingress.ingestion.v1.IngestionInvocation.
+* Use `create(IngestionInvocationSchema)` to create a new message.
+*/
+const IngestionInvocationSchema = /* @__PURE__ */ messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 2);
+/**
+* Describes the message dev.restate.ingress.ingestion.v1.IngestionRequest.
+* Use `create(IngestionRequestSchema)` to create a new message.
+*/
+const IngestionRequestSchema = /* @__PURE__ */ messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 3);
+/**
+* How the server deduplicates the records of a stream.
+*
+* The mode is fixed for the lifetime of the stream: it is chosen once in the
+* `Start` frame and cannot be changed by a later `IngestionDefaults` frame.
+*
+* Note that this only controls deduplication. Regardless of the mode, every
+* `Invocation` must still carry an `offset`, offsets must still increase
+* monotonically within a stream, and `Response.last_committed` still reports
+* progress in terms of those offsets.
+*
+* @generated from enum dev.restate.ingress.ingestion.v1.DeduplicationMode
+*/
+let DeduplicationMode = /* @__PURE__ */ function(DeduplicationMode$1) {
+	/**
+	* Disable deduplication: every record accepted by the server becomes an
+	* invocation.
+	*
+	* Nothing is tracked across streams, so resending records after a
+	* reconnect duplicates them. Pick this mode only when the producer cannot
+	* supply a stable ID, or when duplicates are acceptable or already
+	* suppressed elsewhere (for example by an `idempotency_key`).
+	*
+	* `producer_id` is optional in this mode, but is still recorded on traces
+	* and metrics when set.
+	*
+	* @generated from enum value: DISABLED = 0;
+	*/
+	DeduplicationMode$1[DeduplicationMode$1["DISABLED"] = 0] = "DISABLED";
+	/**
+	* Deduplicate on `(producer_id, offset)`.
+	*
+	* The server tracks the highest committed offset per producer ID and
+	* silently drops any record whose offset is not above it, which makes
+	* resending a range of records after a reconnect safe: records the server
+	* already committed do not become duplicate invocations.
+	*
+	* This mode requires `producer_id` to be set; using it with an empty
+	* producer ID fails the stream with `GO_AWAY`. It also requires the
+	* producer to reuse the same ID across streams, since a new ID starts
+	* from a fresh deduplication state.
+	*
+	* @generated from enum value: OFFSET_BASED = 1;
+	*/
+	DeduplicationMode$1[DeduplicationMode$1["OFFSET_BASED"] = 1] = "OFFSET_BASED";
+	return DeduplicationMode$1;
+}({});
+/**
+* @generated from enum dev.restate.ingress.ingestion.v1.ErrorKind
+*/
+let ErrorKind = /* @__PURE__ */ function(ErrorKind$1) {
+	/**
+	* @generated from enum value: ERROR_KIND_UNKNOWN = 0;
+	*/
+	ErrorKind$1[ErrorKind$1["UNKNOWN"] = 0] = "UNKNOWN";
+	/**
+	* The server is shutting down and can't accept more
+	* records. The caller must switch to a new ingress
+	* node and respect the reported last_committed.
+	*
+	* @generated from enum value: ERROR_KIND_SHUTTING_DOWN = 1;
+	*/
+	ErrorKind$1[ErrorKind$1["SHUTTING_DOWN"] = 1] = "SHUTTING_DOWN";
+	/**
+	* A protocol violation, for example sending another
+	* Start message after the initial one or not
+	* respecting the send window.
+	*
+	* @generated from enum value: ERROR_KIND_GO_AWAY = 2;
+	*/
+	ErrorKind$1[ErrorKind$1["GO_AWAY"] = 2] = "GO_AWAY";
+	/**
+	* The invocation target was not found (unknown
+	* service or handler).
+	*
+	* @generated from enum value: ERROR_KIND_NOT_FOUND = 3;
+	*/
+	ErrorKind$1[ErrorKind$1["NOT_FOUND"] = 3] = "NOT_FOUND";
+	/**
+	* Covers a wide range of client errors, including:
+	* - unexpected key
+	* - missing key
+	* - invalid scope format
+	* and similar errors. The `Error.message` should
+	* carry more details.
+	*
+	* @generated from enum value: ERROR_KIND_BAD_REQUEST = 4;
+	*/
+	ErrorKind$1[ErrorKind$1["BAD_REQUEST"] = 4] = "BAD_REQUEST";
+	/**
+	* The server can't process the request yet, for
+	* example because it has not loaded the schema.
+	* The caller should retry later (possibly on a
+	* different ingress node) without changing the
+	* request.
+	*
+	* @generated from enum value: ERROR_KIND_UNAVAILABLE = 5;
+	*/
+	ErrorKind$1[ErrorKind$1["UNAVAILABLE"] = 5] = "UNAVAILABLE";
+	return ErrorKind$1;
+}({});
+/**
+* @generated from service dev.restate.ingress.ingestion.v1.IngestionSvc
+*/
+const IngestionSvc = /* @__PURE__ */ serviceDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 0);
+
+//#endregion
+export { DeduplicationMode, ErrorKind, IngestionDefaultsSchema, IngestionInvocationSchema, IngestionRequestSchema, IngestionSvc };
+//# sourceMappingURL=ingestion_svc_pb.js.map

package/dist/generated/dev/restate/ingress/ingestion/v1/ingestion_svc_pb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion_svc_pb.js","names":["file_dev_restate_ingress_ingestion_v1_ingestion_svc: GenFile","IngestionDefaultsSchema: GenMessage<IngestionDefaults>","IngestionInvocationSchema: GenMessage<IngestionInvocation>","IngestionRequestSchema: GenMessage<IngestionRequest>","IngestionSvc: GenService<{\n  /**\n   * Opens a bidirectional node-to-node stream.\n   *\n   * @generated from rpc dev.restate.ingress.ingestion.v1.IngestionSvc.Ingest\n   */\n  ingest: {\n    methodKind: \"bidi_streaming\";\n    input: typeof IngestionRequestSchema;\n    output: typeof IngestionResponseSchema;\n  };\n}>"],"sources":["../../../../../../../src/generated/dev/restate/ingress/ingestion/v1/ingestion_svc_pb.ts"],"sourcesContent":["// Copyright (c) 2026 - Restate Software, Inc., Restate GmbH\n//\n// This file is part of the Restate service protocol, which is\n// released under the MIT license.\n//\n// You can find a copy of the license in file LICENSE in the root\n// directory of this repository or package, or at\n// https://github.com/restatedev/proto/blob/main/LICENSE\n\n// @generated by protoc-gen-es v2.16.0 with parameter \"target=ts,import_extension=js\"\n// @generated from file dev/restate/ingress/ingestion/v1/ingestion_svc.proto (package dev.restate.ingress.ingestion.v1, syntax proto3)\n/* eslint-disable */\n\nimport type {\n  GenEnum,\n  GenFile,\n  GenMessage,\n  GenService,\n} from \"@bufbuild/protobuf/codegenv2\";\nimport {\n  enumDesc,\n  fileDesc,\n  messageDesc,\n  serviceDesc,\n} from \"@bufbuild/protobuf/codegenv2\";\nimport type { Message } from \"@bufbuild/protobuf\";\n\n/**\n * Describes the file dev/restate/ingress/ingestion/v1/ingestion_svc.proto.\n */\nexport const file_dev_restate_ingress_ingestion_v1_ingestion_svc: GenFile =\n  /*@__PURE__*/\n  fileDesc(\n    \"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\"\n  );\n\n/**\n * Required.\n * A Start frame must be sent before any IngestionDefaults or\n * IngestionInvocation frame.\n * Sending a Start frame again during the lifetime of\n * the stream is illegal: the server will return an\n * error and terminate the stream.\n *\n * Invalid Start message will cause an error\n * to be returned immediately, and stream to be teared down\n * immediately\n *\n * @generated from message dev.restate.ingress.ingestion.v1.IngestionStart\n */\nexport type IngestionStart =\n  Message<\"dev.restate.ingress.ingestion.v1.IngestionStart\"> & {\n    /**\n     * Stable identity of the *producer*, not of this particular stream.\n     *\n     * The ID is an opaque string: this API is generic, so the server\n     * attaches no format or meaning to it. It is entirely up to the producer\n     * to pick an ID that uniquely identifies a single source of sequential,\n     * ordered messages, since offsets are only meaningful relative to that\n     * source. For a Kafka-based producer, for instance, an ID composed of\n     * cluster + topic + consumer-group + partition would identify such a\n     * source.\n     *\n     * Depending on the DedupMode, the same producer must reuse the same\n     * ID across streams (including after reconnects), otherwise deduplication\n     * cannot work: the server tracks committed offsets per producer ID,\n     * so a new ID starts a fresh deduplication state and previously committed\n     * records may be duplicated.\n     *\n     * The ID must be unique across producers: two distinct producers\n     * sharing an ID will be treated as one and will shadow each other's\n     * offsets.\n     *\n     * Max length is 256 bytes.\n     *\n     * @generated from field: string producer_id = 1;\n     */\n    producerId: string;\n\n    /**\n     * Integration identification in format `name/version`\n     * Max length is 64 bytes\n     *\n     * @generated from field: string integration = 2;\n     */\n    integration: string;\n\n    /**\n     * Deduplication strategy for this stream. Defaults to `DISABLED`.\n     *\n     * @generated from field: dev.restate.ingress.ingestion.v1.DeduplicationMode deduplication_mode = 3;\n     */\n    deduplicationMode: DeduplicationMode;\n\n    /**\n     * Initial ingestion defaults for the stream, letting the client\n     * establish its defaults up front instead of following\n     * the Start frame with a separate IngestionDefaults frame.\n     * Clients can still send further IngestionDefaults frames later\n     * to update these defaults during the stream.\n     *\n     * @generated from field: dev.restate.ingress.ingestion.v1.IngestionDefaults defaults = 4;\n     */\n    defaults?: IngestionDefaults | undefined;\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.IngestionStart.\n * Use `create(IngestionStartSchema)` to create a new message.\n */\nexport const IngestionStartSchema: GenMessage<IngestionStart> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 0);\n\n/**\n * An IngestionDefaults message defines the default values applied to all\n * subsequent records in the stream.\n * Each IngestionDefaults message must specify every field it wants to set.\n * Each IngestionDefaults message overwrites the values set by previous IngestionDefaults messages.\n * Leaving an optional field unset clears any previously established\n * default, so later records must supply the value explicitly if needed.\n *\n * It's okay to send IngestionDefaults more than once to tweak and change the defaults\n * during the life time of the stream.\n *\n * Every field here has a matching field on `Invocation`. For those fields the\n * per-record value wins: if the `Invocation` sets the field, its value is used\n * and the default from `IngestionDefaults` is ignored; if it leaves the field unset, the\n * current default from `IngestionDefaults` is used instead. If neither is set, the field\n * is treated as absent, which may be an error for fields that are required for\n * the given target (e.g. `key` for virtual objects and workflows).\n *\n * `headers` are extended with the Invocation's `additional_headers`\n * overriding existing keys.\n *\n * Note: Keep the field tags uniform with the Invocation message\n * This allows parsing IngestionInvocation message as IngestionDefaults.\n *\n * @generated from message dev.restate.ingress.ingestion.v1.IngestionDefaults\n */\nexport type IngestionDefaults =\n  Message<\"dev.restate.ingress.ingestion.v1.IngestionDefaults\"> & {\n    /**\n     * scope is limited to 36 bytes.\n     *\n     * @generated from field: optional string scope = 2;\n     */\n    scope?: string | undefined;\n\n    /**\n     * @generated from field: optional string limit_key = 3;\n     */\n    limitKey?: string | undefined;\n\n    /**\n     * @generated from field: optional string service = 4;\n     */\n    service?: string | undefined;\n\n    /**\n     * @generated from field: optional string handler = 5;\n     */\n    handler?: string | undefined;\n\n    /**\n     * @generated from field: optional string key = 6;\n     */\n    key?: string | undefined;\n\n    /**\n     * Total headers size should not exceed a max of 2KiB (keys + values)\n     *\n     * @generated from field: map<string, string> headers = 8;\n     */\n    headers: { [key: string]: string };\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.IngestionDefaults.\n * Use `create(IngestionDefaultsSchema)` to create a new message.\n */\nexport const IngestionDefaultsSchema: GenMessage<IngestionDefaults> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 1);\n\n/**\n * @generated from message dev.restate.ingress.ingestion.v1.IngestionInvocation\n */\nexport type IngestionInvocation =\n  Message<\"dev.restate.ingress.ingestion.v1.IngestionInvocation\"> & {\n    /**\n     * Position of this record within the producer's sequence, and the value\n     * deduplication is based on.\n     *\n     * It must increase monotonically for a given producer ID, across the whole\n     * lifetime of that producer and not just within a single stream. On\n     * reconnect, resume from the `Response.last_committed` reported for the\n     * producer rather than restarting the numbering.\n     *\n     * Offsets do not have to be contiguous; gaps are allowed, so it is fine to\n     * skip records. Only the ordering matters. Offsets are 0-based, so 0 is a\n     * valid first offset.\n     *\n     * Within a single stream the server enforces this: sending an offset lower\n     * than one already sent on the same stream is a protocol violation and\n     * fails the stream with `GO_AWAY`.\n     *\n     * Across streams nothing is enforced, since the server does not remember\n     * what a previous stream sent. Reusing an offset already committed by an\n     * earlier stream of the same producer is not reported as an error: the\n     * record is treated as a duplicate and silently dropped, meaning it does\n     * not become an invocation and produces no `Error` frame. A client that\n     * restarts its numbering after a reconnect will therefore see its records\n     * disappear without any signal.\n     *\n     * @generated from field: uint64 offset = 1;\n     */\n    offset: bigint;\n\n    /**\n     * scope is limited to 36 bytes.\n     *\n     * @generated from field: optional string scope = 2;\n     */\n    scope?: string | undefined;\n\n    /**\n     * @generated from field: optional string limit_key = 3;\n     */\n    limitKey?: string | undefined;\n\n    /**\n     * @generated from field: optional string service = 4;\n     */\n    service?: string | undefined;\n\n    /**\n     * @generated from field: optional string handler = 5;\n     */\n    handler?: string | undefined;\n\n    /**\n     * Required when the target service is a virtual object (VO).\n     * or workflow. This can also be set via a preceding IngestionDefaults message.\n     *\n     * @generated from field: optional string key = 6;\n     */\n    key?: string | undefined;\n\n    /**\n     * @generated from field: optional string idempotency_key = 7;\n     */\n    idempotencyKey?: string | undefined;\n\n    /**\n     * IngestionDefaults::headers + IngestionInvocation::headers size\n     * should not exceed a max of 2KiB (keys + values)\n     *\n     * @generated from field: map<string, string> additional_headers = 8;\n     */\n    additionalHeaders: { [key: string]: string };\n\n    /**\n     * starttime timestamp in ms.\n     *\n     * @generated from field: optional uint64 invoke_time_ts_ms = 10;\n     */\n    invokeTimeTsMs?: bigint | undefined;\n\n    /**\n     * This uses the w3c tracecontext format\n     * https://www.w3.org/TR/trace-context/\n     *\n     * @generated from field: optional string traceparent = 11;\n     */\n    traceparent?: string | undefined;\n\n    /**\n     * @generated from field: optional string tracestate = 12;\n     */\n    tracestate?: string | undefined;\n\n    /**\n     * @generated from field: bytes payload = 13;\n     */\n    payload: Uint8Array;\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.IngestionInvocation.\n * Use `create(IngestionInvocationSchema)` to create a new message.\n */\nexport const IngestionInvocationSchema: GenMessage<IngestionInvocation> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 2);\n\n/**\n * @generated from message dev.restate.ingress.ingestion.v1.IngestionRequest\n */\nexport type IngestionRequest =\n  Message<\"dev.restate.ingress.ingestion.v1.IngestionRequest\"> & {\n    /**\n     * @generated from oneof dev.restate.ingress.ingestion.v1.IngestionRequest.kind\n     */\n    kind:\n      | {\n          /**\n           * @generated from field: dev.restate.ingress.ingestion.v1.IngestionStart start = 1;\n           */\n          value: IngestionStart;\n          case: \"start\";\n        }\n      | {\n          /**\n           * @generated from field: dev.restate.ingress.ingestion.v1.IngestionDefaults defaults = 2;\n           */\n          value: IngestionDefaults;\n          case: \"defaults\";\n        }\n      | {\n          /**\n           * @generated from field: dev.restate.ingress.ingestion.v1.IngestionInvocation invocation = 3;\n           */\n          value: IngestionInvocation;\n          case: \"invocation\";\n        }\n      | { case: undefined; value?: undefined };\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.IngestionRequest.\n * Use `create(IngestionRequestSchema)` to create a new message.\n */\nexport const IngestionRequestSchema: GenMessage<IngestionRequest> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 3);\n\n/**\n * Application-layer flow-control message.\n * It tells the client how many more bytes it can send\n * before it must wait for the next window update.\n *\n * This frame only replenishes the window; it carries no\n * acknowledgement. Acking is the job of the enclosing\n * IngestionResponse.last_committed, which is set\n * regardless of which variant the response carries.\n *\n * If the next invocation is bigger than the available\n * window, it's legal to send it anyway (letting the\n * window go negative) so the client doesn't block. Once\n * the window reaches 0 (or less) it's illegal to send\n * more requests until the next window update; sending\n * more invocations while the window is depleted can\n * result in a GO_AWAY error.\n *\n * Before the first WindowUpdate is received, the client\n * may assume an initial window of 32 KiB. This is the\n * smallest window the server will ever grant, so it's\n * always safe to start sending against it; every\n * WindowUpdate that follows can only grow the window\n * beyond that point.\n *\n * Only IngestionInvocation frames are counted against the window;\n * IngestionStart and IngestionDefaults frames are free and never\n * consume it.\n *\n * @generated from message dev.restate.ingress.ingestion.v1.WindowUpdate\n */\nexport type WindowUpdate =\n  Message<\"dev.restate.ingress.ingestion.v1.WindowUpdate\"> & {\n    /**\n     * @generated from field: uint32 increment_bytes = 1;\n     */\n    incrementBytes: number;\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.WindowUpdate.\n * Use `create(WindowUpdateSchema)` to create a new message.\n */\nexport const WindowUpdateSchema: GenMessage<WindowUpdate> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 4);\n\n/**\n * An error frame. It is always the last frame of the stream: whether the\n * error is stream-scoped or record-scoped, the server tears the stream down\n * right after sending it and processes no further messages.\n *\n * Record-scoped errors are the ones that carry `invocation_offset`: the\n * record at that offset was rejected (for example a missing key, an unknown\n * handler, or an internal ingestion failure) while the stream itself is\n * still well-formed. Stream-scoped errors leave `invocation_offset` unset\n * and describe a condition of the stream as a whole (shutdown, a protocol\n * violation, or invalid `Start`/`IngestionDefaults`).\n *\n * Even a record-scoped error terminates the stream, on purpose. Skipping the\n * faulty record and continuing would commit the records that follow it and\n * move the deduplication high water mark past the failed offset, making it\n * impossible to ever ingest that record afterwards. Terminating instead\n * keeps the high water mark where it is and leaves the decision to the\n * client.\n *\n * Recovery is therefore the client's responsibility: reconnect with the same\n * producer ID, resume from the `last_committed` reported on the response\n * that carried this error, and skip (or fix) the offending record before\n * resending the rest. Note that records after the failed offset may have\n * already been sent by the client but were not committed; they must be\n * resent.\n *\n * @generated from message dev.restate.ingress.ingestion.v1.Error\n */\nexport type Error = Message<\"dev.restate.ingress.ingestion.v1.Error\"> & {\n  /**\n   * if set, the error is associated\n   * with the invocation with that offset\n   *\n   * @generated from field: optional uint64 invocation_offset = 1;\n   */\n  invocationOffset?: bigint | undefined;\n\n  /**\n   * @generated from field: dev.restate.ingress.ingestion.v1.ErrorKind kind = 2;\n   */\n  kind: ErrorKind;\n\n  /**\n   * @generated from field: string message = 3;\n   */\n  message: string;\n};\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.Error.\n * Use `create(ErrorSchema)` to create a new message.\n */\nexport const ErrorSchema: GenMessage<Error> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 5);\n\n/**\n * @generated from message dev.restate.ingress.ingestion.v1.IngestionResponse\n */\nexport type IngestionResponse =\n  Message<\"dev.restate.ingress.ingestion.v1.IngestionResponse\"> & {\n    /**\n     * Acknowledgement. When set, every record up to and\n     * including this offset has been committed.\n     *\n     * It is set on every response that has something to ack,\n     * including responses carrying an Error, so a client whose\n     * stream is torn down can always resume from the offset on\n     * the last response it saw.\n     *\n     * It is unset only when nothing has been committed yet on\n     * this stream. The field must be optional because offsets\n     * are 0-based: \"offset 0 committed\" has to stay\n     * distinguishable from \"nothing committed\", which matters\n     * when an error is returned on the very first ingestion\n     * message.\n     *\n     * @generated from field: optional uint64 last_committed = 1;\n     */\n    lastCommitted?: bigint | undefined;\n\n    /**\n     * @generated from oneof dev.restate.ingress.ingestion.v1.IngestionResponse.response\n     */\n    response:\n      | {\n          /**\n           * @generated from field: dev.restate.ingress.ingestion.v1.WindowUpdate window_update = 2;\n           */\n          value: WindowUpdate;\n          case: \"windowUpdate\";\n        }\n      | {\n          /**\n           * @generated from field: dev.restate.ingress.ingestion.v1.Error error = 3;\n           */\n          value: Error;\n          case: \"error\";\n        }\n      | { case: undefined; value?: undefined };\n  };\n\n/**\n * Describes the message dev.restate.ingress.ingestion.v1.IngestionResponse.\n * Use `create(IngestionResponseSchema)` to create a new message.\n */\nexport const IngestionResponseSchema: GenMessage<IngestionResponse> =\n  /*@__PURE__*/\n  messageDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 6);\n\n/**\n * How the server deduplicates the records of a stream.\n *\n * The mode is fixed for the lifetime of the stream: it is chosen once in the\n * `Start` frame and cannot be changed by a later `IngestionDefaults` frame.\n *\n * Note that this only controls deduplication. Regardless of the mode, every\n * `Invocation` must still carry an `offset`, offsets must still increase\n * monotonically within a stream, and `Response.last_committed` still reports\n * progress in terms of those offsets.\n *\n * @generated from enum dev.restate.ingress.ingestion.v1.DeduplicationMode\n */\nexport enum DeduplicationMode {\n  /**\n   * Disable deduplication: every record accepted by the server becomes an\n   * invocation.\n   *\n   * Nothing is tracked across streams, so resending records after a\n   * reconnect duplicates them. Pick this mode only when the producer cannot\n   * supply a stable ID, or when duplicates are acceptable or already\n   * suppressed elsewhere (for example by an `idempotency_key`).\n   *\n   * `producer_id` is optional in this mode, but is still recorded on traces\n   * and metrics when set.\n   *\n   * @generated from enum value: DISABLED = 0;\n   */\n  DISABLED = 0,\n\n  /**\n   * Deduplicate on `(producer_id, offset)`.\n   *\n   * The server tracks the highest committed offset per producer ID and\n   * silently drops any record whose offset is not above it, which makes\n   * resending a range of records after a reconnect safe: records the server\n   * already committed do not become duplicate invocations.\n   *\n   * This mode requires `producer_id` to be set; using it with an empty\n   * producer ID fails the stream with `GO_AWAY`. It also requires the\n   * producer to reuse the same ID across streams, since a new ID starts\n   * from a fresh deduplication state.\n   *\n   * @generated from enum value: OFFSET_BASED = 1;\n   */\n  OFFSET_BASED = 1,\n}\n\n/**\n * Describes the enum dev.restate.ingress.ingestion.v1.DeduplicationMode.\n */\nexport const DeduplicationModeSchema: GenEnum<DeduplicationMode> =\n  /*@__PURE__*/\n  enumDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 0);\n\n/**\n * @generated from enum dev.restate.ingress.ingestion.v1.ErrorKind\n */\nexport enum ErrorKind {\n  /**\n   * @generated from enum value: ERROR_KIND_UNKNOWN = 0;\n   */\n  UNKNOWN = 0,\n\n  /**\n   * The server is shutting down and can't accept more\n   * records. The caller must switch to a new ingress\n   * node and respect the reported last_committed.\n   *\n   * @generated from enum value: ERROR_KIND_SHUTTING_DOWN = 1;\n   */\n  SHUTTING_DOWN = 1,\n\n  /**\n   * A protocol violation, for example sending another\n   * Start message after the initial one or not\n   * respecting the send window.\n   *\n   * @generated from enum value: ERROR_KIND_GO_AWAY = 2;\n   */\n  GO_AWAY = 2,\n\n  /**\n   * The invocation target was not found (unknown\n   * service or handler).\n   *\n   * @generated from enum value: ERROR_KIND_NOT_FOUND = 3;\n   */\n  NOT_FOUND = 3,\n\n  /**\n   * Covers a wide range of client errors, including:\n   * - unexpected key\n   * - missing key\n   * - invalid scope format\n   * and similar errors. The `Error.message` should\n   * carry more details.\n   *\n   * @generated from enum value: ERROR_KIND_BAD_REQUEST = 4;\n   */\n  BAD_REQUEST = 4,\n\n  /**\n   * The server can't process the request yet, for\n   * example because it has not loaded the schema.\n   * The caller should retry later (possibly on a\n   * different ingress node) without changing the\n   * request.\n   *\n   * @generated from enum value: ERROR_KIND_UNAVAILABLE = 5;\n   */\n  UNAVAILABLE = 5,\n}\n\n/**\n * Describes the enum dev.restate.ingress.ingestion.v1.ErrorKind.\n */\nexport const ErrorKindSchema: GenEnum<ErrorKind> =\n  /*@__PURE__*/\n  enumDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 1);\n\n/**\n * @generated from service dev.restate.ingress.ingestion.v1.IngestionSvc\n */\nexport const IngestionSvc: GenService<{\n  /**\n   * Opens a bidirectional node-to-node stream.\n   *\n   * @generated from rpc dev.restate.ingress.ingestion.v1.IngestionSvc.Ingest\n   */\n  ingest: {\n    methodKind: \"bidi_streaming\";\n    input: typeof IngestionRequestSchema;\n    output: typeof IngestionResponseSchema;\n  };\n}> =\n  /*@__PURE__*/\n  serviceDesc(file_dev_restate_ingress_ingestion_v1_ingestion_svc, 0);\n"],"mappings":";;;;;;AA8BA,MAAaA,sDAEX,yBACE,y7FACD;;;;;AAmJH,MAAaC,0BAEX,4BAAY,qDAAqD,EAAE;;;;;AA6GrE,MAAaC,4BAEX,4BAAY,qDAAqD,EAAE;;;;;AAuCrE,MAAaC,yBAEX,4BAAY,qDAAqD,EAAE;;;;;;;;;;;;;;AA4KrE,IAAY,kEAAL;;;;;;;;;;;;;;;AAeL;;;;;;;;;;;;;;;;AAiBA;;;;;;AAaF,IAAY,kDAAL;;;;AAIL;;;;;;;;AASA;;;;;;;;AASA;;;;;;;AAQA;;;;;;;;;;;AAYA;;;;;;;;;;AAWA;;;;;;AAaF,MAAaC,eAaX,4BAAY,qDAAqD,EAAE"}

package/dist/index.cjs

@@ -0,0 +1,5 @@
+const require_errors = require('./errors.cjs');
+const require_client = require('./client.cjs');
+
+exports.IntegrationClientError = require_errors.IntegrationClientError;
+exports.connect = require_client.connect;

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+import { ExactlyOnceInvocation, ExactlyOnceProducer, IntegrationClient, IntegrationClientOptions, Invocation, InvocationDefaults, Producer, ProducerBase, ProducerOptions, SendOptions } from "./api.cjs";
+import { connect } from "./client.cjs";
+import { IntegrationClientError, IntegrationClientErrorKind } from "./errors.cjs";
+export { type ExactlyOnceInvocation, type ExactlyOnceProducer, type IntegrationClient, IntegrationClientError, type IntegrationClientErrorKind, type IntegrationClientOptions, type Invocation, type InvocationDefaults, type Producer, type ProducerBase, type ProducerOptions, type SendOptions, connect };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { ExactlyOnceInvocation, ExactlyOnceProducer, IntegrationClient, IntegrationClientOptions, Invocation, InvocationDefaults, Producer, ProducerBase, ProducerOptions, SendOptions } from "./api.js";
+import { connect } from "./client.js";
+import { IntegrationClientError, IntegrationClientErrorKind } from "./errors.js";
+export { type ExactlyOnceInvocation, type ExactlyOnceProducer, type IntegrationClient, IntegrationClientError, type IntegrationClientErrorKind, type IntegrationClientOptions, type Invocation, type InvocationDefaults, type Producer, type ProducerBase, type ProducerOptions, type SendOptions, connect };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { IntegrationClientError } from "./errors.js";
+import { connect } from "./client.js";
+
+export { IntegrationClientError, connect };

package/dist/package.cjs

@@ -0,0 +1,11 @@
+
+//#region package.json
+var version = "1.18.0";
+
+//#endregion
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});

package/dist/package.js

@@ -0,0 +1,6 @@
+//#region package.json
+var version = "1.18.0";
+
+//#endregion
+export { version };
+//# sourceMappingURL=package.js.map

package/dist/package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.js","names":[],"sources":["../package.json"],"sourcesContent":["{\n  \"name\": \"@restatedev/restate-sdk-integration-client\",\n  \"version\": \"1.18.0\",\n  \"description\": \"Client for the Restate ingress integration (ingestion) API\",\n  \"author\": \"Restate Developers\",\n  \"email\": \"code@restate.dev\",\n  \"license\": \"MIT\",\n  \"homepage\": \"https://github.com/restatedev/sdk-typescript#readme\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/restatedev/sdk-typescript.git\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/restatedev/sdk-typescript/issues\"\n  },\n  \"type\": \"module\",\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.cts\",\n  \"exports\": {\n    \".\": {\n      \"import\": \"./dist/index.js\",\n      \"require\": \"./dist/index.cjs\"\n    },\n    \"./package.json\": \"./package.json\"\n  },\n  \"files\": [\n    \"dist\",\n    \"README.md\"\n  ],\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"scripts\": {\n    \"test\": \"turbo run _test --filter={.}...\",\n    \"_test\": \"vitest run\",\n    \"test:e2e\": \"vitest run --config vitest.e2e.config.ts\",\n    \"generate:proto\": \"buf generate\",\n    \"build\": \"turbo run _build --filter={.}...\",\n    \"_build\": \"tsc --noEmit && tsdown\",\n    \"dev\": \"tsc --noEmit --watch\",\n    \"clean\": \"rm -rf dist *.tsbuildinfo .turbo\",\n    \"check:types\": \"turbo run _check:types --filter={.}...\",\n    \"_check:types\": \"tsc --noEmit --project tsconfig.build.json\",\n    \"lint\": \"eslint .\",\n    \"check:exports\": \"turbo run _check:exports --filter={.}...\",\n    \"_check:exports\": \"attw --pack .\",\n    \"check:api\": \"turbo run _check:api --filter={.}...\",\n    \"_check:api\": \"api-extractor run --local\"\n  },\n  \"dependencies\": {\n    \"@bufbuild/protobuf\": \"^2.16.0\",\n    \"@connectrpc/connect\": \"^2.2.0\",\n    \"@connectrpc/connect-node\": \"^2.2.0\"\n  },\n  \"devDependencies\": {\n    \"@bufbuild/buf\": \"1.75.0\",\n    \"@bufbuild/protoc-gen-es\": \"^2.16.0\",\n    \"@restatedev/restate-sdk\": \"workspace:*\",\n    \"@restatedev/restate-sdk-clients\": \"workspace:*\",\n    \"@restatedev/restate-sdk-testcontainers\": \"workspace:*\",\n    \"testcontainers\": \"^11.13.0\"\n  }\n}\n"],"mappings":";cAEa"}

package/dist/producer.cjs

@@ -0,0 +1,245 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_ingestion_svc_pb = require('./generated/dev/restate/ingress/ingestion/v1/ingestion_svc_pb.cjs');
+const require_errors = require('./errors.cjs');
+const require_proto = require('./proto.cjs');
+const require_queue = require('./queue.cjs');
+let __bufbuild_protobuf = require("@bufbuild/protobuf");
+__bufbuild_protobuf = require_rolldown_runtime.__toESM(__bufbuild_protobuf);
+
+//#region src/producer.ts
+const INITIAL_WINDOW_BYTES = 32 * 1024;
+const DEFAULT_BUFFER_BYTES = 32 * 1024 * 1024;
+/**
+* Owns one ingestion stream.
+*
+* A record goes from `send` to the admission queue, where it waits in FIFO order while the
+* buffer is full, then to the buffer, then to the request generator that Connect consumes. Connect
+* pulls the next request only once HTTP/2 has accepted the previous one, and the buffer hands a
+* record to the generator only while the Restate window has credit, so both transport and Restate
+* backpressure propagate back to `send`.
+*/
+var ProducerImpl = class {
+	#producerId;
+	#exactlyOnce;
+	#bufferBytes;
+	#onCommitted;
+	#call = new AbortController();
+	#responsesDone;
+	#admission = new require_queue.Queue();
+	#buffer = new require_queue.Queue();
+	#bufferedBytes = 0;
+	#commitWaiters = new require_queue.Queue();
+	#budget = INITIAL_WINDOW_BYTES;
+	#lastSent = -1;
+	#lastCommitted = -1;
+	#pull;
+	#requestsEnded = false;
+	#closing;
+	#failed = false;
+	#failure;
+	#writable;
+	#writableController;
+	constructor(config) {
+		const bufferBytes = config.options.bufferBytes ?? DEFAULT_BUFFER_BYTES;
+		if (!Number.isSafeInteger(bufferBytes) || bufferBytes < 0) throw new RangeError(`bufferBytes must be a non-negative integer, got ${bufferBytes}`);
+		this.#producerId = config.producerId;
+		this.#exactlyOnce = config.exactlyOnce;
+		this.#bufferBytes = bufferBytes;
+		this.#onCommitted = config.options.onCommitted;
+		const start = (0, __bufbuild_protobuf.create)(require_ingestion_svc_pb.IngestionRequestSchema, { kind: {
+			case: "start",
+			value: {
+				producerId: config.producerId,
+				integration: config.integration,
+				deduplicationMode: config.exactlyOnce ? require_ingestion_svc_pb.DeduplicationMode.OFFSET_BASED : require_ingestion_svc_pb.DeduplicationMode.DISABLED,
+				defaults: config.options.defaults !== void 0 ? require_proto.toProtoDefaults(config.options.defaults) : void 0
+			}
+		} });
+		const responses = config.rpc.ingest(this.#requests(start), {
+			signal: this.#call.signal,
+			headers: config.headers
+		});
+		this.#responsesDone = this.#readResponses(responses);
+	}
+	get producerId() {
+		return this.#producerId;
+	}
+	send(record, opts) {
+		if (this.#failed) return Promise.reject(this.#failure);
+		if (this.#closing !== void 0) return Promise.reject(/* @__PURE__ */ new Error("The producer is closed"));
+		let offset;
+		if (this.#exactlyOnce) {
+			offset = record.offset;
+			if (!Number.isSafeInteger(offset) || offset < 0) return Promise.reject(/* @__PURE__ */ new RangeError(`offset must be a non-negative safe integer, got ${offset}`));
+			if (offset <= this.#lastSent) return Promise.reject(/* @__PURE__ */ new RangeError(`offset must be strictly increasing: last sent ${this.#lastSent}, got ${offset}`));
+		} else {
+			offset = this.#lastSent + 1;
+			if (!Number.isSafeInteger(offset)) return Promise.reject(/* @__PURE__ */ new RangeError("The producer offset sequence is exhausted"));
+		}
+		let pending;
+		try {
+			const invocation = require_proto.toProtoInvocation(record, offset);
+			pending = {
+				offset,
+				size: (0, __bufbuild_protobuf.toBinary)(require_ingestion_svc_pb.IngestionInvocationSchema, invocation).byteLength,
+				request: (0, __bufbuild_protobuf.create)(require_ingestion_svc_pb.IngestionRequestSchema, { kind: {
+					case: "invocation",
+					value: invocation
+				} })
+			};
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		if (this.#bufferBytes > 0 && pending.size > this.#bufferBytes) return Promise.reject(/* @__PURE__ */ new RangeError(`The serialized record takes ${pending.size} bytes, more than bufferBytes (${this.#bufferBytes})`));
+		this.#lastSent = offset;
+		const accepted = new Promise((resolve, reject) => {
+			this.#admission.push({
+				record: pending,
+				resolve,
+				reject
+			});
+		});
+		this.#drive();
+		if (opts?.waitCommitted !== true) return accepted;
+		return Promise.all([accepted, this.#committed(offset)]).then(() => offset);
+	}
+	flush() {
+		return this.#committed(this.#lastSent);
+	}
+	close() {
+		this.#closing ??= this.#close();
+		return this.#closing;
+	}
+	abort(reason) {
+		this.#fail(reason ?? new require_errors.IntegrationClientError("unknown", "The producer was aborted"));
+	}
+	get writable() {
+		this.#writable ??= new WritableStream({
+			start: (controller) => {
+				this.#writableController = controller;
+				if (this.#failed) controller.error(this.#failure);
+			},
+			write: async (record) => {
+				await this.send(record);
+			},
+			close: () => this.close(),
+			abort: (reason) => this.abort(reason)
+		});
+		return this.#writable;
+	}
+	async #close() {
+		if (this.#failed) throw this.#failure;
+		await this.flush();
+		this.#requestsEnded = true;
+		this.#drive();
+		await this.#responsesDone;
+		if (this.#failed) throw this.#failure;
+	}
+	async *#requests(start) {
+		yield start;
+		for (;;) {
+			const request = await new Promise((resolve) => {
+				this.#pull = resolve;
+				this.#drive();
+			});
+			if (request === void 0) return;
+			yield request;
+		}
+	}
+	/** Moves records along: hands the buffer head to the waiting generator, admits waiting sends. */
+	#drive() {
+		for (;;) {
+			if (this.#pull !== void 0) {
+				if (this.#failed || this.#requestsEnded && this.#buffer.length === 0) {
+					this.#takePull()(void 0);
+					return;
+				}
+				if (this.#budget > 0) {
+					const record = this.#buffer.shift();
+					if (record !== void 0) {
+						this.#bufferedBytes -= record.size;
+						this.#budget -= record.size;
+						this.#takePull()(record.request);
+						continue;
+					}
+				}
+			}
+			const waiter = this.#admission.peek();
+			if (waiter === void 0 || !this.#canAdmit(waiter.record.size)) return;
+			this.#admission.shift();
+			this.#buffer.push(waiter.record);
+			this.#bufferedBytes += waiter.record.size;
+			waiter.resolve(waiter.record.offset);
+		}
+	}
+	#canAdmit(size) {
+		if (this.#failed) return false;
+		if (this.#bufferBytes === 0) return this.#pull !== void 0 && this.#budget > 0 && this.#buffer.length === 0;
+		return this.#bufferedBytes + size <= this.#bufferBytes;
+	}
+	#takePull() {
+		const pull = this.#pull;
+		this.#pull = void 0;
+		return pull;
+	}
+	#committed(offset) {
+		if (offset <= this.#lastCommitted) return Promise.resolve(this.#lastCommitted);
+		if (this.#failed) return Promise.reject(this.#failure);
+		return new Promise((resolve, reject) => {
+			this.#commitWaiters.push({
+				offset,
+				resolve,
+				reject
+			});
+		});
+	}
+	async #readResponses(responses) {
+		try {
+			for await (const response of responses) {
+				if (response.lastCommitted !== void 0) this.#advanceCommitted(require_errors.toSafeNumber(response.lastCommitted));
+				if (this.#failed) return;
+				if (response.response.case === "windowUpdate") {
+					this.#budget += response.response.value.incrementBytes;
+					this.#drive();
+				} else if (response.response.case === "error") {
+					this.#fail(require_errors.errorFromProto(response.response.value));
+					return;
+				}
+			}
+			if (!this.#requestsEnded) this.#fail(new require_errors.IntegrationClientError("unknown", "The ingestion stream was closed by the server"));
+		} catch (e) {
+			this.#fail(new require_errors.IntegrationClientError("unknown", `The ingestion stream failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e }));
+		}
+	}
+	#advanceCommitted(watermark) {
+		if (watermark <= this.#lastCommitted) return;
+		this.#lastCommitted = watermark;
+		for (let waiter = this.#commitWaiters.peek(); waiter !== void 0 && waiter.offset <= watermark; waiter = this.#commitWaiters.peek()) {
+			this.#commitWaiters.shift();
+			waiter.resolve(watermark);
+		}
+		if (this.#onCommitted !== void 0) try {
+			this.#onCommitted(watermark);
+		} catch (e) {
+			this.#fail(e);
+		}
+	}
+	/** Makes the producer terminally failed: cancels the stream and rejects everything pending. */
+	#fail(reason) {
+		if (this.#failed) return;
+		this.#failed = true;
+		this.#failure = reason;
+		this.#buffer.drain();
+		this.#bufferedBytes = 0;
+		const admission = this.#admission.drain();
+		const commits = this.#commitWaiters.drain();
+		if (this.#pull !== void 0) this.#takePull()(void 0);
+		this.#call.abort(reason);
+		this.#writableController?.error(reason);
+		for (const waiter of admission) waiter.reject(reason);
+		for (const waiter of commits) waiter.reject(reason);
+	}
+};
+
+//#endregion
+exports.ProducerImpl = ProducerImpl;