@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/hostTurnSettings.js

@@ -0,0 +1,692 @@
+import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
+import { hooksWirePlanShapeOf } from './pluginHooksWire.js';
+import { resolveWebSearchVerdict, webSearchVerdictMessage } from './webSearchWireCaps.js';
+import { fileHistoryTightenVerdict, fileHistoryUnjudgedRefusal } from './fileHistoryCaptureCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
+export const HOST_SETTING_CAUSES = Object.freeze([
+    'carried',
+    'entries_dropped',
+    'source_rejected',
+    'projection_failed',
+    'source_unreadable',
+    'empty',
+    'no_source',
+    'host_port_missing',
+    'value_malformed',
+]);
+export const HOST_SETTING_DISPOSITIONS = Object.freeze(['carry', 'carry_partial', 'withhold_notice', 'refuse_turn', 'unwired', 'nothing_to_carry']);
+const HOST_SETTING_NOTICE_TEXT = {
+    'HS-UNWIRED': (what) => `This app has not connected ${what} from your settings, so it is not sent with your requests.`,
+    'HS-MANAGED-REJECTED': () => 'Managed settings: the hooks your administrator configured could not be loaded, so requests are not sent until the managed settings are fixed.',
+    'HS-PROJECTION': () => 'The hooks for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
+    'HS-SOURCE-UNREADABLE': (what) => `This app could not read ${what} from your settings, so the request is not sent. Reload your settings and try again.`,
+    'HS-WEBSEARCH-MALFORMED': (sentence) => sentence,
+    'HS-SWITCH-MALFORMED': () => renderMessage(msg('session.hostSettings.memorySwitchMalformed')),
+    'HS-FILEHISTORY-UNJUDGED': (sentence) => sentence,
+};
+const KEY_NOUN = {
+    'settings.hooks': 'the hooks',
+    'settings.resolved': 'the permission rules',
+    'settings.webSearch': 'the web search setup',
+    'settings.outputStyle': 'the output style',
+    memory: 'auto-memory',
+    fileHistory: 'file checkpoints',
+};
+const BASE_DISPOSITION = {
+    carried: 'carry',
+    entries_dropped: 'carry_partial',
+    source_rejected: 'withhold_notice',
+    projection_failed: 'refuse_turn',
+    source_unreadable: 'refuse_turn',
+    empty: 'nothing_to_carry',
+    no_source: 'nothing_to_carry',
+    host_port_missing: 'unwired',
+    value_malformed: 'refuse_turn',
+};
+const freeze = (o) => Object.freeze(o);
+const mint = (o) => o;
+const notice = (id, plane, what = '') => freeze({ id, plane, text: HOST_SETTING_NOTICE_TEXT[id](what) });
+function readSource(sources, key) {
+    try {
+        if (typeof sources !== 'object' || sources === null || !Object.hasOwn(sources, key))
+            return { kind: 'missing' };
+        const v = sources[key];
+        return v === undefined ? { kind: 'missing' } : { kind: 'value', value: v };
+    }
+    catch {
+        return { kind: 'threw' };
+    }
+}
+function unwrap(v, field) {
+    if (v === 'none')
+        return { kind: 'none' };
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v) || !Object.hasOwn(v, field))
+            return { kind: 'bad' };
+        return { kind: 'value', value: v[field] };
+    }
+    catch {
+        return { kind: 'bad' };
+    }
+}
+const isRecordShape = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function hooksPassJudge(wire) {
+    try {
+        return isRecordShape(wire) && SETTINGS_CLASSIFY_HOOKS_CONFIG({ hooks: wire }).outcome === 'loaded';
+    }
+    catch {
+        return false;
+    }
+}
+class HostSourceShapeError extends TypeError {
+    code = 'host_source_shape';
+}
+function badSource(key, want) {
+    return new HostSourceShapeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
+}
+const missingArm = (key) => ({
+    row: freeze({ key, cause: 'host_port_missing', disposition: BASE_DISPOSITION.host_port_missing }),
+    notices: [notice('HS-UNWIRED', 'session', KEY_NOUN[key])],
+});
+const unreadableArm = (key) => ({
+    row: freeze({ key, cause: 'source_unreadable', disposition: BASE_DISPOSITION.source_unreadable }),
+    notices: [notice('HS-SOURCE-UNREADABLE', 'turn', KEY_NOUN[key])],
+});
+const noSourceArm = (key) => ({ row: freeze({ key, cause: 'no_source', disposition: BASE_DISPOSITION.no_source }), notices: [] });
+const carriedArm = (key, value) => ({ row: freeze({ key, cause: 'carried', disposition: BASE_DISPOSITION.carried }), notices: [], carried: value });
+function hooksArm(src) {
+    const key = 'settings.hooks';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const u = unwrap(src.value, 'plan');
+    if (u.kind === 'none')
+        return noSourceArm(key);
+    if (u.kind === 'bad' || hooksWirePlanShapeOf(u.value) !== 'plan')
+        throw badSource(key, '{ plan } with the plan returned by hooksWirePlan() for this turn');
+    const plan = u.value;
+    let wire;
+    let salvageRows;
+    let closedBy;
+    try {
+        wire = plan.wire;
+        salvageRows = plan.settingsSalvage;
+        closedBy = plan.closedBy;
+    }
+    catch {
+        throw badSource(key, '{ plan } with a readable plan');
+    }
+    const rows = Array.isArray(salvageRows) ? salvageRows : [];
+    const layersOf = (outcome) => rows.filter((r) => isRecordShape(r) && r.outcome === outcome && typeof r.source === 'string').map((r) => r.source);
+    const managedRejected = layersOf('rejected').includes('policySettings');
+    if (managedRejected || layersOf('loaded-partial').includes('policySettings')) {
+        return {
+            row: freeze({ key, cause: managedRejected ? 'source_rejected' : 'entries_dropped', disposition: 'refuse_turn', layers: freeze(['policySettings']) }),
+            notices: [notice('HS-MANAGED-REJECTED', 'turn')],
+            plan,
+        };
+    }
+    if (closedBy === 'governance_unreadable')
+        return { ...unreadableArm(key), plan };
+    if (wire !== undefined && !hooksPassJudge(wire)) {
+        return { row: freeze({ key, cause: 'projection_failed', disposition: BASE_DISPOSITION.projection_failed }), notices: [notice('HS-PROJECTION', 'turn')], plan };
+    }
+    const carried = wire === undefined ? undefined : wire;
+    const rejected = layersOf('rejected');
+    const partial = layersOf('loaded-partial');
+    if (rejected.length > 0 || partial.length > 0) {
+        const cause = rejected.length > 0 ? 'source_rejected' : 'entries_dropped';
+        const layers = freeze([...new Set([...rejected, ...partial])]);
+        return { row: freeze({ key, cause, disposition: carried !== undefined ? 'carry_partial' : 'withhold_notice', layers }), notices: [], carried, plan };
+    }
+    if (carried === undefined)
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [], plan };
+    return { ...carriedArm(key, carried), plan };
+}
+function webSearchArm(src) {
+    const key = 'settings.webSearch';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let section;
+    let env;
+    let apiKeyFor;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'env') || Object.hasOwn(v, 'settings'))
+            throw badSource(key, "{ section, env } with the raw webSearch section of the settings and the environment (since 0.100.0 the entry judges it; do not pass the judged settings)");
+        section = v.section;
+        env = v.env;
+        apiKeyFor = v.apiKeyFor;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (!isRecordShape(env))
+        throw badSource(key, '{ section, env } where env is the environment record (pass {} where there is none)');
+    if (apiKeyFor !== undefined && typeof apiKeyFor !== 'function')
+        throw badSource(key, '{ section, env, apiKeyFor? } where apiKeyFor is a function');
+    const verdict = resolveWebSearchVerdict(env, section, apiKeyFor);
+    if (verdict.kind === 'absent')
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+    if (verdict.kind === 'honored')
+        return carriedArm(key, freeze({ ...verdict.settings }));
+    return {
+        row: freeze({ key, cause: 'value_malformed', disposition: BASE_DISPOSITION.value_malformed }),
+        notices: [notice('HS-WEBSEARCH-MALFORMED', 'turn', webSearchVerdictMessage(verdict, 'submit') ?? '')],
+    };
+}
+function memoryArm(src, judge) {
+    const key = 'memory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let flag;
+    let settingsMemory;
+    try {
+        if (!isRecordShape(v))
+            throw badSource(key, '{ flag?, settingsMemory? } with the --memory flag word and the memory section of the settings');
+        flag = v.flag;
+        settingsMemory = v.settingsMemory;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (judge({ flag }))
+        return carriedArm(key, 'off');
+    let bySettings;
+    try {
+        bySettings = judge({ settingsMemory });
+    }
+    catch {
+        return { row: freeze({ key, cause: 'value_malformed', disposition: 'withhold_notice' }), notices: [notice('HS-SWITCH-MALFORMED', 'session')] };
+    }
+    if (bySettings)
+        return carriedArm(key, 'off');
+    return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+}
+const UNOBSERVED_READING = Object.freeze({ kind: 'unobserved' });
+function fileHistoryReadingSnapshot(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return UNOBSERVED_READING;
+        const kind = reading.kind;
+        if (kind === 'present') {
+            const word = reading.word;
+            return Object.freeze({ kind, word });
+        }
+        return Object.freeze({ kind });
+    }
+    catch {
+        return UNOBSERVED_READING;
+    }
+}
+function fileHistoryArm(src) {
+    const key = 'fileHistory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let reading;
+    let captureOff;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'captureOff'))
+            throw badSource(key, '{ reading, captureOff } with the engine capability reading and the switch');
+        reading = v.reading;
+        captureOff = v.captureOff;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (typeof captureOff !== 'boolean')
+        throw badSource(key, '{ reading, captureOff } where captureOff is a boolean');
+    const snap = fileHistoryReadingSnapshot(reading);
+    const verdict = fileHistoryTightenVerdict(snap, captureOff);
+    if (verdict === 'declare')
+        return carriedArm(key, 'disabled');
+    if (verdict === 'unjudged') {
+        return {
+            row: freeze({ key, cause: 'value_malformed', disposition: 'refuse_turn' }),
+            notices: [notice('HS-FILEHISTORY-UNJUDGED', 'turn', fileHistoryUnjudgedRefusal(snap, true) ?? fileHistoryUnjudgedRefusal(UNOBSERVED_READING, true) ?? '')],
+        };
+    }
+    return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+}
+function passArm(key, field, src, want) {
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const u = unwrap(src.value, field);
+    if (u.kind === 'none')
+        return noSourceArm(key);
+    if (u.kind === 'bad')
+        throw badSource(key, want);
+    if (u.value === undefined || u.value === null)
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+    return carriedArm(key, u.value);
+}
+const RESOLVED_DEFERRED_ERROR = Symbol('hostTurnSettings.resolvedDeferredError');
+export function rethrowHostResolvedDeferred(product) {
+    const rec = product;
+    if (!Object.hasOwn(rec, RESOLVED_DEFERRED_ERROR))
+        return;
+    const box = rec[RESOLVED_DEFERRED_ERROR];
+    if (box !== undefined)
+        throw box.error;
+}
+export function buildHostTurnSettings(input, judges) {
+    const materialize = judges.materialize;
+    let sources;
+    let sourcesThrew = false;
+    try {
+        sources = input?.sources;
+    }
+    catch {
+        sourcesThrew = true;
+    }
+    const read = (key) => (sourcesThrew ? { kind: 'threw' } : readSource(sources, key));
+    const resolved = passArm('settings.resolved', 'snapshot', read('resolved'), '{ snapshot } with the resolver snapshot');
+    let resolvedCarried = resolved.carried;
+    let resolvedError;
+    if (resolvedCarried !== undefined) {
+        try {
+            resolvedCarried = materialize(resolvedCarried);
+        }
+        catch (error) {
+            resolvedError = freeze({ error });
+        }
+    }
+    const hooks = hooksArm(read('hooks'));
+    const webSearch = webSearchArm(read('webSearch'));
+    const outputStyle = passArm('settings.outputStyle', 'name', read('outputStyle'), '{ name } with the output style name');
+    const memory = memoryArm(read('memory'), judges.memoryOffDeclared);
+    const fileHistory = fileHistoryArm(read('fileHistory'));
+    const arms = [hooks, resolved, webSearch, outputStyle, memory, fileHistory];
+    const rows = freeze(arms.map((a) => a.row));
+    const notices = freeze(arms.flatMap((a) => a.notices));
+    const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
+    const verdict = refusal === undefined ? freeze({ kind: 'send' }) : freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notice('HS-PROJECTION', 'turn') });
+    const carried = freeze({
+        ...(hooks.carried !== undefined ? { hooks: hooks.carried } : {}),
+        ...(resolvedCarried !== undefined ? { resolved: resolvedCarried } : {}),
+        ...(webSearch.carried !== undefined ? { webSearch: webSearch.carried } : {}),
+        ...(outputStyle.carried !== undefined ? { outputStyle: outputStyle.carried } : {}),
+        ...(memory.carried !== undefined ? { memory: 'off' } : {}),
+        ...(fileHistory.carried !== undefined ? { fileHistory: 'disabled' } : {}),
+    });
+    const product = { verdict, rows, notices, hooks: hooks.plan, carried };
+    if (resolvedError !== undefined)
+        Object.defineProperty(product, RESOLVED_DEFERRED_ERROR, { value: resolvedError, enumerable: false });
+    return mint(freeze(product));
+}
+export function hostSettingsSelfCheck(product) {
+    try {
+        const rows = product.rows;
+        if (!Array.isArray(rows))
+            return HOST_SUPPLIED_KEYS;
+        const seen = new Set();
+        const out = [];
+        for (const r of rows) {
+            if (!isRecordShape(r) || typeof r.key !== 'string')
+                continue;
+            seen.add(r.key);
+            if (r.disposition === 'unwired' && HOST_SUPPLIED_KEYS.includes(r.key))
+                out.push(r.key);
+        }
+        for (const k of HOST_SUPPLIED_KEYS)
+            if (!seen.has(k) && !out.includes(k))
+                out.push(k);
+        return freeze(out);
+    }
+    catch {
+        return HOST_SUPPLIED_KEYS;
+    }
+}
+export const hostProjectionNotice = () => notice('HS-PROJECTION', 'turn');
+export class HostSettingsRefused extends Error {
+    notice;
+    constructor(n) {
+        super(n.text);
+        this.name = 'HostSettingsRefused';
+        this.notice = n;
+    }
+}
+const CARRYING = new Set(['carry', 'carry_partial']);
+function shapeOf(v) {
+    if (v === undefined || v === null)
+        return UNWIRED_HOST_TURN_SETTINGS;
+    try {
+        if (!isRecordShape(v))
+            return undefined;
+        for (const k of ['verdict', 'rows', 'notices', 'hooks', 'carried'])
+            if (!Object.hasOwn(v, k))
+                return undefined;
+        const rows = v.rows;
+        if (!Array.isArray(rows) || rows.length !== HOST_SUPPLIED_KEYS.length)
+            return undefined;
+        const keys = rows.map((r) => (isRecordShape(r) ? r.key : undefined));
+        if (!HOST_SUPPLIED_KEYS.every((k, i) => keys[i] === k))
+            return undefined;
+        if (!isRecordShape(v.carried) || !isRecordShape(v.verdict))
+            return undefined;
+        const product = v;
+        return product;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hostTurnSettingsOf(v, depth = 'full') {
+    const shaped = shapeOf(v);
+    if (depth === 'shape' || shaped === undefined || shaped === UNWIRED_HOST_TURN_SETTINGS)
+        return shaped;
+    try {
+        const view = shaped;
+        const p = view;
+        const rows = p.rows;
+        const carried = p.carried;
+        const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
+        if (Object.keys(carried).some((k) => !subs.includes(k)))
+            return undefined;
+        if (carried.memory !== undefined && carried.memory !== 'off')
+            return undefined;
+        if (carried.fileHistory !== undefined && carried.fileHistory !== 'disabled')
+            return undefined;
+        let refuses = false;
+        for (const [i, r] of rows.entries()) {
+            const disposition = r.disposition;
+            if (!HOST_SETTING_DISPOSITIONS.includes(disposition))
+                return undefined;
+            if (disposition === 'refuse_turn')
+                refuses = true;
+            const sub = subs[i] ?? '';
+            const has = Object.hasOwn(carried, sub) && carried[sub] !== undefined;
+            if (has !== CARRYING.has(disposition))
+                return undefined;
+        }
+        const verdict = p.verdict;
+        if (verdict.kind !== (refuses ? 'refuse' : 'send'))
+            return undefined;
+        if (refuses && !(isRecordShape(verdict.notice) && typeof verdict.notice.text === 'string'))
+            return undefined;
+        if (Object.hasOwn(carried, 'hooks') && carried.hooks !== undefined && !hooksPassJudge(carried.hooks))
+            return undefined;
+        return shaped;
+    }
+    catch {
+        return undefined;
+    }
+}
+function wireFormOf(v) {
+    const text = JSON.stringify(v);
+    return text === undefined ? undefined : JSON.parse(text);
+}
+function sameJson(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameJson(x, b[i]));
+    const ra = a;
+    const rb = b;
+    const ka = Object.keys(ra);
+    if (ka.length !== Object.keys(rb).length)
+        return false;
+    return ka.every((k) => Object.hasOwn(rb, k) && sameJson(ra[k], rb[k]));
+}
+function groupHead(g) {
+    if (!isRecordShape(g))
+        return undefined;
+    const head = {};
+    for (const k of Object.keys(g))
+        if (k !== 'hooks')
+            head[k] = g[k];
+    return head;
+}
+export function intersectHostHooks(sent, now) {
+    try {
+        return intersectHostHooksUnguarded(sent, now);
+    }
+    catch {
+        return { hooks: undefined, dropped: 0, judged: false };
+    }
+}
+function intersectHostHooksUnguarded(sentIn, nowIn) {
+    const sent = wireFormOf(sentIn);
+    const now = nowIn === undefined ? undefined : wireFormOf(nowIn);
+    const entriesOf = (cfg) => {
+        if (!isRecordShape(cfg))
+            return 0;
+        let n = 0;
+        for (const ev of Object.keys(cfg)) {
+            const groups = cfg[ev];
+            if (!Array.isArray(groups))
+                continue;
+            for (const g of groups)
+                if (isRecordShape(g) && Array.isArray(g.hooks))
+                    n += g.hooks.length;
+        }
+        return n;
+    };
+    const total = entriesOf(sent);
+    if (!isRecordShape(sent))
+        return { hooks: undefined, dropped: 0, judged: true };
+    if (!isRecordShape(now))
+        return { hooks: undefined, dropped: total, judged: true };
+    const out = {};
+    let kept = 0;
+    for (const ev of Object.keys(sent)) {
+        const groups = sent[ev];
+        const nowGroups = now[ev];
+        if (!Array.isArray(groups) || !Array.isArray(nowGroups))
+            continue;
+        const pool = nowGroups.map((g) => ({ head: groupHead(g), left: isRecordShape(g) && Array.isArray(g.hooks) ? [...g.hooks] : [] }));
+        const evOut = [];
+        for (const g of groups) {
+            const head = groupHead(g);
+            if (head === undefined || !isRecordShape(g) || !Array.isArray(g.hooks))
+                continue;
+            const keep = [];
+            for (const entry of g.hooks) {
+                for (const slot of pool) {
+                    if (slot.head === undefined || !sameJson(slot.head, head))
+                        continue;
+                    const at = slot.left.findIndex((x) => sameJson(x, entry));
+                    if (at < 0)
+                        continue;
+                    slot.left.splice(at, 1);
+                    keep.push(entry);
+                    break;
+                }
+            }
+            if (keep.length > 0)
+                evOut.push({ ...head, hooks: keep });
+            kept += keep.length;
+        }
+        if (evOut.length > 0)
+            out[ev] = evOut;
+    }
+    const hooks = Object.keys(out).length > 0 ? out : undefined;
+    return { hooks, dropped: total - kept, judged: hooks === undefined || hooksPassJudge(hooks) };
+}
+function ownDataOf(o, k) {
+    try {
+        if (typeof o !== 'object' || o === null)
+            return { ok: false };
+        const d = Object.getOwnPropertyDescriptor(o, k);
+        if (d === undefined)
+            return { ok: true, value: undefined };
+        if (!('value' in d))
+            return { ok: false };
+        return { ok: true, value: d.value };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function noticeCopyOf(n) {
+    const id = ownDataOf(n, 'id');
+    const plane = ownDataOf(n, 'plane');
+    const text = ownDataOf(n, 'text');
+    if (!id.ok || !plane.ok || !text.ok || typeof id.value !== 'string' || typeof plane.value !== 'string' || typeof text.value !== 'string')
+        return undefined;
+    return freeze({ id: id.value, plane: plane.value, text: text.value });
+}
+function turnNoticesOf(product) {
+    try {
+        return turnNoticesUnguarded(product);
+    }
+    catch {
+        return undefined;
+    }
+}
+function turnNoticesUnguarded(product) {
+    const ns = ownDataOf(product, 'notices');
+    if (!ns.ok || !Array.isArray(ns.value))
+        return undefined;
+    const len = ownDataOf(ns.value, 'length');
+    if (!len.ok || typeof len.value !== 'number')
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len.value; i++) {
+        const e = ownDataOf(ns.value, String(i));
+        const copy = e.ok ? noticeCopyOf(e.value) : undefined;
+        if (copy === undefined)
+            return undefined;
+        if (copy.plane === 'turn')
+            out.push(copy);
+    }
+    return freeze(out);
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null) {
+        for (const x of Object.values(v))
+            deepFreeze(x);
+        Object.freeze(v);
+    }
+    return v;
+}
+export function hostIntakeSnapshotOf(product, onResolved) {
+    try {
+        return intakeSnapshotUnguarded(product, onResolved);
+    }
+    catch {
+        return undefined;
+    }
+}
+function intakeSnapshotUnguarded(product, onResolved) {
+    if (product === UNWIRED_HOST_TURN_SETTINGS) {
+        return freeze({
+            carried: freeze({}),
+            refuses: false,
+            dispositions: freeze(Object.fromEntries(HOST_SUPPLIED_KEYS.map((k) => [k, 'unwired']))),
+            refusingKeys: freeze([]),
+            turnNotices: freeze([]),
+            notice: undefined,
+        });
+    }
+    const c = ownDataOf(product, 'carried');
+    if (!c.ok || !isRecordShape(c.value))
+        return undefined;
+    const carriedIn = c.value;
+    const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
+    let keys;
+    try {
+        keys = Reflect.ownKeys(carriedIn);
+    }
+    catch {
+        return undefined;
+    }
+    if (keys.some((k) => typeof k !== 'string' || !subs.includes(k)))
+        return undefined;
+    const values = {};
+    const resolvedR = ownDataOf(carriedIn, 'resolved');
+    if (!resolvedR.ok)
+        return undefined;
+    onResolved?.(resolvedR.value);
+    if (resolvedR.value !== undefined)
+        values.resolved = resolvedR.value;
+    for (const sub of subs.filter((x) => x !== 'resolved')) {
+        const r = ownDataOf(carriedIn, sub);
+        if (!r.ok)
+            return undefined;
+        const copy = deepFreeze(wireFormOf(r.value));
+        if (copy !== undefined)
+            values[sub] = copy;
+    }
+    const rowsR = ownDataOf(product, 'rows');
+    if (!rowsR.ok || !Array.isArray(rowsR.value) || rowsR.value.length !== HOST_SUPPLIED_KEYS.length)
+        return undefined;
+    let refuses = false;
+    const refusingKeys = [];
+    const dispositions = {};
+    for (const [i, key] of HOST_SUPPLIED_KEYS.entries()) {
+        const rowR = ownDataOf(rowsR.value, String(i));
+        if (!rowR.ok)
+            return undefined;
+        const k = ownDataOf(rowR.value, 'key');
+        const d = ownDataOf(rowR.value, 'disposition');
+        if (!k.ok || !d.ok || k.value !== key || !HOST_SETTING_DISPOSITIONS.includes(d.value))
+            return undefined;
+        if (d.value === 'refuse_turn') {
+            refuses = true;
+            refusingKeys.push(key);
+        }
+        dispositions[key] = d.value;
+        if ((values[carriedKeyOf(key)] !== undefined) !== CARRYING.has(d.value))
+            return undefined;
+    }
+    if (values.memory !== undefined && values.memory !== 'off')
+        return undefined;
+    if (values.fileHistory !== undefined && values.fileHistory !== 'disabled')
+        return undefined;
+    if (values.hooks !== undefined && !hooksPassJudge(values.hooks))
+        return undefined;
+    const v = ownDataOf(product, 'verdict');
+    if (!v.ok)
+        return undefined;
+    const kind = ownDataOf(v.value, 'kind');
+    if (!kind.ok || kind.value !== (refuses ? 'refuse' : 'send'))
+        return undefined;
+    const noticeR = refuses ? ownDataOf(v.value, 'notice') : undefined;
+    const notice = noticeR === undefined ? undefined : ((noticeR.ok ? noticeCopyOf(noticeR.value) : undefined) ?? hostProjectionNotice());
+    return freeze({
+        carried: freeze(values),
+        refuses,
+        dispositions: freeze(dispositions),
+        refusingKeys: freeze(refusingKeys),
+        turnNotices: turnNoticesOf(product),
+        notice,
+    });
+}
+export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {} }, {
+    materialize: (snapshot) => snapshot,
+    memoryOffDeclared: () => false,
+});
+function carriedKeyOf(k) {
+    return k.startsWith('settings.') ? k.slice('settings.'.length) : k;
+}
+const _armsPin = [true, true, true, true];
+void _armsPin;