@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/queuedDelivery.js

@@ -0,0 +1,233 @@
+import { encodeHumanTurn } from './humanTurn.js';
+import { imageVisionOf } from './liveModelCatalog.js';
+import { userPromptSubmitExecutorOf } from './pluginHooksWire.js';
+import { observedUserAttachmentSeat } from './userAttachmentSeat.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+const own = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+const str = (o, key) => {
+    const v = own(o, key);
+    return typeof v === 'string' ? v : undefined;
+};
+const UNREADABLE = Symbol('unreadable');
+function peek(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return UNREADABLE;
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return undefined;
+        return Object.hasOwn(d, 'value') ? d.value : UNREADABLE;
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function arrayFact(v) {
+    if (v === undefined)
+        return 'absent';
+    if (v === UNREADABLE)
+        return 'bad';
+    try {
+        if (!Array.isArray(v))
+            return 'bad';
+        return v.length > 0 ? 'some' : 'empty';
+    }
+    catch {
+        return 'bad';
+    }
+}
+const nonEmptyArray = (v) => arrayFact(v) === 'some';
+export function batchCompatible(head, follower, plan) {
+    try {
+        if (plan === undefined || plan === null)
+            return false;
+        if (typeof head !== 'object' || head === null || typeof follower !== 'object' || follower === null)
+            return false;
+        const executor = userPromptSubmitExecutorOf(plan);
+        if (executor === 'engine' || executor === 'unknown')
+            return false;
+        if (peek(follower, 'screening') !== undefined)
+            return false;
+        const item = peek(follower, 'item');
+        if (typeof item !== 'object' || item === null)
+            return false;
+        const mentions = arrayFact(peek(item, 'attachments'));
+        if (mentions !== 'absent' && mentions !== 'empty')
+            return false;
+        const he = peek(head, 'upsExecutor');
+        const fe = peek(follower, 'upsExecutor');
+        if (!upsExecutorWordOk(he) || !upsExecutorWordOk(fe))
+            return false;
+        if (he !== undefined && fe !== undefined && he !== fe)
+            return false;
+        const kind = str(head, 'kind');
+        if (kind === undefined || kind !== str(follower, 'kind'))
+            return false;
+        const sameOptStr = (key) => {
+            const a = peek(head, key);
+            const b = peek(follower, key);
+            if ((a !== undefined && typeof a !== 'string') || (b !== undefined && typeof b !== 'string'))
+                return false;
+            return a === b;
+        };
+        if (!sameOptStr('injection') || !sameOptStr('intentKey'))
+            return false;
+        const ha = peek(head, 'hidden');
+        const hb = peek(follower, 'hidden');
+        if ((ha !== undefined && typeof ha !== 'boolean') || (hb !== undefined && typeof hb !== 'boolean'))
+            return false;
+        if ((ha === true) !== (hb === true))
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function upsExecutorWordOk(v) {
+    return v === undefined || v === 'shell' || v === 'engine' || v === 'unknown' || v === 'none';
+}
+export function planQueuedDelivery(entries, run, caps, policy) {
+    const steerNow = [];
+    const held = [];
+    let list = [];
+    try {
+        list = Array.isArray(entries) ? [...entries] : [];
+    }
+    catch {
+        list = [];
+    }
+    const uuidOf = (e) => str(e, 'uuid') ?? '';
+    const live = own(run, 'live') === true && own(run, 'steerVerb') === true;
+    if (!live) {
+        for (const e of list)
+            held.push({ uuid: uuidOf(e), reason: 'no_run' });
+        return { steerNow, held, canSendNow: false };
+    }
+    const overtake = policy === undefined ? true : own(policy, 'overtakeBashHead') !== false;
+    let barrier = false;
+    let headSeen = false;
+    for (const e of list) {
+        const uuid = uuidOf(e);
+        const heldMark = peek(e, 'held');
+        if (heldMark === true) {
+            held.push({ uuid, reason: 'not_steerable' });
+            continue;
+        }
+        const isHead = !headSeen;
+        headSeen = true;
+        if (barrier) {
+            held.push({ uuid, reason: 'barrier' });
+            continue;
+        }
+        const state = peek(e, 'steerState');
+        const kind = peek(e, 'kind');
+        const shellBlock = peek(e, 'shellBlock');
+        const item = peek(e, 'item');
+        const stateKnown = state === undefined || state === 'none' || state === 'in_flight' || state === 'attempted';
+        if ((heldMark !== undefined && heldMark !== false) || !stateKnown || kind === UNREADABLE || shellBlock === UNREADABLE || item === UNREADABLE) {
+            held.push({ uuid, reason: 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        if (state === 'in_flight' || state === 'attempted') {
+            held.push({ uuid, reason: state });
+            barrier = true;
+            continue;
+        }
+        if (kind === 'bash' && isHead && overtake) {
+            held.push({ uuid, reason: 'not_steerable' });
+            continue;
+        }
+        if (kind !== 'prompt' || shellBlock !== undefined || typeof item !== 'object' || item === null) {
+            held.push({ uuid, reason: 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        const text = str(item, 'text');
+        if (text === undefined) {
+            held.push({ uuid, reason: 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        const mediaFacts = ['images', 'attachments', 'attachmentIds', 'missing', 'riders'].map((k) => arrayFact(peek(item, k)));
+        if (mediaFacts.includes('bad')) {
+            held.push({ uuid, reason: 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        const media = mediaFacts.includes('some');
+        if (text.trim() === '' && !media) {
+            held.push({ uuid, reason: 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        if (nonEmptyArray(own(item, 'attachments'))) {
+            held.push({ uuid, reason: 'share_incomplete' });
+            barrier = true;
+            continue;
+        }
+        const enc = encodeHumanTurn({ items: [item], lane: 'steer', caps });
+        if (!enc.ok) {
+            held.push({ uuid, reason: enc.reason === 'steer_hold' && enc.why === 'no_text' && media ? 'share_incomplete' : 'not_steerable' });
+            barrier = true;
+            continue;
+        }
+        if (enc.lane !== 'steer' || enc.shares.some((s) => s.level !== 'full')) {
+            held.push({ uuid, reason: 'share_incomplete' });
+            barrier = true;
+            continue;
+        }
+        steerNow.push({ uuid, payload: enc });
+    }
+    return { steerNow, held, canSendNow: steerNow.length > 0 };
+}
+export function selfHealSteerEligible(items, caps) {
+    try {
+        if (!Array.isArray(items) || items.length !== 1)
+            return false;
+        if (nonEmptyArray(own(items[0], 'attachments')))
+            return false;
+        const enc = encodeHumanTurn({ items: [items[0]], lane: 'steer', caps });
+        return enc.ok === true && enc.lane === 'steer' && enc.shares.length === 1 && enc.shares.every((s) => s.level === 'full');
+    }
+    catch {
+        return false;
+    }
+}
+export function humanTurnCapsOf(facts) {
+    const model = facts === undefined ? undefined : str(facts, 'model');
+    const baseUrl = facts === undefined ? undefined : str(facts, 'baseUrl');
+    const catalog = facts === undefined ? undefined : own(facts, 'catalog');
+    let vision = 'unknown';
+    try {
+        vision = catalog === undefined ? imageVisionOf(model) : imageVisionOf(model, catalog);
+    }
+    catch {
+        vision = 'unknown';
+    }
+    let userAttachments;
+    try {
+        userAttachments = baseUrl === undefined ? observedUserAttachmentSeat() : observedUserAttachmentSeat(baseUrl);
+    }
+    catch {
+        userAttachments = undefined;
+    }
+    return { vision, ...(userAttachments !== undefined ? { userAttachments } : {}) };
+}
+export function humanTextForKeywordScan(items) {
+    try {
+        if (!Array.isArray(items))
+            return '';
+        const parts = [];
+        for (const it of items) {
+            const t = str(it, 'text');
+            if (t !== undefined && t.trim() !== '')
+                parts.push(t);
+        }
+        return parts.join('\n');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/reattachWindow.d.ts

@@ -0,0 +1,94 @@
+export declare const REATTACH_WINDOW_MS = 300000;
+export declare const REATTACH_BACKOFF_START_MS = 1000;
+export declare const REATTACH_BACKOFF_CAP_MS = 30000;
+export declare const REATTACH_NOT_FOUND_CONFIRM = 3;
+export declare const REATTACH_NOT_FOUND_MIN_ELAPSED_MS = 10000;
+export interface ReattachWindowTuning {
+    readonly windowMs?: number;
+    readonly startMs?: number;
+    readonly capMs?: number;
+    readonly notFoundConfirm?: number;
+    readonly notFoundMinElapsedMs?: number;
+}
+interface Tuned {
+    readonly windowMs: number;
+    readonly startMs: number;
+    readonly capMs: number;
+    readonly notFoundConfirm: number;
+    readonly notFoundMinElapsedMs: number;
+}
+export declare function reattachBackoffMs(attempt: number, tuning?: ReattachWindowTuning): number;
+export interface ReattachWindowState {
+    readonly enteredAtMs: number;
+    readonly deadlineMs: number;
+    readonly attempt: number;
+    readonly consecutiveNotFound: number;
+    readonly notFoundConfirmed: boolean;
+    readonly tuning: Readonly<Tuned>;
+}
+export declare function reattachWindowOpen(nowMs: number, tuning?: ReattachWindowTuning): ReattachWindowState;
+export type ReattachProbeResult = 'readable' | 'unreachable' | 'not-found';
+export type ReattachWindowEvent = {
+    readonly type: 'attempt';
+} | {
+    readonly type: 'probe';
+    readonly result: ReattachProbeResult;
+} | {
+    readonly type: 'tail-frame';
+} | {
+    readonly type: 'tail-refused-404';
+} | {
+    readonly type: 'backoff';
+    readonly serverRetryAfterMs?: number;
+} | {
+    readonly type: 'new-segment';
+};
+export type ReattachWindowDecision = {
+    readonly action: 'continue';
+    readonly notFoundConfirmed: boolean;
+} | {
+    readonly action: 'wait';
+    readonly afterMs: number;
+} | {
+    readonly action: 'window-exhausted';
+} | {
+    readonly action: 'run-unknown';
+    readonly confirmations: number;
+};
+export interface ReattachWindowStep {
+    readonly state: ReattachWindowState;
+    readonly decision: ReattachWindowDecision;
+}
+export declare function reattachWindowStep(state: ReattachWindowState, event: ReattachWindowEvent, nowMs: number): ReattachWindowStep;
+export interface PoisonFrameState {
+    readonly lastGoodSeq: string | null;
+    readonly strikeAt: string | null | undefined;
+}
+export declare function poisonFrameInitial(): PoisonFrameState;
+export type PoisonFrameEvent = {
+    readonly type: 'frame-ok';
+    readonly seq?: string;
+} | {
+    readonly type: 'frame-bad';
+    readonly raw?: string;
+};
+export type PoisonFrameDecision = {
+    readonly action: 'continue';
+} | {
+    readonly action: 'resume-from';
+    readonly seq: string | null;
+} | {
+    readonly action: 'raise';
+    readonly afterSeq: string | null;
+    readonly raw?: string;
+};
+export interface PoisonFrameStep {
+    readonly state: PoisonFrameState;
+    readonly decision: PoisonFrameDecision;
+}
+export declare const POISON_FRAME_RAW_MAX = 2000;
+export declare function poisonFrameStep(state: PoisonFrameState, event: PoisonFrameEvent): PoisonFrameStep;
+export declare function malformedFrameErrorOf(err: {} | null | undefined): {
+    readonly detail: string;
+} | null;
+export {};

package/dist/reattachWindow.js

@@ -0,0 +1,127 @@
+import { usableClockMs } from './clockReading.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+export const REATTACH_WINDOW_MS = 300_000;
+export const REATTACH_BACKOFF_START_MS = 1_000;
+export const REATTACH_BACKOFF_CAP_MS = 30_000;
+export const REATTACH_NOT_FOUND_CONFIRM = 3;
+export const REATTACH_NOT_FOUND_MIN_ELAPSED_MS = 10_000;
+const pos = (v, d) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : d);
+const nonNeg = (v, d) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : d);
+const posInt = (v, d) => (typeof v === 'number' && Number.isSafeInteger(v) && v > 0 ? v : d);
+function tuned(t) {
+    const startMs = pos(t?.startMs, REATTACH_BACKOFF_START_MS);
+    return {
+        windowMs: pos(t?.windowMs, REATTACH_WINDOW_MS),
+        startMs,
+        capMs: Math.max(startMs, pos(t?.capMs, REATTACH_BACKOFF_CAP_MS)),
+        notFoundConfirm: posInt(t?.notFoundConfirm, REATTACH_NOT_FOUND_CONFIRM),
+        notFoundMinElapsedMs: nonNeg(t?.notFoundMinElapsedMs, REATTACH_NOT_FOUND_MIN_ELAPSED_MS),
+    };
+}
+export function reattachBackoffMs(attempt, tuning) {
+    const { startMs, capMs } = tuned(tuning);
+    if (typeof attempt !== 'number' || !(attempt > 1))
+        return startMs;
+    const raw = startMs * 2 ** (attempt - 1);
+    return Number.isFinite(raw) ? Math.min(raw, capMs) : capMs;
+}
+export function reattachWindowOpen(nowMs, tuning) {
+    const t = tuned(tuning);
+    const start = usableClockMs(nowMs) ?? Number.NaN;
+    return Object.freeze({ enteredAtMs: start, deadlineMs: start + t.windowMs, attempt: 0, consecutiveNotFound: 0, notFoundConfirmed: false, tuning: Object.freeze(t) });
+}
+const step = (state, decision) => Object.freeze({ state, decision });
+const exhausted = (state) => step(state, Object.freeze({ action: 'window-exhausted' }));
+const cont = (state, notFoundConfirmed = false) => step(state, Object.freeze({ action: 'continue', notFoundConfirmed }));
+const next = (state, patch) => Object.freeze({ ...state, ...patch });
+const isCount = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+function validState(s) {
+    if (typeof s !== 'object' || s === null)
+        return false;
+    const o = s;
+    return typeof o.enteredAtMs === 'number' && typeof o.deadlineMs === 'number' && isCount(o.attempt) && isCount(o.consecutiveNotFound) && typeof o.notFoundConfirmed === 'boolean' && typeof o.tuning === 'object' && o.tuning !== null;
+}
+export function reattachWindowStep(state, event, nowMs) {
+    try {
+        if (!validState(state))
+            return exhausted(reattachWindowOpen(Number.NaN));
+        if (typeof event !== 'object' || event === null)
+            return cont(state);
+        const type = event.type;
+        const result = event.result;
+        const serverRetryAfterMs = event.serverRetryAfterMs;
+        if (type === 'new-segment')
+            return cont(reattachWindowOpen(nowMs, state.tuning));
+        if (usableClockMs(nowMs) === null || !Number.isFinite(state.deadlineMs))
+            return exhausted(state);
+        switch (type) {
+            case 'attempt':
+                return nowMs < state.deadlineMs ? cont(next(state, { attempt: state.attempt + 1 })) : exhausted(state);
+            case 'probe': {
+                if (result === 'not-found') {
+                    const count = state.consecutiveNotFound + 1;
+                    const confirmed = count >= state.tuning.notFoundConfirm && nowMs - state.enteredAtMs >= state.tuning.notFoundMinElapsedMs;
+                    return cont(next(state, { consecutiveNotFound: count, notFoundConfirmed: confirmed }), confirmed);
+                }
+                if (result === 'readable' || result === 'unreachable')
+                    return cont(next(state, { consecutiveNotFound: 0, notFoundConfirmed: false }));
+                return cont(state);
+            }
+            case 'tail-frame':
+                return cont(next(state, { consecutiveNotFound: 0, notFoundConfirmed: false }));
+            case 'tail-refused-404':
+                return state.notFoundConfirmed ? step(state, Object.freeze({ action: 'run-unknown', confirmations: state.consecutiveNotFound })) : cont(state);
+            case 'backoff': {
+                const own = reattachBackoffMs(state.attempt, state.tuning);
+                const delay = typeof serverRetryAfterMs === 'number' && Number.isFinite(serverRetryAfterMs) && serverRetryAfterMs > 0 ? Math.max(own, serverRetryAfterMs) : own;
+                return nowMs + delay >= state.deadlineMs ? exhausted(state) : step(state, Object.freeze({ action: 'wait', afterMs: delay }));
+            }
+            default:
+                return cont(state);
+        }
+    }
+    catch {
+        return exhausted(reattachWindowOpen(Number.NaN));
+    }
+}
+export function poisonFrameInitial() {
+    return Object.freeze({ lastGoodSeq: null, strikeAt: undefined });
+}
+export const POISON_FRAME_RAW_MAX = 2_000;
+export function poisonFrameStep(state, event) {
+    const keep = (s) => Object.freeze({ state: s, decision: Object.freeze({ action: 'continue' }) });
+    try {
+        if (typeof state !== 'object' || state === null || typeof event !== 'object' || event === null)
+            return keep(typeof state === 'object' && state !== null ? state : poisonFrameInitial());
+        const goodSeq = state.lastGoodSeq;
+        const strikeAt = state.strikeAt;
+        const type = event.type;
+        const lastGoodSeq = typeof goodSeq === 'string' ? goodSeq : null;
+        if (type === 'frame-ok') {
+            const evSeq = event.seq;
+            const seq = typeof evSeq === 'string' && evSeq.length > 0 ? evSeq : lastGoodSeq;
+            return keep(Object.freeze({ lastGoodSeq: seq, strikeAt: undefined }));
+        }
+        if (type === 'frame-bad') {
+            const evRaw = event.raw;
+            const raw = typeof evRaw === 'string' ? evRaw.slice(0, POISON_FRAME_RAW_MAX) : undefined;
+            if (strikeAt !== undefined && strikeAt === lastGoodSeq) {
+                return Object.freeze({ state, decision: Object.freeze({ action: 'raise', afterSeq: lastGoodSeq, ...(raw !== undefined ? { raw } : {}) }) });
+            }
+            return Object.freeze({ state: Object.freeze({ lastGoodSeq, strikeAt: lastGoodSeq }), decision: Object.freeze({ action: 'resume-from', seq: lastGoodSeq }) });
+        }
+        return keep(state);
+    }
+    catch {
+        return keep(typeof state === 'object' && state !== null ? state : poisonFrameInitial());
+    }
+}
+const MALFORMED_FRAME_LEAD = /^SSE: malformed event data/;
+export function malformedFrameErrorOf(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const message = readThrownSlot(err, 'message');
+    if (message === THROWN_SLOT_UNREADABLE || typeof message !== 'string' || !MALFORMED_FRAME_LEAD.test(message))
+        return null;
+    return Object.freeze({ detail: message.replace(MALFORMED_FRAME_LEAD, '').replace(/^\s*\(contract breach\)\s*:?\s*/, '').trim().slice(0, 300) });
+}

package/dist/request/printNotification.d.ts

@@ -9,5 +9,5 @@ export interface PrintNotificationFieldSpec {
     why: string;
 }
 export declare const PRINT_NOTIFICATION_FIELD_MATRIX: readonly PrintNotificationFieldSpec[];
-export declare function taskNotificationToPrintFrame(n: Record<string, unknown>, identity?: PrintFrameIdentity): Record<string, unknown> | null;
+export declare function taskNotificationToPrintFrame(raw: Record<string, unknown>, identity?: PrintFrameIdentity): Record<string, unknown> | null;
 export declare function unregisteredPrintNotificationKeys(frame: Record<string, unknown>): string[];

package/dist/request/printNotification.js

@@ -1,4 +1,5 @@
 import { normalizeTaskNotification } from '../notifications.js';
+import { ownSnapshotRecord } from '../ownKey.js';
 export const PRINT_NOTIFICATION_FIELD_MATRIX = [
     { field: 'type', from: '—', cc: true, why: "CC system 帧信封:{type:'system'}" },
     { field: 'subtype', from: '—', cc: true, why: "CC 完成通知的 subtype:'task_notification'(187 print/SDK 出口形)" },
@@ -15,7 +16,7 @@ export const PRINT_NOTIFICATION_FIELD_MATRIX = [
     { field: '_sema_partial', from: 'partial', cc: false, why: 'server 1.258:被终止子代的残果(消费方须渲成不完整,不得当完整结果)' },
     { field: '_sema_exit_code', from: 'exitCode', cc: false, why: '后台 bash 退出码(137=OOM 这类归因只在这一位上)' },
     { field: '_sema_diagnostics', from: 'diagnostics', cc: false, why: '引擎侧诊断串(UNTRUSTED,service 已 redact)' },
-    { field: '_sema_result', from: 'result', cc: false, why: '完成结果正文(#49 C1:帧带 result 必入 XML,print 出口同理不得独漏)' },
+    { field: '_sema_result', from: 'result', cc: false, why: '完成结果正文(帧带 result 必入 XML,print 出口同理不得独漏)' },
     { field: '_sema_lines', from: 'lines', cc: false, why: '尾部输出行(UNTRUSTED);交互面折进 <output-lines>' },
     { field: '_sema_recent_steps', from: 'recentSteps', cc: false, why: '结构化残局步骤 {tool,target,outcome}[] —— **原样透传**,不降级成交互面那份显示串(SDK 消费方要结构)' },
     { field: '_sema_edited_files', from: 'editedFiles', cc: false, why: '结构化改档清单 {path,edits}[];同上原样透传' },
@@ -25,7 +26,10 @@ export const PRINT_NOTIFICATION_FIELD_MATRIX = [
     { field: '_sema_injected', from: 'injected', cc: false, why: '[1818]§四:本帧**不**证明 XML 已进模型上下文;消费方须按此位判,不得按帧到达判' },
 ];
 const PRINT_FRAME_KEYS = new Set(PRINT_NOTIFICATION_FIELD_MATRIX.map(r => r.field));
-export function taskNotificationToPrintFrame(n, identity = {}) {
+export function taskNotificationToPrintFrame(raw, identity = {}) {
+    const n = ownSnapshotRecord(raw);
+    if (n === undefined)
+        return null;
     const f = normalizeTaskNotification(n);
     if (f === null)
         return null;

package/dist/request/submissionIdentity.d.ts

@@ -0,0 +1,37 @@
+import type { RequestLane } from './taskRequest.js';
+export type RejectedSubmissionOrigin = 'user' | 'injected';
+export declare const SUBMISSION_SURFACES: readonly ["interactive", "print"];
+export type SubmissionSurface = (typeof SUBMISSION_SURFACES)[number];
+export declare const SUBMISSION_ORIGINS: readonly ["user", "injected", "shell"];
+export type SubmissionOrigin = (typeof SUBMISSION_ORIGINS)[number];
+export declare const SUBMISSION_TOOLS: readonly ["full", "none"];
+export type SubmissionTools = (typeof SUBMISSION_TOOLS)[number];
+export interface SubmissionIdentity {
+    readonly surface: SubmissionSurface;
+    readonly origin: SubmissionOrigin;
+    readonly tools: SubmissionTools;
+}
+export declare const SUBMISSION_KINDS: readonly ["keyboard", "wake", "schedule", "plan_review_outcome", "shell_side"];
+export type SubmissionKind = (typeof SUBMISSION_KINDS)[number];
+export interface SubmissionProvenance {
+    readonly kind: SubmissionKind;
+    readonly origin: SubmissionOrigin;
+    readonly authoredByUser: boolean;
+    readonly source?: 'objective' | 'resume_message';
+    readonly selfHealOrigin?: RejectedSubmissionOrigin;
+}
+export declare function submissionProvenanceOf(kind: SubmissionKind): SubmissionProvenance | undefined;
+export interface SubmissionIdentityInput {
+    readonly surface: SubmissionSurface;
+    readonly kind: SubmissionKind;
+    readonly tools: SubmissionTools;
+}
+export declare function submissionIdentityOf(input: SubmissionIdentityInput): SubmissionIdentity | undefined;
+export declare function requestLaneOf(identity: SubmissionIdentity): RequestLane | undefined;
+export declare function submissionOriginOf(identity: SubmissionIdentity): SubmissionOrigin | undefined;
+export declare function submissionSurfaceOf(identity: {} | null | undefined): SubmissionSurface | undefined;
+export interface SubmissionAxes {
+    readonly lane: RequestLane;
+    readonly origin: SubmissionOrigin;
+}
+export declare function submissionAxesOf(x: object): SubmissionAxes | undefined;

package/dist/request/submissionIdentity.js

@@ -0,0 +1,65 @@
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
+export const SUBMISSION_SURFACES = Object.freeze(['interactive', 'print']);
+export const SUBMISSION_ORIGINS = Object.freeze(['user', 'injected', 'shell']);
+export const SUBMISSION_TOOLS = Object.freeze(['full', 'none']);
+export const SUBMISSION_KINDS = Object.freeze(['keyboard', 'wake', 'schedule', 'plan_review_outcome', 'shell_side']);
+const PROVENANCE_ROWS = Object.freeze({
+    keyboard: { origin: 'user', source: 'objective', selfHealOrigin: 'user' },
+    wake: { origin: 'user', source: 'resume_message', selfHealOrigin: 'injected' },
+    schedule: { origin: 'user', source: 'resume_message', selfHealOrigin: 'injected' },
+    plan_review_outcome: { origin: 'injected', selfHealOrigin: 'injected' },
+    shell_side: { origin: 'shell' },
+});
+const PROVENANCE = Object.freeze(Object.fromEntries(SUBMISSION_KINDS.map((kind) => {
+    const row = PROVENANCE_ROWS[kind];
+    const p = Object.freeze({
+        kind,
+        origin: row.origin,
+        authoredByUser: row.origin === 'user',
+        ...(row.source !== undefined ? { source: row.source } : {}),
+        ...(row.selfHealOrigin !== undefined ? { selfHealOrigin: row.selfHealOrigin } : {}),
+    });
+    return [kind, p];
+})));
+const memberOf = (set, v) => typeof v === 'string' && set.includes(v);
+const slotOf = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+const isCarrier = (x) => typeof x === 'object' && x !== null && guardedRead(() => !Array.isArray(x)) === true;
+export function submissionProvenanceOf(kind) {
+    return typeof kind === 'string' && Object.hasOwn(PROVENANCE, kind) ? PROVENANCE[kind] : undefined;
+}
+export function submissionIdentityOf(input) {
+    if (!isCarrier(input))
+        return undefined;
+    const surface = slotOf(input, 'surface');
+    const kind = slotOf(input, 'kind');
+    const tools = slotOf(input, 'tools');
+    if (!memberOf(SUBMISSION_SURFACES, surface) || !memberOf(SUBMISSION_KINDS, kind) || !memberOf(SUBMISSION_TOOLS, tools))
+        return undefined;
+    const provenance = submissionProvenanceOf(kind);
+    return provenance === undefined ? undefined : Object.freeze({ surface, origin: provenance.origin, tools });
+}
+const identitySnapshotOf = (x) => {
+    if (!isCarrier(x))
+        return undefined;
+    const surface = slotOf(x, 'surface');
+    const origin = slotOf(x, 'origin');
+    const tools = slotOf(x, 'tools');
+    return memberOf(SUBMISSION_SURFACES, surface) && memberOf(SUBMISSION_ORIGINS, origin) && memberOf(SUBMISSION_TOOLS, tools)
+        ? Object.freeze({ surface, origin, tools })
+        : undefined;
+};
+const laneOfIdentity = (id) => id.surface === 'print' ? 'print' : id.origin === 'shell' && id.tools === 'none' ? 'utility' : 'interactive';
+export function requestLaneOf(identity) {
+    const id = identitySnapshotOf(identity);
+    return id === undefined ? undefined : laneOfIdentity(id);
+}
+export function submissionOriginOf(identity) {
+    return identitySnapshotOf(identity)?.origin;
+}
+export function submissionSurfaceOf(identity) {
+    return typeof identity === 'object' && identity !== null ? identitySnapshotOf(identity)?.surface : undefined;
+}
+export function submissionAxesOf(x) {
+    const id = identitySnapshotOf(x);
+    return id === undefined ? undefined : Object.freeze({ lane: laneOfIdentity(id), origin: id.origin });
+}