@clowder-ai/plugin-contract 0.1.0-beta.9 → 0.3.0

package/dist/wire/messaging-byte-bounds.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Derived compact-JSON byte bounds for the beta.11 M0-C messaging rows.
+ *
+ * Structural maxima are built from the closed public grammar and measured as
+ * compact UTF-8 JSON. Read and snapshot results are intentionally different:
+ * their legal structural maxima can exceed one frame, so their published
+ * bound is the final-frame assembler budget rather than a fictional
+ * structural maximum.
+ */
+import type { AppendElementsRequest, AppendReceipt, SendReceipt } from '../generated/contract.generated.js';
+import type { DeliverInput, DeliverResult, MediaReadInput, MediaReadResult, MessagingAckRequest, MessagingAckResult, ReadInput, SendInput, SnapshotInput, SubscribeInput, SubscribeResult } from './row-shapes.js';
+import type { MessagingRowMethod } from '../validation/messaging-wire.js';
+export declare const MESSAGING_BYTE_PROOF_ENCODING_FAMILIES: readonly ["ascii", "multibyte", "escaping"];
+export type MessagingByteProofEncodingFamily = (typeof MESSAGING_BYTE_PROOF_ENCODING_FAMILIES)[number];
+export type MessagingByteProofBasis = 'structural-maximum' | 'assembler-budget';
+export interface MessagingNPlusOneByteProof {
+    readonly leaf: string;
+    readonly encodedBytes: number;
+    readonly fitsFrame: boolean;
+}
+export interface MessagingEncodedByteProofCase {
+    readonly family: MessagingByteProofEncodingFamily;
+    readonly encodedBytes: number;
+    readonly fitsFrame: boolean;
+    readonly nPlusOne: readonly MessagingNPlusOneByteProof[];
+}
+export interface MessagingEncodedByteProof {
+    readonly basis: MessagingByteProofBasis;
+    readonly maxEncodedBytes: number;
+    readonly cases: readonly MessagingEncodedByteProofCase[];
+}
+export interface MessagingRowEncodedByteBounds {
+    readonly maxEncodedRequestBytes: number;
+    readonly maxEncodedResultBytes: number;
+    readonly maxEncodedErrorBytes: number;
+}
+export interface MessagingNPlusOneInputWitness {
+    readonly leaf: string;
+    readonly input: unknown;
+}
+export interface MessagingNPlusOneResultWitness {
+    readonly leaf: string;
+    readonly result: unknown;
+}
+export declare function messagingMaximumRequestInput(method: MessagingRowMethod, family: MessagingByteProofEncodingFamily): SendInput | AppendElementsRequest | SubscribeInput | ReadInput | MessagingAckRequest | SnapshotInput | DeliverInput | MediaReadInput;
+export declare function messagingMaximumResult(method: Exclude<MessagingRowMethod, 'messaging.read' | 'messaging.snapshot'>, family: MessagingByteProofEncodingFamily): SendReceipt | AppendReceipt | SubscribeResult | MessagingAckResult | DeliverResult | MediaReadResult;
+export declare function messagingRequestNPlusOneInputs(method: MessagingRowMethod, family: MessagingByteProofEncodingFamily): readonly MessagingNPlusOneInputWitness[];
+export declare function messagingResultNPlusOneInputs(method: Exclude<MessagingRowMethod, 'messaging.read' | 'messaging.snapshot'>, family: MessagingByteProofEncodingFamily): readonly MessagingNPlusOneResultWitness[];
+export declare const MESSAGING_REQUEST_BYTE_PROOFS: Readonly<Record<MessagingRowMethod, MessagingEncodedByteProof>>;
+export declare const MESSAGING_RESULT_BYTE_PROOFS: {
+    readonly 'messaging.send': MessagingEncodedByteProof;
+    readonly 'messaging.appendElements': MessagingEncodedByteProof;
+    readonly 'messaging.subscribe': MessagingEncodedByteProof;
+    readonly 'messaging.read': MessagingEncodedByteProof;
+    readonly 'messaging.ack': MessagingEncodedByteProof;
+    readonly 'messaging.snapshot': MessagingEncodedByteProof;
+    readonly 'streams.read': MessagingEncodedByteProof;
+    readonly 'host.messaging.deliver': MessagingEncodedByteProof;
+};
+export declare const MESSAGING_ERROR_BYTE_PROOFS: Readonly<Record<MessagingRowMethod, MessagingEncodedByteProof>>;
+export declare const MESSAGING_ROW_ENCODED_BYTE_BOUNDS: Readonly<Record<MessagingRowMethod, MessagingRowEncodedByteBounds>>;
+//# sourceMappingURL=messaging-byte-bounds.d.ts.map

