@sema-agent/client-core 0.89.0 → 0.91.0

package/dist/humanTurn.js

@@ -0,0 +1,253 @@
+import { mintEnvelopeOf, mintReferenceOf } from './userAttachmentEnvelope.js';
+import { readEncodingShares, readHumanTurnInput } from './humanTurnRead.js';
+const REQUEST_BODY_MAX_BYTES = 8 * 1024 * 1024;
+const IMAGE_SEAT_MAX_COUNT = 20;
+const IMAGE_MAX_BASE64_CHARS_EACH = 6 * 1024 * 1024;
+const IMAGE_SEAT_MAX_BASE64_CHARS_TOTAL = 6 * 1024 * 1024;
+const STEER_MAX_CHARS = 16000;
+const STEER_REMINDER_TAG = /<\s*\/?\s*system-reminder(?:\s[^>]*)?>/i;
+const STEER_CONTROL_CHARS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
+function utf8Length(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i += 1) {
+        const c = s.charCodeAt(i);
+        if (c < 0x80)
+            n += 1;
+        else if (c < 0x800)
+            n += 2;
+        else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
+            const d = s.charCodeAt(i + 1);
+            if (d >= 0xdc00 && d <= 0xdfff) {
+                n += 4;
+                i += 1;
+            }
+            else
+                n += 3;
+        }
+        else
+            n += 3;
+    }
+    return n;
+}
+const jsonBytes = (v) => utf8Length(JSON.stringify(v));
+function bodyBytes(other, objective, images, ids) {
+    const keys = [jsonBytes('objective') + 1 + jsonBytes(objective)];
+    if (images.length > 0)
+        keys.push(jsonBytes('images') + 1 + jsonBytes(images));
+    if (ids.length > 0)
+        keys.push(jsonBytes('attachmentIds') + 1 + jsonBytes(ids));
+    const commas = other === 2 ? keys.length - 1 : keys.length;
+    return other + keys.reduce((a, b) => a + b, 0) + commas;
+}
+function steerRefusal(text) {
+    if (text.length === 0)
+        return 'no_text';
+    if (STEER_REMINDER_TAG.test(text))
+        return 'reminder_tag';
+    if (STEER_CONTROL_CHARS.test(text))
+        return 'control_char';
+    if (text.length > STEER_MAX_CHARS)
+        return 'too_long';
+    return undefined;
+}
+function textOf(p) {
+    if (p.form === 'reference')
+        return mintReferenceOf(p.a.d);
+    return mintEnvelopeOf(p.a.d, p.seated ? 'attached' : 'not-attached');
+}
+function compose(items, placements) {
+    const perItem = items.map((it, i) => [...placements.filter((p) => p.item === i).map(textOf), it.text].filter((s) => s.length > 0).join('\n\n'));
+    return perItem.filter((s) => s.length > 0).join('\n');
+}
+function seatedImages(items, pastedWhy, placements) {
+    const out = [];
+    items.forEach((it, i) => {
+        it.images.forEach((img, k) => {
+            if (pastedWhy[i]?.[k] === undefined)
+                out.push('url' in img ? { url: img.url } : { data: img.data, mimeType: img.mimeType });
+        });
+        for (const p of placements) {
+            if (p.item === i && p.form === 'content' && p.seated && p.a.pixels !== undefined)
+                out.push({ data: p.a.pixels.data, mimeType: p.a.pixels.mimeType });
+        }
+    });
+    return out;
+}
+const ENCODER_WHY_LIST = [
+    'body_budget',
+    'steer_admission',
+    'vision_no',
+    'vision_unknown',
+    'image_too_large',
+    'seat_count',
+    'seat_total',
+    'lane_has_no_image_seat',
+    'lane_has_no_attachment_id_seat',
+];
+const encoderWhysExhaustive = true;
+void encoderWhysExhaustive;
+const ENCODER_WHYS = new Set(ENCODER_WHY_LIST);
+function records(lane, items, pastedWhy, placements) {
+    const recs = [];
+    const push = (item, part) => {
+        recs.push({ item, part });
+    };
+    items.forEach((it, i) => {
+        if (it.text.length > 0)
+            push(i, { kind: 'text', status: 'full' });
+        it.images.forEach((_, k) => {
+            const why = pastedWhy[i]?.[k];
+            push(i, lane !== 'objective' ? { kind: 'image', ref: k, status: 'none', why: 'lane_has_no_image_seat' } : why === undefined ? { kind: 'image', ref: k, status: 'full' } : { kind: 'image', ref: k, status: 'none', why });
+        });
+        for (const p of placements) {
+            if (p.item !== i)
+                continue;
+            push(i, p.form === 'content' ? { kind: 'attachment_ref', ref: p.a.uuid, status: 'full' } : { kind: 'attachment_ref', ref: p.a.uuid, status: 'none', why: lane === 'objective' ? 'body_budget' : 'steer_admission' });
+            if (p.a.pixels !== undefined) {
+                if (lane === 'steer')
+                    push(i, { kind: 'image', ref: p.a.uuid, status: 'none', why: 'lane_has_no_image_seat' });
+                else if (p.seated && p.form === 'content')
+                    push(i, { kind: 'image', ref: p.a.uuid, status: 'full' });
+                else
+                    push(i, { kind: 'image', ref: p.a.uuid, status: 'none', why: p.seated ? 'body_budget' : p.seatWhy });
+            }
+        }
+        for (const id of it.attachmentIds) {
+            push(i, lane === 'objective' ? { kind: 'attachment_id', ref: id, status: 'full' } : { kind: 'attachment_id', ref: id, status: 'none', why: 'lane_has_no_attachment_id_seat' });
+        }
+        for (const r of it.riders) {
+            if (r.role === 'image_meta')
+                continue;
+            push(i, r.textIncluded ? { kind: 'rider_text', ref: r.uuid, status: 'full' } : { kind: 'rider_text', ref: r.uuid, status: 'none', why: 'text_not_included' });
+        }
+        for (const m of it.missing) {
+            push(i, m.ref === undefined ? { kind: m.kind, status: 'none', why: m.reason } : { kind: m.kind, ref: m.ref, status: 'none', why: m.reason });
+        }
+    });
+    return recs;
+}
+function sharesAndDegraded(items, recs) {
+    const shares = items.map((it, i) => {
+        const parts = recs.filter((r) => r.item === i).map((r) => r.part);
+        const full = parts.filter((p) => p.status === 'full').length;
+        const level = parts.length > 0 && full === parts.length ? 'full' : full === 0 ? 'none' : 'partial';
+        return { uuid: it.uuid, riderUuids: [...it.riders.map((r) => r.uuid), ...it.attachments.map((a) => a.uuid)], level, parts };
+    });
+    const degraded = [];
+    for (const r of recs) {
+        const w = r.part.why;
+        if (r.part.status === 'none' && w !== undefined && ENCODER_WHYS.has(w)) {
+            const uuid = items[r.item].uuid;
+            degraded.push(r.part.ref === undefined ? { uuid, kind: r.part.kind, why: w } : { uuid, kind: r.part.kind, ref: r.part.ref, why: w });
+        }
+    }
+    return { shares, degraded };
+}
+function encodeObjective(v) {
+    const { items } = v;
+    let count = 0;
+    let total = 0;
+    const seat = (len) => {
+        if (len > IMAGE_MAX_BASE64_CHARS_EACH)
+            return 'image_too_large';
+        if (count + 1 > IMAGE_SEAT_MAX_COUNT)
+            return 'seat_count';
+        if (total + len > IMAGE_SEAT_MAX_BASE64_CHARS_TOTAL)
+            return 'seat_total';
+        count += 1;
+        total += len;
+        return undefined;
+    };
+    const pastedWhy = items.map((it) => it.images.map((img) => seat('data' in img ? img.data.length : 0)));
+    const placements = [];
+    items.forEach((it, i) => {
+        for (const a of it.attachments) {
+            const p = { item: i, a, form: 'content', seated: false, seatWhy: undefined };
+            if (a.pixels !== undefined) {
+                if (v.vision !== 'yes')
+                    p.seatWhy = v.vision === 'no' ? 'vision_no' : 'vision_unknown';
+                else {
+                    p.seatWhy = seat(a.pixels.data.length);
+                    p.seated = p.seatWhy === undefined;
+                }
+            }
+            placements.push(p);
+        }
+    });
+    const ids = items.flatMap((it) => it.attachmentIds);
+    for (;;) {
+        const text = compose(items, placements);
+        const images = seatedImages(items, pastedWhy, placements);
+        if (bodyBytes(v.otherBodyBytes, text, images, ids) <= REQUEST_BODY_MAX_BYTES) {
+            if (text.trim() === '')
+                return { ok: false, reason: 'empty' };
+            const { shares, degraded } = sharesAndDegraded(items, records('objective', items, pastedWhy, placements));
+            return { ok: true, lane: 'objective', text, images, attachmentIds: [...ids], shares, degraded };
+        }
+        let pick = -1;
+        let pickCost = -1;
+        placements.forEach((p, k) => {
+            if (p.form !== 'content')
+                return;
+            const cost = jsonBytes(textOf(p)) + (p.seated && p.a.pixels !== undefined ? jsonBytes({ data: p.a.pixels.data, mimeType: p.a.pixels.mimeType }) : 0);
+            if (cost >= pickCost) {
+                pick = k;
+                pickCost = cost;
+            }
+        });
+        if (pick < 0)
+            return { ok: false, reason: 'oversize' };
+        placements[pick].form = 'reference';
+    }
+}
+function encodeSteer(v) {
+    const { items } = v;
+    const placements = [];
+    items.forEach((it, i) => {
+        for (const a of it.attachments)
+            placements.push({ item: i, a, form: 'content', seated: false, seatWhy: undefined });
+    });
+    let text = compose(items, placements);
+    let refusal = steerRefusal(text);
+    if (refusal !== undefined && refusal !== 'no_text' && placements.length > 0) {
+        for (const p of placements)
+            p.form = 'reference';
+        text = compose(items, placements);
+        refusal = steerRefusal(text);
+    }
+    if (refusal !== undefined)
+        return { ok: false, reason: 'steer_hold', why: refusal };
+    const { shares, degraded } = sharesAndDegraded(items, records('steer', items, [], placements));
+    return { ok: true, lane: 'steer', text, shares, degraded };
+}
+export function encodeHumanTurn(input) {
+    let v;
+    try {
+        v = readHumanTurnInput(input);
+    }
+    catch {
+        return { ok: false, reason: 'malformed_input' };
+    }
+    if ('reject' in v)
+        return { ok: false, reason: v.reject };
+    try {
+        return v.lane === 'objective' ? encodeObjective(v) : encodeSteer(v);
+    }
+    catch {
+        return { ok: false, reason: 'malformed_input' };
+    }
+}
+export function deliveredUuidsOf(encoding) {
+    const shares = readEncodingShares(encoding);
+    const full = [];
+    const partial = [];
+    for (const s of shares ?? []) {
+        const into = s.level === 'full' ? full : s.level === 'partial' ? partial : undefined;
+        if (into === undefined)
+            continue;
+        into.push(s.uuid);
+        for (const r of s.riderUuids)
+            into.push(r);
+    }
+    return { full, partial };
+}