package/dist/wire/messaging-byte-bounds.d.ts.map

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

package/dist/wire/messaging-byte-bounds.js

@@ -0,0 +1,581 @@
+/**
+ * Derived compact-JSON byte bounds for the beta.11 M0-C messaging rows.
+ *
+ * Structural maxima are built from the closed public grammar and measured as
+ * compact UTF-8 JSON. Read and snapshot results are intentionally different:
+ * their legal structural maxima can exceed one frame, so their published
+ * bound is the final-frame assembler budget rather than a fictional
+ * structural maximum.
+ */
+import { MAX_ELEMENT_PAYLOAD_BYTES, MAX_ELEMENTS_PER_MESSAGE, MAX_ELEMENTS_PER_OPERATION, MAX_FRAME_BYTES, MAX_TOTAL_PAYLOAD_BYTES, MAX_WHISPER_TARGETS, } from './constants.js';
+import { DEADLINE_EXPIRED_CODE, DEADLINE_EXPIRED_MESSAGE, DELIVERY_REJECTED_CODE, DELIVERY_REJECTED_MESSAGE, DELIVERY_REJECT_REASONS, LIFECYCLE_REJECT_REASONS, DOMAIN_ERROR_CODE, DOMAIN_ERROR_MESSAGE, ERROR_CODE_TO_MESSAGE, INVALID_REQUEST_CODE, PARSE_ERROR_CODE, SNAPSHOT_UNAVAILABLE_CODE, SNAPSHOT_UNAVAILABLE_MESSAGE, SNAPSHOT_UNAVAILABLE_REASONS, STANDARD_ERROR_CODES, } from './errors.js';
+import { REQUEST_ID_MAX_LENGTH } from './request-id.js';
+import { WIRE_UINT53_MAX } from './wire-uint53.js';
+export const MESSAGING_BYTE_PROOF_ENCODING_FAMILIES = [
+    'ascii',
+    'multibyte',
+    'escaping',
+];
+const MAX_REQUEST_ID = 'a'.repeat(REQUEST_ID_MAX_LENGTH);
+const ESCAPING_SCALARS = [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x0b, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
+];
+function byteLength(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+function familyScalar(family, salt = 0) {
+    switch (family) {
+        case 'ascii':
+            return String.fromCodePoint(0x61 + (salt % 26));
+        case 'multibyte':
+            return String.fromCodePoint(0x1f408 + (salt % 16));
+        case 'escaping':
+            return String.fromCodePoint(ESCAPING_SCALARS[salt % ESCAPING_SCALARS.length]);
+    }
+}
+function maximumString(family, length, salt = 0) {
+    if (length === 0)
+        return '';
+    return `${familyScalar(family).repeat(length - 1)}${familyScalar(family, salt)}`;
+}
+function exactPayload(family, targetBytes) {
+    const scalar = familyScalar(family);
+    const empty = { id: 'proof', kind: 'proof', v: 1, data: '', pad: '' };
+    const staticBytes = byteLength(empty);
+    const unitBytes = byteLength({ ...empty, data: scalar }) - staticBytes;
+    const repetitions = Math.floor((targetBytes - staticBytes) / unitBytes);
+    const data = scalar.repeat(repetitions);
+    const usedBytes = byteLength({ ...empty, data });
+    const payload = { ...empty, data, pad: 'a'.repeat(targetBytes - usedBytes) };
+    if (byteLength(payload) !== targetBytes) {
+        throw new Error(`failed to construct exact ${targetBytes}-byte messaging payload`);
+    }
+    return payload;
+}
+function maximumElements(family, count, totalPayloadBytes = MAX_TOTAL_PAYLOAD_BYTES) {
+    if (totalPayloadBytes % count !== 0) {
+        throw new Error('messaging proof payload budget must divide evenly across elements');
+    }
+    const payloadBytes = totalPayloadBytes / count;
+    return Array.from({ length: count }, (_, index) => ({
+        elementId: maximumString(family, 128, index),
+        kind: 'rich_block',
+        payload: exactPayload(family, payloadBytes),
+        derivedFromElementId: maximumString(family, 128, index + count),
+        epistemicStatus: 'observation',
+    }));
+}
+function maximumAudience(family) {
+    return {
+        kind: 'whisper',
+        targets: Array.from({ length: MAX_WHISPER_TARGETS }, (_, index) => maximumString(family, 256, index)),
+    };
+}
+function maximumOrigin(family) {
+    return {
+        kind: 'external',
+        connectorId: maximumString(family, 256, 1),
+        sourceAddress: {
+            connectorId: maximumString(family, 256, 2),
+            chatId: maximumString(family, 512, 3),
+            messageId: maximumString(family, 512, 4),
+        },
+    };
+}
+function maximumDraft(family) {
+    return {
+        address: {
+            kind: 'connector_binding',
+            handle: maximumString(family, 256, 5),
+        },
+        draftAudience: maximumAudience(family),
+        idempotencyKey: maximumString(family, 200, 6),
+        sourceEventId: maximumString(family, 512, 7),
+        replyTo: maximumString(family, 256, 8),
+        payload: {
+            provenance: {
+                origin: maximumOrigin(family),
+                epistemicStatus: 'observation',
+            },
+            elements: maximumElements(family, MAX_ELEMENTS_PER_OPERATION),
+            correlationId: maximumString(family, 256, 9),
+            causationId: maximumString(family, 256, 10),
+        },
+    };
+}
+function maximumEnvelope(family) {
+    return {
+        messageId: maximumString(family, 512, 1),
+        revision: WIRE_UINT53_MAX,
+        threadId: maximumString(family, 512, 2),
+        replyTo: maximumString(family, 256, 3),
+        actor: { kind: 'system', id: maximumString(family, 512, 4) },
+        audience: maximumAudience(family),
+        occurredAt: '+010000-01-01T00:00:00.000Z',
+        payload: {
+            provenance: {
+                origin: maximumOrigin(family),
+                epistemicStatus: 'observation',
+            },
+            elements: maximumElements(family, MAX_ELEMENTS_PER_MESSAGE),
+            correlationId: maximumString(family, 256, 5),
+            causationId: maximumString(family, 256, 6),
+        },
+    };
+}
+function maximumFrontendDisplayUrl(length = 2048) {
+    const prefix = 'https://example.invalid/';
+    return `${prefix}${'a'.repeat(length - prefix.length)}`;
+}
+function maximumPresentation(family, salt = 0) {
+    return {
+        actor: {
+            displayName: maximumString(family, 256, salt + 1),
+            emoji: maximumString(family, 32, salt + 2),
+        },
+        thread: {
+            shortId: maximumString(family, 128, salt + 3),
+            title: maximumString(family, 512, salt + 4),
+            featId: maximumString(family, 128, salt + 5),
+        },
+        deepLinkUrl: maximumFrontendDisplayUrl(),
+    };
+}
+function requestFrame(method, input, requestId = MAX_REQUEST_ID) {
+    return {
+        jsonrpc: '2.0',
+        id: requestId,
+        method,
+        params: { meta: { deadlineUnixMs: WIRE_UINT53_MAX }, input },
+    };
+}
+function resultFrame(result, requestId = MAX_REQUEST_ID) {
+    return { jsonrpc: '2.0', id: requestId, result };
+}
+export function messagingMaximumRequestInput(method, family) {
+    switch (method) {
+        case 'messaging.send':
+            return maximumDraft(family);
+        case 'messaging.appendElements':
+            return {
+                handle: { kind: 'message', token: maximumString(family, 512, 1) },
+                operationId: maximumString(family, 200, 2),
+                baseRevision: WIRE_UINT53_MAX,
+                elements: maximumElements(family, MAX_ELEMENTS_PER_OPERATION),
+            };
+        case 'messaging.subscribe':
+            return { handle: maximumString(family, 256, 1) };
+        case 'messaging.read':
+            return { subscriptionId: maximumString(family, 128, 1), limit: 32 };
+        case 'messaging.ack':
+            return {
+                subscriptionId: maximumString(family, 128, 1),
+                ackToken: maximumString(family, 512, 2),
+            };
+        case 'messaging.snapshot':
+            return {
+                subscriptionId: maximumString(family, 128, 1),
+                maxItems: 64,
+                pageToken: maximumString(family, 512, 2),
+            };
+        case 'streams.read':
+            return {
+                reference: `hmr_${maximumString(family, 2044, 1)}`,
+                offset: WIRE_UINT53_MAX,
+                limit: 524_288,
+            };
+        case 'host.messaging.deliver':
+            return {
+                deliveryId: maximumString(family, 128, 1),
+                kind: 'message',
+                executionId: maximumString(family, 128, 2),
+                threadId: maximumEnvelope(family).threadId,
+                envelope: maximumEnvelope(family),
+                presentation: maximumPresentation(family, 3),
+            };
+    }
+}
+export function messagingMaximumResult(method, family) {
+    switch (method) {
+        case 'messaging.send':
+            return {
+                messageId: maximumString(family, 512, 1),
+                threadId: maximumString(family, 512, 2),
+                revision: WIRE_UINT53_MAX,
+                messageHandle: { kind: 'message', token: maximumString(family, 512, 3) },
+                publishSequence: WIRE_UINT53_MAX,
+            };
+        case 'messaging.appendElements':
+            return {
+                messageId: maximumString(family, 512, 1),
+                revision: WIRE_UINT53_MAX,
+                appendSequence: WIRE_UINT53_MAX,
+                appliedElementIds: Array.from({ length: MAX_ELEMENTS_PER_OPERATION }, (_, index) => maximumString(family, 128, index)),
+            };
+        case 'messaging.subscribe':
+            return { subscriptionId: maximumString(family, 128, 1) };
+        case 'messaging.ack':
+            return null;
+        case 'streams.read':
+            return {
+                offset: WIRE_UINT53_MAX,
+                dataBase64: 'A'.repeat(699_048),
+                done: true,
+            };
+        case 'host.messaging.deliver':
+            return { deliveryId: maximumString(family, 128, 1) };
+    }
+}
+function payloadNPlusOneDraft(family, aggregate) {
+    const draft = maximumDraft(family);
+    const elements = aggregate
+        ? Array.from({ length: 5 }, (_, index) => ({
+            elementId: maximumString(family, 128, index),
+            kind: 'rich_block',
+            payload: exactPayload(family, index === 4 ? 64 : MAX_ELEMENT_PAYLOAD_BYTES),
+        }))
+        : [{
+                elementId: maximumString(family, 128),
+                kind: 'rich_block',
+                payload: exactPayload(family, MAX_ELEMENT_PAYLOAD_BYTES + 1),
+            }];
+    return { ...draft, payload: { ...draft.payload, elements } };
+}
+export function messagingRequestNPlusOneInputs(method, family) {
+    switch (method) {
+        case 'messaging.send': {
+            const maximum = maximumDraft(family);
+            return [
+                { leaf: 'idempotencyKey', input: { ...maximum, idempotencyKey: maximumString(family, 201) } },
+                { leaf: 'payloadBytes', input: payloadNPlusOneDraft(family, false) },
+                { leaf: 'aggregatePayloadBytes', input: payloadNPlusOneDraft(family, true) },
+            ];
+        }
+        case 'messaging.appendElements': {
+            const maximum = messagingMaximumRequestInput(method, family);
+            return [
+                { leaf: 'operationId', input: { ...maximum, operationId: maximumString(family, 201) } },
+                {
+                    leaf: 'payloadBytes',
+                    input: {
+                        ...maximum,
+                        elements: [{
+                                elementId: maximumString(family, 128),
+                                kind: 'rich_block',
+                                payload: exactPayload(family, MAX_ELEMENT_PAYLOAD_BYTES + 1),
+                            }],
+                    },
+                },
+            ];
+        }
+        case 'messaging.subscribe':
+            return [{ leaf: 'handle', input: { handle: maximumString(family, 257) } }];
+        case 'messaging.read':
+            return [
+                { leaf: 'subscriptionId', input: { subscriptionId: maximumString(family, 129), limit: 32 } },
+                { leaf: 'limit', input: { subscriptionId: maximumString(family, 128), limit: 33 } },
+            ];
+        case 'messaging.ack':
+            return [
+                { leaf: 'subscriptionId', input: { subscriptionId: maximumString(family, 129), ackToken: 'a' } },
+                { leaf: 'ackToken', input: { subscriptionId: 'a', ackToken: maximumString(family, 513) } },
+            ];
+        case 'messaging.snapshot':
+            return [
+                { leaf: 'subscriptionId', input: { subscriptionId: maximumString(family, 129), maxItems: 64 } },
+                { leaf: 'maxItems', input: { subscriptionId: 'a', maxItems: 65 } },
+                { leaf: 'pageToken', input: { subscriptionId: 'a', maxItems: 64, pageToken: maximumString(family, 513) } },
+            ];
+        case 'streams.read':
+            return [
+                { leaf: 'reference', input: { reference: `hmr_${maximumString(family, 2045)}`, offset: 0, limit: 1 } },
+                { leaf: 'limit', input: { reference: 'hmr_a', offset: 0, limit: 524_289 } },
+            ];
+        case 'host.messaging.deliver': {
+            const maximum = messagingMaximumRequestInput(method, family);
+            if (maximum.kind !== 'message')
+                throw new Error('message arm supplies the delivery byte maximum');
+            return [
+                { leaf: 'deliveryId', input: { ...maximum, deliveryId: maximumString(family, 129) } },
+                { leaf: 'executionId', input: { ...maximum, executionId: maximumString(family, 129) } },
+                {
+                    leaf: 'threadId',
+                    input: {
+                        ...maximum,
+                        threadId: maximumString(family, 513),
+                    },
+                },
+                {
+                    leaf: 'presentation.actor.displayName',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            actor: {
+                                ...maximum.presentation.actor,
+                                displayName: maximumString(family, 257),
+                            },
+                        },
+                    },
+                },
+                {
+                    leaf: 'presentation.actor.emoji',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            actor: {
+                                ...maximum.presentation.actor,
+                                emoji: maximumString(family, 33),
+                            },
+                        },
+                    },
+                },
+                {
+                    leaf: 'presentation.thread.shortId',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            thread: {
+                                ...maximum.presentation.thread,
+                                shortId: maximumString(family, 129),
+                            },
+                        },
+                    },
+                },
+                {
+                    leaf: 'presentation.thread.title',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            thread: {
+                                ...maximum.presentation.thread,
+                                title: maximumString(family, 513),
+                            },
+                        },
+                    },
+                },
+                {
+                    leaf: 'presentation.thread.featId',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            thread: {
+                                ...maximum.presentation.thread,
+                                featId: maximumString(family, 129),
+                            },
+                        },
+                    },
+                },
+                {
+                    leaf: 'presentation.deepLinkUrl',
+                    input: {
+                        ...maximum,
+                        presentation: {
+                            ...maximum.presentation,
+                            deepLinkUrl: maximumFrontendDisplayUrl(2049),
+                        },
+                    },
+                },
+            ];
+        }
+    }
+}
+export function messagingResultNPlusOneInputs(method, family) {
+    const maximum = messagingMaximumResult(method, family);
+    switch (method) {
+        case 'messaging.send':
+            return [{ leaf: 'messageId', result: { ...maximum, messageId: maximumString(family, 513) } }];
+        case 'messaging.appendElements':
+            return [{
+                    leaf: 'appliedElementIds',
+                    result: {
+                        ...maximum,
+                        appliedElementIds: Array.from({ length: 33 }, (_, index) => maximumString(family, 128, index)),
+                    },
+                }];
+        case 'messaging.subscribe':
+            return [{ leaf: 'subscriptionId', result: { subscriptionId: maximumString(family, 129) } }];
+        case 'messaging.ack':
+            return [];
+        case 'streams.read':
+            return [{
+                    leaf: 'dataBase64',
+                    result: { offset: 0, dataBase64: 'A'.repeat(699_053), done: true },
+                }];
+        case 'host.messaging.deliver':
+            return [{ leaf: 'deliveryId', result: { deliveryId: maximumString(family, 129) } }];
+    }
+}
+function structuralProof(maximumFrames, nPlusOneFrames) {
+    const cases = MESSAGING_BYTE_PROOF_ENCODING_FAMILIES.map((family) => {
+        const encodedBytes = byteLength(maximumFrames(family));
+        return {
+            family,
+            encodedBytes,
+            fitsFrame: encodedBytes <= MAX_FRAME_BYTES,
+            nPlusOne: nPlusOneFrames(family).map(({ leaf, frame }) => {
+                const witnessBytes = byteLength(frame);
+                return { leaf, encodedBytes: witnessBytes, fitsFrame: witnessBytes <= MAX_FRAME_BYTES };
+            }),
+        };
+    });
+    return {
+        basis: 'structural-maximum',
+        maxEncodedBytes: Math.max(...cases.map(({ encodedBytes }) => encodedBytes)),
+        cases,
+    };
+}
+function assemblerBudgetProof() {
+    return {
+        basis: 'assembler-budget',
+        maxEncodedBytes: MAX_FRAME_BYTES,
+        cases: MESSAGING_BYTE_PROOF_ENCODING_FAMILIES.map((family) => ({
+            family,
+            encodedBytes: MAX_FRAME_BYTES,
+            fitsFrame: true,
+            nPlusOne: [{
+                    leaf: 'frameBytes',
+                    encodedBytes: MAX_FRAME_BYTES + 1,
+                    fitsFrame: false,
+                }],
+        })),
+    };
+}
+function requestProof(method) {
+    return structuralProof(family => requestFrame(method, messagingMaximumRequestInput(method, family)), family => [
+        {
+            leaf: 'requestId',
+            frame: requestFrame(method, messagingMaximumRequestInput(method, family), 'a'.repeat(REQUEST_ID_MAX_LENGTH + 1)),
+        },
+        ...messagingRequestNPlusOneInputs(method, family).map(({ leaf, input }) => ({
+            leaf,
+            frame: requestFrame(method, input),
+        })),
+    ]);
+}
+function resultProof(method) {
+    return structuralProof(family => resultFrame(messagingMaximumResult(method, family)), family => [
+        {
+            leaf: 'requestId',
+            frame: resultFrame(messagingMaximumResult(method, family), 'a'.repeat(REQUEST_ID_MAX_LENGTH + 1)),
+        },
+        ...messagingResultNPlusOneInputs(method, family).map(({ leaf, result }) => ({
+            leaf,
+            frame: resultFrame(result),
+        })),
+    ]);
+}
+const MESSAGING_ERROR_CODES = [
+    'VALIDATION',
+    'PERMISSION',
+    'NOT_FOUND',
+    'CONFLICT',
+    'RETRYABLE_INFLIGHT',
+    'STALE_CURSOR',
+    'MEDIA_ACCESS_DENIED',
+    'MESSAGE_NOT_PUBLISHED',
+];
+function longest(values) {
+    return values.reduce((current, candidate) => candidate.length > current.length ? candidate : current);
+}
+function standardErrorEnvelopes() {
+    return STANDARD_ERROR_CODES.flatMap((code) => {
+        const error = { code, message: ERROR_CODE_TO_MESSAGE[code] };
+        if (code === PARSE_ERROR_CODE)
+            return [{ id: null, error }];
+        if (code === INVALID_REQUEST_CODE) {
+            return [{ id: null, error }, { id: MAX_REQUEST_ID, error }];
+        }
+        return [{ id: MAX_REQUEST_ID, error }];
+    });
+}
+function applicationErrorEnvelopes(method) {
+    const common = [
+        {
+            id: MAX_REQUEST_ID,
+            error: {
+                code: DOMAIN_ERROR_CODE,
+                message: DOMAIN_ERROR_MESSAGE,
+                data: { code: longest(MESSAGING_ERROR_CODES) },
+            },
+        },
+        {
+            id: MAX_REQUEST_ID,
+            error: {
+                code: DEADLINE_EXPIRED_CODE,
+                message: DEADLINE_EXPIRED_MESSAGE,
+                data: {},
+            },
+        },
+    ];
+    if (method === 'messaging.snapshot') {
+        return [...common, {
+                id: MAX_REQUEST_ID,
+                error: {
+                    code: SNAPSHOT_UNAVAILABLE_CODE,
+                    message: SNAPSHOT_UNAVAILABLE_MESSAGE,
+                    data: { reason: longest(SNAPSHOT_UNAVAILABLE_REASONS) },
+                },
+            }];
+    }
+    if (method === 'host.messaging.deliver') {
+        return [{
+                id: MAX_REQUEST_ID,
+                error: {
+                    code: DELIVERY_REJECTED_CODE,
+                    message: DELIVERY_REJECTED_MESSAGE,
+                    data: { reason: longest(DELIVERY_REJECT_REASONS) },
+                },
+            }];
+    }
+    return common;
+}
+function errorProof(method) {
+    const envelopes = [...standardErrorEnvelopes(), ...applicationErrorEnvelopes(method)];
+    const maximum = envelopes.reduce((current, candidate) => byteLength({ jsonrpc: '2.0', ...candidate }) >
+        byteLength({ jsonrpc: '2.0', ...current }) ? candidate : current);
+    return structuralProof(() => ({ jsonrpc: '2.0', ...maximum }), () => [{
+            leaf: 'requestId',
+            frame: {
+                jsonrpc: '2.0',
+                id: 'a'.repeat(REQUEST_ID_MAX_LENGTH + 1),
+                error: maximum.error,
+            },
+        }]);
+}
+export const MESSAGING_REQUEST_BYTE_PROOFS = Object.fromEntries([
+    'messaging.send',
+    'messaging.appendElements',
+    'messaging.subscribe',
+    'messaging.read',
+    'messaging.ack',
+    'messaging.snapshot',
+    'streams.read',
+    'host.messaging.deliver',
+].map(method => [method, requestProof(method)]));
+export const MESSAGING_RESULT_BYTE_PROOFS = {
+    'messaging.send': resultProof('messaging.send'),
+    'messaging.appendElements': resultProof('messaging.appendElements'),
+    'messaging.subscribe': resultProof('messaging.subscribe'),
+    'messaging.read': assemblerBudgetProof(),
+    'messaging.ack': resultProof('messaging.ack'),
+    'messaging.snapshot': assemblerBudgetProof(),
+    'streams.read': resultProof('streams.read'),
+    'host.messaging.deliver': resultProof('host.messaging.deliver'),
+};
+export const MESSAGING_ERROR_BYTE_PROOFS = Object.fromEntries(Object.keys(MESSAGING_REQUEST_BYTE_PROOFS)
+    .map(method => [method, errorProof(method)]));
+export const MESSAGING_ROW_ENCODED_BYTE_BOUNDS = Object.fromEntries(Object.keys(MESSAGING_REQUEST_BYTE_PROOFS).map(method => [
+    method,
+    {
+        maxEncodedRequestBytes: MESSAGING_REQUEST_BYTE_PROOFS[method].maxEncodedBytes,
+        maxEncodedResultBytes: MESSAGING_RESULT_BYTE_PROOFS[method].maxEncodedBytes,
+        maxEncodedErrorBytes: MESSAGING_ERROR_BYTE_PROOFS[method].maxEncodedBytes,
+    },
+]));
+//# sourceMappingURL=messaging-byte-bounds.js.map