package/dist/humanTurnRead.d.ts

@@ -0,0 +1,105 @@
+import type { ImageInput } from './imagesWireCaps.js';
+import type { UserAttachmentDescriptor, UserAttachmentNotIncludedReason, UserAttachmentSource } from './userAttachmentEnvelope.js';
+import type { HumanTurnAttachment, HumanTurnEncoding, HumanTurnInput, HumanTurnMissing } from './humanTurn.js';
+import type { ImageVision } from './liveModelCatalog.js';
+export interface CellView {
+    cellType: string | undefined;
+    source: string | undefined;
+    cellId: string | undefined;
+    language: string | undefined;
+    outputs: {
+        text: string | undefined;
+        hasImage: boolean;
+    }[];
+    outputsTooLarge: boolean;
+}
+export type DescriptorView = {
+    kind: 'text';
+    source: UserAttachmentSource;
+    name: string;
+    path: string;
+    lines: string[];
+    startLine: number;
+    totalLines: number;
+    complete: boolean;
+} | {
+    kind: 'notebook';
+    source: UserAttachmentSource;
+    name: string;
+    path: string;
+    cells: CellView[];
+} | {
+    kind: 'image';
+    source: UserAttachmentSource;
+    name: string;
+    path: string;
+    sizeBytes: number | null;
+    delivery: 'attached' | 'not-attached' | undefined;
+} | {
+    kind: 'pdf';
+    source: UserAttachmentSource;
+    name: string;
+    path: string;
+    sizeBytes: number | null;
+    pageCount: number | null;
+} | {
+    kind: 'directory';
+    name: string;
+    path: string;
+    entries: string[];
+    totalEntries: number;
+} | {
+    kind: 'not-included';
+    target: 'file' | 'directory' | 'path';
+    name: string;
+    path: string;
+    sizeBytes: number | null;
+    reason: UserAttachmentNotIncludedReason;
+};
+export declare function readDescriptor(x: UserAttachmentDescriptor | HumanTurnAttachment['descriptor'], imageDelivery: 'required' | 'ignored'): DescriptorView | undefined;
+type Reason = Exclude<Extract<HumanTurnEncoding, {
+    ok: false;
+}>['reason'], 'steer_hold' | 'oversize'>;
+export interface AttachmentView {
+    uuid: string;
+    d: DescriptorView;
+    pixels: {
+        data: string;
+        mimeType: string;
+    } | undefined;
+}
+export interface RiderView {
+    uuid: string;
+    role: string;
+    textIncluded: boolean;
+}
+export interface MissingView {
+    kind: HumanTurnMissing['kind'];
+    ref: string | undefined;
+    reason: HumanTurnMissing['reason'];
+}
+export interface ItemView {
+    uuid: string;
+    text: string;
+    images: ImageInput[];
+    attachments: AttachmentView[];
+    attachmentIds: string[];
+    riders: RiderView[];
+    missing: MissingView[];
+}
+export interface InputView {
+    lane: 'objective' | 'steer';
+    vision: ImageVision;
+    otherBodyBytes: number;
+    items: ItemView[];
+}
+export declare function readHumanTurnInput(input: HumanTurnInput): InputView | {
+    readonly reject: Reason;
+};
+export interface ShareView {
+    uuid: string;
+    level: 'full' | 'partial' | 'none';
+    riderUuids: string[];
+}
+export declare function readEncodingShares(encoding: HumanTurnEncoding): ShareView[] | undefined;
+export {};

package/dist/humanTurnRead.js

@@ -0,0 +1,331 @@
+const descriptorKindsAligned = true;
+void descriptorKindsAligned;
+const MALFORMED = Object.freeze({});
+const bad = () => {
+    throw MALFORMED;
+};
+function isPlainObject(x) {
+    if (x === null || typeof x !== 'object' || Array.isArray(x))
+        return false;
+    const p = Object.getPrototypeOf(x);
+    return p === Object.prototype || p === null;
+}
+function ownData(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    if (d === undefined)
+        return undefined;
+    if (!('value' in d))
+        bad();
+    return d.value;
+}
+function ownArray(x) {
+    if (!Array.isArray(x))
+        bad();
+    const arr = x;
+    const n = ownData(arr, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        bad();
+    const out = [];
+    for (let i = 0; i < n; i += 1) {
+        const d = Object.getOwnPropertyDescriptor(arr, i);
+        if (d === undefined || !('value' in d))
+            bad();
+        out.push(d.value);
+    }
+    return out;
+}
+const str = (v) => (typeof v === 'string' ? v : bad());
+const optStr = (v) => (v === undefined ? undefined : str(v));
+const strArray = (v) => ownArray(v).map(str);
+const sizeOf = (v) => (v === null ? null : typeof v === 'number' ? v : bad());
+const posInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 1 ? v : bad());
+const natInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : bad());
+function sourceOf(v) {
+    return v === 'at-mention' || v === 'compact-restore' ? v : bad();
+}
+function readCell(x) {
+    if (!isPlainObject(x))
+        bad();
+    const c = x;
+    const outputsRaw = ownData(c, 'outputs');
+    const outputs = outputsRaw === undefined
+        ? []
+        : ownArray(outputsRaw).map((o) => {
+            if (!isPlainObject(o))
+                bad();
+            const hasImage = ownData(o, 'hasImage');
+            if (hasImage !== undefined && typeof hasImage !== 'boolean')
+                bad();
+            return { text: optStr(ownData(o, 'text')), hasImage: hasImage === true };
+        });
+    const tooLarge = ownData(c, 'outputsTooLarge');
+    if (tooLarge !== undefined && typeof tooLarge !== 'boolean')
+        bad();
+    return {
+        cellType: optStr(ownData(c, 'cellType')),
+        source: optStr(ownData(c, 'source')),
+        cellId: optStr(ownData(c, 'cellId')),
+        language: optStr(ownData(c, 'language')),
+        outputs,
+        outputsTooLarge: tooLarge === true,
+    };
+}
+function readDescriptorAny(x, imageDelivery) {
+    try {
+        if (!isPlainObject(x))
+            return undefined;
+        const o = x;
+        const kind = ownData(o, 'kind');
+        const name = () => str(ownData(o, 'name'));
+        const path = () => str(ownData(o, 'path'));
+        switch (kind) {
+            case 'text': {
+                const complete = ownData(o, 'complete');
+                if (typeof complete !== 'boolean')
+                    bad();
+                return {
+                    kind,
+                    source: sourceOf(ownData(o, 'source')),
+                    name: name(),
+                    path: path(),
+                    lines: strArray(ownData(o, 'lines')),
+                    startLine: posInt(ownData(o, 'startLine')),
+                    totalLines: natInt(ownData(o, 'totalLines')),
+                    complete: complete,
+                };
+            }
+            case 'notebook':
+                return { kind, source: sourceOf(ownData(o, 'source')), name: name(), path: path(), cells: ownArray(ownData(o, 'cells')).map(readCell) };
+            case 'image': {
+                let delivery;
+                if (imageDelivery === 'required') {
+                    const d = ownData(o, 'delivery');
+                    delivery = d === 'attached' || d === 'not-attached' ? d : bad();
+                }
+                return { kind, source: sourceOf(ownData(o, 'source')), name: name(), path: path(), sizeBytes: sizeOf(ownData(o, 'sizeBytes')), delivery };
+            }
+            case 'pdf': {
+                const pc = ownData(o, 'pageCount');
+                return {
+                    kind,
+                    source: sourceOf(ownData(o, 'source')),
+                    name: name(),
+                    path: path(),
+                    sizeBytes: sizeOf(ownData(o, 'sizeBytes')),
+                    pageCount: pc === null ? null : typeof pc === 'number' ? pc : bad(),
+                };
+            }
+            case 'directory':
+                return { kind, name: name(), path: path(), entries: strArray(ownData(o, 'entries')), totalEntries: natInt(ownData(o, 'totalEntries')) };
+            case 'not-included': {
+                const target = ownData(o, 'target');
+                const reason = ownData(o, 'reason');
+                if (target !== 'file' && target !== 'directory' && target !== 'path')
+                    bad();
+                if (reason !== 'too-large' && reason !== 'unreadable' && reason !== 'read-denied')
+                    bad();
+                return {
+                    kind,
+                    target: target,
+                    name: name(),
+                    path: path(),
+                    sizeBytes: sizeOf(ownData(o, 'sizeBytes')),
+                    reason: reason,
+                };
+            }
+            default:
+                return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readDescriptor(x, imageDelivery) {
+    return readDescriptorAny(x, imageDelivery);
+}
+const REASON_LIST = ['empty', 'malformed_input', 'malformed_item', 'duplicate_uuid', 'rider_collides_primary'];
+const reasonListExhaustive = true;
+void reasonListExhaustive;
+const REJECT_SENTINELS = new Map(REASON_LIST.map((r) => [Object.freeze({}), r]));
+const sentinelOf = (reason) => {
+    for (const [s, r] of REJECT_SENTINELS)
+        if (r === reason)
+            return s;
+    return MALFORMED;
+};
+const reject = (reason) => {
+    throw sentinelOf(reason);
+};
+const rejectReasonOf = (e) => (typeof e === 'object' && e !== null ? REJECT_SENTINELS.get(e) : undefined);
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : reject('malformed_item'));
+const optArray = (v) => (v === undefined ? [] : ownArray(v));
+function readImage(x) {
+    if (!isPlainObject(x))
+        reject('malformed_item');
+    const o = x;
+    const data = ownData(o, 'data');
+    const mimeType = ownData(o, 'mimeType');
+    const url = ownData(o, 'url');
+    if (url === undefined && data !== undefined)
+        return { data: nonEmpty(data), mimeType: nonEmpty(mimeType) };
+    if (data === undefined && mimeType === undefined)
+        return { url: nonEmpty(url) };
+    return reject('malformed_item');
+}
+const MISSING_KIND_LIST = ['rider_text', 'image', 'attachment_ref', 'non_text'];
+const MISSING_REASON_LIST = ['not_persisted', 'not_found', 'non_text_filtered', 'projection_failed'];
+const missingListsExhaustive = true;
+void missingListsExhaustive;
+const MISSING_KINDS = new Set(MISSING_KIND_LIST);
+const MISSING_REASONS = new Set(MISSING_REASON_LIST);
+function readItem(x) {
+    if (!isPlainObject(x))
+        reject('malformed_item');
+    const o = x;
+    const text = ownData(o, 'text');
+    if (typeof text !== 'string')
+        reject('malformed_item');
+    const attachments = optArray(ownData(o, 'attachments')).map((a) => {
+        if (!isPlainObject(a))
+            reject('malformed_item');
+        const ao = a;
+        const d = readDescriptorAny(ownData(ao, 'descriptor'), 'ignored');
+        if (d === undefined)
+            reject('malformed_item');
+        const px = ownData(ao, 'pixels');
+        let pixels;
+        if (px !== undefined) {
+            if (d.kind !== 'image' || !isPlainObject(px))
+                reject('malformed_item');
+            pixels = { data: nonEmpty(ownData(px, 'data')), mimeType: nonEmpty(ownData(px, 'mimeType')) };
+        }
+        return { uuid: nonEmpty(ownData(ao, 'uuid')), d: d, pixels };
+    });
+    return {
+        uuid: nonEmpty(ownData(o, 'uuid')),
+        text: text,
+        images: optArray(ownData(o, 'images')).map(readImage),
+        attachments,
+        attachmentIds: optArray(ownData(o, 'attachmentIds')).map(nonEmpty),
+        riders: optArray(ownData(o, 'riders')).map((r) => {
+            if (!isPlainObject(r))
+                reject('malformed_item');
+            const ti = ownData(r, 'textIncluded');
+            if (typeof ti !== 'boolean')
+                reject('malformed_item');
+            return { uuid: nonEmpty(ownData(r, 'uuid')), role: nonEmpty(ownData(r, 'role')), textIncluded: ti };
+        }),
+        missing: optArray(ownData(o, 'missing')).map((m) => {
+            if (!isPlainObject(m))
+                reject('malformed_item');
+            const kind = ownData(m, 'kind');
+            const reason = ownData(m, 'reason');
+            const ref = ownData(m, 'ref');
+            if (typeof kind !== 'string' || !MISSING_KINDS.has(kind))
+                reject('malformed_item');
+            if (typeof reason !== 'string' || !MISSING_REASONS.has(reason))
+                reject('malformed_item');
+            if (ref !== undefined && typeof ref !== 'string')
+                reject('malformed_item');
+            return { kind: kind, ref: ref, reason: reason };
+        }),
+    };
+}
+function readInputAny(x) {
+    if (!isPlainObject(x))
+        reject('malformed_input');
+    const o = x;
+    const lane = ownData(o, 'lane');
+    if (lane !== 'objective' && lane !== 'steer')
+        reject('malformed_input');
+    const caps = ownData(o, 'caps');
+    if (!isPlainObject(caps))
+        reject('malformed_input');
+    const vision = ownData(caps, 'vision');
+    if (vision !== undefined && vision !== 'yes' && vision !== 'no' && vision !== 'unknown')
+        reject('malformed_input');
+    let otherBodyBytes = 0;
+    if (lane === 'objective') {
+        const ob = ownData(o, 'otherBodyBytes');
+        if (typeof ob !== 'number' || !Number.isSafeInteger(ob) || ob < 2)
+            reject('malformed_input');
+        otherBodyBytes = ob;
+    }
+    const raw = ownData(o, 'items');
+    if (!Array.isArray(raw))
+        reject('malformed_input');
+    let rawItems;
+    try {
+        rawItems = ownArray(raw);
+    }
+    catch {
+        return reject('malformed_input');
+    }
+    if (rawItems.length === 0)
+        reject('empty');
+    const items = rawItems.map((x) => {
+        try {
+            return readItem(x);
+        }
+        catch (e) {
+            return reject(rejectReasonOf(e) ?? 'malformed_item');
+        }
+    });
+    const primaries = new Set();
+    for (const it of items) {
+        if (primaries.has(it.uuid))
+            reject('duplicate_uuid');
+        primaries.add(it.uuid);
+    }
+    const secondaries = new Set();
+    for (const it of items) {
+        for (const u of [...it.riders.map((r) => r.uuid), ...it.attachments.map((a) => a.uuid)]) {
+            if (primaries.has(u))
+                reject('rider_collides_primary');
+            if (secondaries.has(u))
+                reject('malformed_item');
+            secondaries.add(u);
+        }
+    }
+    if (items.every((it) => it.text.length === 0 && it.images.length === 0 && it.attachments.length === 0 && it.attachmentIds.length === 0))
+        reject('empty');
+    return { lane: lane, vision: vision ?? 'unknown', otherBodyBytes, items };
+}
+export function readHumanTurnInput(input) {
+    try {
+        return readInputAny(input);
+    }
+    catch (e) {
+        return { reject: rejectReasonOf(e) ?? 'malformed_input' };
+    }
+}
+export function readEncodingShares(encoding) {
+    try {
+        if (!isPlainObject(encoding) || ownData(encoding, 'ok') !== true)
+            return undefined;
+        const out = [];
+        for (const s of ownArray(ownData(encoding, 'shares'))) {
+            if (!isPlainObject(s))
+                return undefined;
+            const level = ownData(s, 'level');
+            const uuid = ownData(s, 'uuid');
+            const riders = ownArray(ownData(s, 'riderUuids'));
+            if (typeof uuid !== 'string' || uuid.length === 0)
+                return undefined;
+            if (level !== 'full' && level !== 'partial' && level !== 'none')
+                return undefined;
+            const riderUuids = [];
+            for (const r of riders) {
+                if (typeof r !== 'string' || r.length === 0)
+                    return undefined;
+                riderUuids.push(r);
+            }
+            out.push({ uuid, level, riderUuids });
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}