@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/hostSettingsSource.js

@@ -0,0 +1,675 @@
+import { appendOwnElement } from './ownKey.js';
+import { SETTINGS_WORKSPACE_TRUST_STATES } from './generated/settingsSchemaTables.js';
+import { jsonFaithfulCost, materializeJsonFaithful } from './jsonFaithful.js';
+import { faultText } from './hostCallbackGuard.js';
+export const HOST_SETTINGS_LAYERS = Object.freeze(['policySettings', 'userSettings', 'projectSettings', 'localSettings', 'flagSettings']);
+export const MANAGED_POLICY_STATES = Object.freeze(['absent', 'in-effect', 'in-effect-pieces', 'unreadable-covered', 'unreadable-uncovered', 'remote-unknown']);
+export const HOST_STARTUP_MODES = Object.freeze(['safe', 'bare', 'none']);
+export const HOST_SETTINGS_CARRIER_STATUSES = Object.freeze(['loaded', 'loaded-partial', 'empty', 'absent', 'unreadable', 'not-loaded']);
+export const HOST_SETTINGS_EMPTY_KINDS = Object.freeze(['zero-byte', 'whitespace', 'empty-object']);
+const MEMBERS = ['readLayer', 'workspaceTrust', 'managedPolicyReading', 'startupMode', 'enabledPluginHooks', 'sessionHooks'];
+export class HostSettingsSourceShapeError extends TypeError {
+    code = 'host_settings_source_shape';
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function shortShape(v) {
+    try {
+        if (v === null)
+            return 'null';
+        if (typeof v === 'string')
+            return JSON.stringify(v.length > 40 ? `${v.slice(0, 40)}…` : v);
+        return Array.isArray(v) ? 'array' : typeof v;
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function isRecordSafe(v) {
+    try {
+        return isRecord(v);
+    }
+    catch {
+        return false;
+    }
+}
+function ownData(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 (!Object.hasOwn(d, 'value'))
+            return { ok: false };
+        return { ok: true, value: d.value };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+export const SETTINGS_READ_BUDGET = 250_000;
+export const HOST_SETTINGS_STATE_BUDGET = 4 * SETTINGS_READ_BUDGET;
+export const SETTINGS_MAX_CARRIERS_PER_LAYER = 1024;
+export const SETTINGS_MAX_ISSUES_PER_CARRIER = 4096;
+const SESSION_CALLBACK_LEAF = (captured, key) => key === 'callback' && (captured.type === 'callback' || captured.type === 'function');
+function sessionFunctionsAtRegistrations(v, path = []) {
+    if (typeof v === 'function') {
+        return path.length === 8 && path[0] === 'sources' && typeof path[1] === 'number' && path[2] === 'hooks' && typeof path[3] === 'string' &&
+            typeof path[4] === 'number' && path[5] === 'hooks' && typeof path[6] === 'number' && path[7] === 'callback';
+    }
+    if (v === null || typeof v !== 'object')
+        return true;
+    if (Array.isArray(v))
+        return v.every((x, i) => sessionFunctionsAtRegistrations(x, [...path, i]));
+    return Object.keys(v).every((k) => sessionFunctionsAtRegistrations(v[k], [...path, k]));
+}
+function captureSettingsValue(v, budget, kind = 'settings') {
+    try {
+        const guard = kind === 'state' ? { budget } : { budget, visited: new WeakSet() };
+        const r = materializeJsonFaithful(v, 'settings', new Set(), kind === 'session' ? { guard, functionLeaf: SESSION_CALLBACK_LEAF } : kind === 'state' ? { guard, undefinedIsBad: true } : { guard });
+        if ('bad' in r)
+            return { ok: false };
+        if (kind === 'session' && !sessionFunctionsAtRegistrations(r.value))
+            return { ok: false };
+        return { ok: true, value: deepFreeze(r.value) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function ownArrayItems(v, max, budget) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        if (--budget.left < 0)
+            return undefined;
+        const ld = Object.getOwnPropertyDescriptor(v, 'length');
+        if (ld === undefined || !Object.hasOwn(ld, 'value') || typeof ld.value !== 'number' || !Number.isSafeInteger(ld.value) || ld.value < 0 || ld.value > max)
+            return undefined;
+        const len = ld.value;
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            budget.left -= 2;
+            if (budget.left < 0)
+                return undefined;
+            const d = Object.getOwnPropertyDescriptor(v, i);
+            if (d === undefined || !Object.hasOwn(d, 'value'))
+                return undefined;
+            appendOwnElement(out, d.value);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null && !Object.isFrozen(v)) {
+        for (const k of Reflect.ownKeys(v))
+            deepFreeze(v[k]);
+        Object.freeze(v);
+    }
+    return v;
+}
+const MALFORMED_LAYER = (layer) => Object.freeze({
+    layer,
+    enabled: true,
+    outcome: 'unreadable',
+    doc: null,
+    carriers: Object.freeze([Object.freeze({ id: `${layer}|reading`, status: 'unreadable' })]),
+    issues: Object.freeze([]),
+    malformed: true,
+});
+export function combineCarrierStatuses(carriers) {
+    const has = (st) => carriers.some((c) => c.status === st);
+    if (has('unreadable'))
+        return 'unreadable';
+    if (has('not-loaded'))
+        return 'not-loaded';
+    if (has('loaded-partial'))
+        return 'loaded-partial';
+    if (has('loaded'))
+        return 'loaded';
+    if (has('empty'))
+        return 'empty';
+    return 'absent';
+}
+function carrierOf(c, budget) {
+    budget.left -= 8;
+    if (budget.left < 0)
+        return undefined;
+    const id = ownData(c, 'id');
+    const st = ownData(c, 'status');
+    const ek = ownData(c, 'emptyKind');
+    const is = ownData(c, 'issues');
+    if (!id.ok || !st.ok || !ek.ok || !is.ok || typeof id.value !== 'string' || id.value.length === 0)
+        return undefined;
+    const status = HOST_SETTINGS_CARRIER_STATUSES.find((x) => x === st.value);
+    if (status === undefined)
+        return undefined;
+    let emptyKind;
+    if (status === 'empty') {
+        emptyKind = HOST_SETTINGS_EMPTY_KINDS.find((x) => x === ek.value);
+        if (emptyKind === undefined)
+            return undefined;
+    }
+    else if (ek.value !== undefined)
+        return undefined;
+    let issues;
+    if (is.value !== undefined) {
+        const items = ownArrayItems(is.value, SETTINGS_MAX_ISSUES_PER_CARRIER, budget);
+        if (items === undefined || !items.every((x) => typeof x === 'string'))
+            return undefined;
+        issues = Object.freeze(items);
+    }
+    if (status === 'loaded-partial' && (issues === undefined || issues.length === 0))
+        return undefined;
+    return Object.freeze({ id: id.value, status, ...(emptyKind !== undefined ? { emptyKind } : {}), ...(issues !== undefined ? { issues } : {}) });
+}
+function layerSnapshotOf(layer, r, budget) {
+    budget.left -= 3;
+    if (budget.left < 0)
+        return MALFORMED_LAYER(layer);
+    const en = ownData(r, 'enabled');
+    if (!en.ok || typeof en.value !== 'boolean')
+        return MALFORMED_LAYER(layer);
+    if (!en.value) {
+        return Object.freeze({ layer, enabled: false, outcome: 'absent', doc: null, carriers: Object.freeze([]), issues: Object.freeze([]), malformed: false });
+    }
+    const docIn = ownData(r, 'doc');
+    const cs = ownData(r, 'carriers');
+    if (!docIn.ok || !(docIn.value === null || isRecordSafe(docIn.value)) || !cs.ok)
+        return MALFORMED_LAYER(layer);
+    let docCopy = null;
+    if (docIn.value !== null) {
+        const c = captureSettingsValue(docIn.value, budget);
+        if (!c.ok || !isRecord(c.value))
+            return MALFORMED_LAYER(layer);
+        docCopy = c.value;
+    }
+    const doc = { ok: true, value: docCopy };
+    const carriers = [];
+    const items = ownArrayItems(cs.value, SETTINGS_MAX_CARRIERS_PER_LAYER, budget);
+    if (items === undefined)
+        return MALFORMED_LAYER(layer);
+    const seenIds = new Set();
+    for (const item of items) {
+        const c = carrierOf(item, budget);
+        if (c === undefined || seenIds.has(c.id))
+            return MALFORMED_LAYER(layer);
+        seenIds.add(c.id);
+        appendOwnElement(carriers, c);
+    }
+    const outcome = combineCarrierStatuses(carriers);
+    const anyLoaded = carriers.some((c) => c.status === 'loaded' || c.status === 'loaded-partial');
+    let docKeys;
+    try {
+        docKeys = doc.value === null ? 0 : Reflect.ownKeys(doc.value).length;
+    }
+    catch {
+        return MALFORMED_LAYER(layer);
+    }
+    if (anyLoaded ? doc.value === null : docKeys > 0)
+        return MALFORMED_LAYER(layer);
+    const issues = carriers.flatMap((c) => (c.issues ?? []).map((x) => JSON.stringify([c.id, x])));
+    return Object.freeze({
+        layer,
+        enabled: true,
+        outcome,
+        doc: doc.value,
+        carriers: Object.freeze(carriers),
+        issues: Object.freeze(issues),
+        malformed: false,
+    });
+}
+export function readHostSettingsOnce(source, who) {
+    if (typeof source === 'object' && source !== null) {
+        const replayed = REPLAYS.get(source);
+        if (replayed !== undefined)
+            return replayed;
+    }
+    if (!isRecordSafe(source) && typeof source !== 'function') {
+        throw new HostSettingsSourceShapeError(`${who}: settings must be a HostSettingsSource (an object with ${MEMBERS.join(' / ')}) — got ${shortShape(source)}.`);
+    }
+    const methods = {};
+    for (const name of MEMBERS) {
+        let m;
+        try {
+            m = source[name];
+        }
+        catch {
+            throw new HostSettingsSourceShapeError(`${who}: reading the settings source member ${name} threw — every member of HostSettingsSource is required and must be a method.`);
+        }
+        if (typeof m !== 'function') {
+            throw new HostSettingsSourceShapeError(`${who}: the settings source member ${name} is ${m === undefined ? 'missing' : `not a method (got ${shortShape(m)})`} — every member of HostSettingsSource is required (answer 'none' / { state: 'absent' } where there is nothing).`);
+        }
+        methods[name] = m;
+    }
+    const call = (name, ...args) => {
+        try {
+            return { ok: true, value: methods[name].call(source, ...args) };
+        }
+        catch (err) {
+            return { ok: false, err };
+        }
+    };
+    const debug = [];
+    const budget = { left: SETTINGS_READ_BUDGET };
+    const layers = {};
+    for (const layer of HOST_SETTINGS_LAYERS) {
+        const r = call('readLayer', layer);
+        if (!r.ok) {
+            appendOwnElement(debug, `hostSettings: readLayer(${layer}) threw — this layer is read as unreadable: ${faultText(r.err)}`);
+            layers[layer] = MALFORMED_LAYER(layer);
+            continue;
+        }
+        let snap;
+        try {
+            snap = layerSnapshotOf(layer, r.value, budget);
+        }
+        catch {
+            snap = MALFORMED_LAYER(layer);
+        }
+        if (snap.malformed)
+            appendOwnElement(debug, `hostSettings: readLayer(${layer}) returned a malformed reading — this layer is read as unreadable`);
+        layers[layer] = snap;
+    }
+    let trust = 'unreadable';
+    {
+        const r = call('workspaceTrust');
+        if (!r.ok)
+            appendOwnElement(debug, `hostSettings: workspaceTrust() threw — hooks are not projected this turn (trust unknown): ${faultText(r.err)}`);
+        else {
+            const w = SETTINGS_WORKSPACE_TRUST_STATES.find((x) => x === r.value);
+            if (w === undefined)
+                appendOwnElement(debug, `hostSettings: workspaceTrust() returned ${shortShape(r.value)}, none of ${SETTINGS_WORKSPACE_TRUST_STATES.join(' / ')} — hooks are not projected this turn (trust unknown)`);
+            else
+                trust = w;
+        }
+    }
+    let managed = 'unreadable-uncovered';
+    {
+        const r = call('managedPolicyReading');
+        if (!r.ok)
+            appendOwnElement(debug, `hostSettings: managedPolicyReading() threw — read as unreadable-uncovered: ${faultText(r.err)}`);
+        else {
+            const st = ownData(r.value, 'state');
+            const w = st.ok ? MANAGED_POLICY_STATES.find((x) => x === st.value) : undefined;
+            if (w === undefined)
+                appendOwnElement(debug, `hostSettings: managedPolicyReading() state is ${st.ok ? shortShape(st.value) : 'unreadable'}, none of ${MANAGED_POLICY_STATES.join(' / ')} — read as unreadable-uncovered`);
+            else
+                managed = w;
+        }
+    }
+    let startup = 'none';
+    {
+        const r = call('startupMode');
+        if (!r.ok)
+            appendOwnElement(debug, `hostSettings: startupMode() threw — read as 'none' (hooks not narrowed): ${faultText(r.err)}`);
+        else {
+            const w = HOST_STARTUP_MODES.find((x) => x === r.value);
+            if (w === undefined)
+                appendOwnElement(debug, `hostSettings: startupMode() returned ${shortShape(r.value)}, none of ${HOST_STARTUP_MODES.join(' / ')} — read as 'none' (hooks not narrowed)`);
+            else
+                startup = w;
+        }
+    }
+    let plugins = Object.freeze({ state: 'failed' });
+    {
+        const r = call('enabledPluginHooks');
+        if (!r.ok)
+            appendOwnElement(debug, `hostSettings: enabledPluginHooks() threw — no plugin hooks projected this turn: ${faultText(r.err)}`);
+        else if (r.value === 'none')
+            plugins = Object.freeze({ state: 'absent' });
+        else {
+            const c = isRecordSafe(r.value) ? captureSettingsValue(r.value, budget) : { ok: false };
+            const ps = c.ok ? ownData(c.value, 'plugins') : { ok: false };
+            if (c.ok && ps.ok && Array.isArray(ps.value))
+                plugins = Object.freeze({ state: 'present', reading: c.value });
+            else
+                appendOwnElement(debug, 'hostSettings: enabledPluginHooks() returned a malformed reading — no plugin hooks projected this turn');
+        }
+    }
+    let sessionHooks = Object.freeze({ state: 'failed' });
+    {
+        const r = call('sessionHooks');
+        if (!r.ok)
+            appendOwnElement(debug, `hostSettings: sessionHooks() threw — no session hooks judged this turn: ${faultText(r.err)}`);
+        else if (r.value === 'none')
+            sessionHooks = Object.freeze({ state: 'absent' });
+        else {
+            const c = isRecordSafe(r.value) ? captureSettingsValue(r.value, budget, 'session') : { ok: false };
+            const sources = c.ok ? ownData(c.value, 'sources') : { ok: false };
+            if (sources.ok && Array.isArray(sources.value))
+                sessionHooks = Object.freeze({ state: 'present', sources: sources.value });
+            else
+                appendOwnElement(debug, 'hostSettings: sessionHooks() returned a malformed reading — no session hooks judged this turn');
+        }
+    }
+    return Object.freeze({ layers: Object.freeze(layers), trust, managed, startup, plugins, sessionHooks, debug: Object.freeze(debug) });
+}
+const REPLAYS = new WeakMap();
+export function sourceOfRead(read) {
+    const quiet = read.debug.length === 0 ? read : Object.freeze({ ...read, debug: Object.freeze([]) });
+    const src = Object.freeze({
+        readLayer: (layer) => {
+            const snap = quiet.layers[layer];
+            return { enabled: snap.enabled, doc: snap.doc, carriers: snap.carriers };
+        },
+        workspaceTrust: () => {
+            if (quiet.trust === 'unreadable')
+                throw new HostSettingsSourceShapeError('hostSettings: replayed workspace trust reading was unreadable');
+            return quiet.trust;
+        },
+        managedPolicyReading: () => ({ state: quiet.managed }),
+        startupMode: () => quiet.startup,
+        enabledPluginHooks: () => (quiet.plugins.reading ?? 'none'),
+        sessionHooks: () => (quiet.sessionHooks.sources !== undefined ? { sources: quiet.sessionHooks.sources } : 'none'),
+    });
+    REPLAYS.set(src, quiet);
+    return src;
+}
+export function settingsValueOf(read, key) {
+    let out;
+    for (const layer of CC_MERGE_ORDER) {
+        const doc = read.layers[layer].doc;
+        if (doc === null)
+            continue;
+        const v = ownData(doc, key);
+        if (v.ok && v.value !== undefined)
+            out = v.value;
+    }
+    return out;
+}
+export function mergedBooleanOf(read, key) {
+    let out;
+    for (const layer of CC_MERGE_ORDER) {
+        const doc = read.layers[layer].doc;
+        if (doc === null)
+            continue;
+        const v = ownData(doc, key);
+        if (v.ok && typeof v.value === 'boolean')
+            out = v.value;
+    }
+    return out;
+}
+export const CC_MERGE_ORDER = Object.freeze(['userSettings', 'projectSettings', 'localSettings', 'flagSettings', 'policySettings']);
+export function nonManagedLayerDown(read) {
+    return HOST_SETTINGS_LAYERS.some((l) => {
+        if (l === 'policySettings')
+            return false;
+        const snap = read.layers[l];
+        return snap.malformed || snap.outcome === 'unreadable' || snap.outcome === 'not-loaded';
+    });
+}
+export const ADOPTED_LAYERS = Object.freeze(['userSettings', 'projectSettings', 'localSettings', 'flagSettings']);
+const GENESIS_VERSION = '0';
+export const parentVersionOf = (session) => (session.version === GENESIS_VERSION ? null : session.version);
+function canonicalOf(v) {
+    if (v === null || typeof v !== 'object')
+        return JSON.stringify(v) ?? 'null';
+    if (Array.isArray(v))
+        return `[${v.map(canonicalOf).join(',')}]`;
+    const keys = Object.keys(v).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalOf(v[k])}`).join(',')}}`;
+}
+function fingerprint64(text) {
+    let a = 0x811c9dc5;
+    let b = 0x050c5d1f;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        a = Math.imul(a ^ c, 0x01000193) >>> 0;
+        b = Math.imul(b ^ c, 0x01000193) >>> 0;
+        b = (b ^ (b >>> 13)) >>> 0;
+    }
+    return a.toString(16).padStart(8, '0') + b.toString(16).padStart(8, '0');
+}
+const VERSION_SHAPE = /^[1-9][0-9]{0,15}\.[0-9a-f]{16}$/;
+const generationOf = (version) => (version === null ? 0 : Number(version.slice(0, version.indexOf('.'))));
+const versionFor = (parent, consented, baseline) => `${generationOf(parent) + 1}.${fingerprint64(canonicalOf({ parent, consented, baseline }))}`;
+export function mintHostSettingsSession(parent, consented, baseline) {
+    const c = Object.freeze([...consented]);
+    if (jsonFaithfulCost({ version: '', parent, consented: c, baseline }) > HOST_SETTINGS_STATE_BUDGET)
+        return undefined;
+    return Object.freeze({ version: versionFor(parent, c, baseline), parent, consented: c, baseline });
+}
+export function remintSameContent(session) {
+    return mintHostSettingsSession(parentVersionOf(session), session.consented, session.baseline) ?? session;
+}
+export function hostSettingsSessionFollows(stored, next) {
+    const sv = stored === undefined ? { ok: true, value: null } : ownData(stored, 'version');
+    const np = ownData(next, 'parent');
+    return sv.ok && np.ok && (sv.value === null || typeof sv.value === 'string') && sv.value === np.value;
+}
+export const FIRST_SESSION = Object.freeze({ version: GENESIS_VERSION, parent: null, consented: Object.freeze([]), baseline: null });
+const isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string');
+const keysWithin = (v, allowed) => typeof v === 'object' && v !== null && Object.keys(v).every((k) => allowed.includes(k));
+const freezeArr = (a) => Object.freeze([...a]);
+export function sessionSnapshotOf(previous) {
+    if (previous === undefined)
+        return FIRST_SESSION;
+    const c = captureSettingsValue(previous, { left: HOST_SETTINGS_STATE_BUDGET }, 'state');
+    if (!c.ok || !isRecord(c.value))
+        return undefined;
+    const v = c.value;
+    if (!keysWithin(v, ['version', 'parent', 'consented', 'baseline']))
+        return undefined;
+    const version = v.version;
+    const parent = v.parent;
+    if (typeof version !== 'string' || !VERSION_SHAPE.test(version) || !(parent === null || (typeof parent === 'string' && VERSION_SHAPE.test(parent))) || !isStringArray(v.consented))
+        return undefined;
+    const verified = (baseline) => {
+        const s = mintHostSettingsSession(parent, v.consented, baseline);
+        return s !== undefined && s.version === version ? s : undefined;
+    };
+    if (v.baseline === null)
+        return verified(null);
+    const b = v.baseline;
+    if (!isRecord(b) || !isRecord(b.docs) || !isStringArray(b.loaded) || !isStringArray(b.issues) || !isRecord(b.cleanAllow) || !isRecord(b.cleanCarriers) || !isRecord(b.protecting))
+        return undefined;
+    if (!keysWithin(b, ['docs', 'loaded', 'issues', 'cleanAllow', 'cleanCarriers', 'protecting']) || !keysWithin(b.docs, ADOPTED_LAYERS) || !keysWithin(b.cleanAllow, ADOPTED_LAYERS) ||
+        !keysWithin(b.cleanCarriers, ADOPTED_LAYERS) || !keysWithin(b.protecting, ['deny', 'ask']))
+        return undefined;
+    const docs = {};
+    const cleanAllow = {};
+    const cleanCarriers = {};
+    for (const l of ADOPTED_LAYERS) {
+        const d = b.docs[l];
+        if (!(d === null || isRecord(d)))
+            return undefined;
+        docs[l] = d;
+        const a = b.cleanAllow[l];
+        const cc = b.cleanCarriers[l];
+        if (!isStringArray(a) || !isStringArray(cc))
+            return undefined;
+        cleanAllow[l] = a;
+        cleanCarriers[l] = cc;
+    }
+    const rulesOf = (x) => {
+        if (!Array.isArray(x))
+            return undefined;
+        const out = [];
+        for (const r of x) {
+            if (!isRecord(r) || !keysWithin(r, ['layer', 'rule']) || typeof r.rule !== 'string' || !ADOPTED_LAYERS.includes(r.layer))
+                return undefined;
+            appendOwnElement(out, Object.freeze({ layer: r.layer, rule: r.rule }));
+        }
+        return Object.freeze(out);
+    };
+    const pd = rulesOf(b.protecting.deny);
+    const pa = rulesOf(b.protecting.ask);
+    if (pd === undefined || pa === undefined)
+        return undefined;
+    const baseline = Object.freeze({
+        docs: Object.freeze(docs),
+        loaded: freezeArr(b.loaded),
+        issues: freezeArr(b.issues),
+        cleanAllow: Object.freeze(cleanAllow),
+        cleanCarriers: Object.freeze(cleanCarriers),
+        protecting: Object.freeze({ deny: pd, ask: pa }),
+    });
+    return verified(baseline);
+}
+const LOADED = new Set(['loaded', 'loaded-partial']);
+export function permissionRulesOf(doc, bucket) {
+    if (doc === null)
+        return [];
+    const p = ownData(doc, 'permissions');
+    if (!p.ok || !isRecord(p.value))
+        return [];
+    const b = ownData(p.value, bucket);
+    return b.ok && Array.isArray(b.value) ? b.value.filter((x) => typeof x === 'string') : [];
+}
+function overflowOf(read, session) {
+    return Object.freeze({ read, session: remintSameContent(session), trusted: false, clean: false, extraTighten: NO_EXTRA, allowByLayer: emptyByLayer(), overflow: true });
+}
+const carrierKeysOf = (read, layer) => read.layers[layer].carriers.map((c) => c.id);
+export function adoptHostSettingsRead(read, session, allowAdmitted = () => true) {
+    const B = session.baseline;
+    const stackIssues = ADOPTED_LAYERS.flatMap((l) => read.layers[l].issues.map((x) => `${l}|${x}`));
+    const loadedNow = ADOPTED_LAYERS.flatMap((l) => read.layers[l].malformed ? [] : read.layers[l].carriers.filter((c) => LOADED.has(c.status) || (c.status === 'empty' && c.emptyKind === 'empty-object')).map((c) => `${l}|${c.id}`));
+    const anyMalformed = ADOPTED_LAYERS.some((l) => read.layers[l].malformed);
+    const carrierState = new Map();
+    for (const l of ADOPTED_LAYERS)
+        for (const c of read.layers[l].carriers)
+            carrierState.set(`${l}|${c.id}`, c);
+    let trusted = true;
+    if (B !== null) {
+        const newIssue = stackIssues.some((x) => !B.issues.includes(x));
+        const lost = B.loaded.some((k) => {
+            const layer = k.slice(0, k.indexOf('|'));
+            if (read.layers[layer].malformed)
+                return true;
+            const c = carrierState.get(k);
+            if (c === undefined)
+                return true;
+            if (LOADED.has(c.status))
+                return false;
+            return !(c.status === 'empty' && c.emptyKind === 'empty-object');
+        });
+        trusted = !newIssue && !lost && !anyMalformed;
+    }
+    const anyDown = ADOPTED_LAYERS.some((l) => read.layers[l].carriers.some((c) => c.status === 'unreadable' || c.status === 'not-loaded' || c.status === 'loaded-partial'));
+    const clean = trusted && stackIssues.length === 0 && !anyDown && !anyMalformed;
+    const currentAllow = (l) => (allowAdmitted(l) ? permissionRulesOf(read.layers[l].doc, 'allow') : []);
+    const allowByLayer = {};
+    for (const l of ADOPTED_LAYERS) {
+        if (clean)
+            allowByLayer[l] = freezeArr(currentAllow(l));
+        else if (B === null)
+            allowByLayer[l] = Object.freeze([]);
+        else {
+            const sameCarriers = sameSet(B.cleanCarriers[l], carrierKeysOf(read, l));
+            allowByLayer[l] = sameCarriers ? freezeArr(currentAllow(l).filter((r) => B.cleanAllow[l].includes(r))) : Object.freeze([]);
+        }
+    }
+    const docsNow = {};
+    for (const l of ADOPTED_LAYERS)
+        docsNow[l] = read.layers[l].doc;
+    const voided = (B0) => {
+        const allow = {};
+        const carriers = {};
+        for (const l of ADOPTED_LAYERS) {
+            const same = sameSet(B0.cleanCarriers[l], carrierKeysOf(read, l));
+            allow[l] = same ? B0.cleanAllow[l] : Object.freeze([]);
+            carriers[l] = same ? B0.cleanCarriers[l] : Object.freeze([]);
+        }
+        return { allow: Object.freeze(allow), carriers: Object.freeze(carriers) };
+    };
+    const history = B === null ? undefined : voided(B);
+    const cleanAllowNext = clean ? Object.freeze({ ...allowByLayer }) : history?.allow ?? emptyByLayer();
+    const cleanCarriersNext = clean ? Object.freeze(Object.fromEntries(ADOPTED_LAYERS.map((l) => [l, freezeArr(carrierKeysOf(read, l))]))) : history?.carriers ?? emptyByLayer();
+    if (trusted) {
+        const baseline = Object.freeze({
+            docs: Object.freeze(docsNow),
+            loaded: freezeArr(loadedNow),
+            issues: freezeArr(stackIssues),
+            cleanAllow: cleanAllowNext,
+            cleanCarriers: cleanCarriersNext,
+            protecting: Object.freeze({ deny: Object.freeze([]), ask: Object.freeze([]) }),
+        });
+        const s = mintHostSettingsSession(parentVersionOf(session), session.consented, baseline);
+        if (s === undefined)
+            return overflowOf(read, session);
+        return Object.freeze({ read, session: s, trusted, clean, extraTighten: NO_EXTRA, allowByLayer: Object.freeze(allowByLayer) });
+    }
+    const base = B;
+    const inBase = (bucket, r) => permissionRulesOf(base.docs[r.layer], bucket).includes(r.rule);
+    const extra = (bucket) => {
+        const out = [];
+        const seen = new Set();
+        const push = (r) => {
+            const k = `${r.layer}|${r.rule}`;
+            if (seen.has(k) || inBase(bucket, r))
+                return;
+            seen.add(k);
+            appendOwnElement(out, Object.freeze(r));
+        };
+        for (const l of ADOPTED_LAYERS)
+            for (const rule of permissionRulesOf(read.layers[l].doc, bucket))
+                push({ layer: l, rule });
+        for (const r of base.protecting[bucket])
+            push(r);
+        return Object.freeze(out);
+    };
+    const extraTighten = Object.freeze({ deny: extra('deny'), ask: extra('ask') });
+    const baseline = Object.freeze({
+        docs: base.docs,
+        loaded: freezeArr([...new Set([...base.loaded, ...loadedNow])]),
+        issues: base.issues,
+        cleanAllow: cleanAllowNext,
+        cleanCarriers: cleanCarriersNext,
+        protecting: extraTighten,
+    });
+    const effectiveLayers = {};
+    for (const l of HOST_SETTINGS_LAYERS) {
+        const snap = read.layers[l];
+        effectiveLayers[l] = l === 'policySettings' ? snap : Object.freeze({ ...snap, doc: base.docs[l] });
+    }
+    const effective = Object.freeze({ ...read, layers: Object.freeze(effectiveLayers), current: read, debug: Object.freeze([]) });
+    const sentNow = (bucket) => new Set([...ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(base.docs[l], bucket)), ...extraTighten[bucket].map((r) => r.rule)]);
+    const readNow = (bucket) => new Set(ADOPTED_LAYERS.flatMap((l) => permissionRulesOf(read.layers[l].doc, bucket)));
+    const drop = (bucket) => Object.freeze([...sentNow(bucket)].filter((r) => !readNow(bucket).has(r)).sort());
+    const wouldDrop = Object.freeze({ deny: drop('deny'), ask: drop('ask') });
+    const acceptable = !stackIssues.some((x) => !base.issues.includes(x)) && !anyMalformed && !ADOPTED_LAYERS.some((l) => read.layers[l].carriers.some((c) => c.status === 'unreadable' || c.status === 'not-loaded'));
+    const s = mintHostSettingsSession(parentVersionOf(session), session.consented, baseline);
+    if (s === undefined)
+        return overflowOf(read, session);
+    const candidate = acceptable
+        ? mintHostSettingsSession(s.version, session.consented, Object.freeze({
+            docs: Object.freeze(docsNow),
+            loaded: freezeArr(loadedNow),
+            issues: freezeArr(stackIssues),
+            cleanAllow: cleanAllowNext,
+            cleanCarriers: cleanCarriersNext,
+            protecting: Object.freeze({ deny: Object.freeze([]), ask: Object.freeze([]) }),
+        }))
+        : undefined;
+    return Object.freeze({
+        read: effective,
+        session: s,
+        trusted,
+        clean,
+        extraTighten,
+        allowByLayer: Object.freeze(allowByLayer),
+        held: Object.freeze({ wouldDrop, ...(candidate !== undefined ? { candidate } : {}) }),
+    });
+}
+const NO_EXTRA = Object.freeze({ deny: Object.freeze([]), ask: Object.freeze([]) });
+const emptyByLayer = () => {
+    const out = {};
+    for (const l of ADOPTED_LAYERS)
+        out[l] = Object.freeze([]);
+    return Object.freeze(out);
+};
+const sameSet = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
+export const MANAGED_READING_DISPOSITIONS = Object.freeze({
+    absent: Object.freeze({ commit: 'proceed', ruleScope: 'all-sources', hooksRestriction: 'use-read', httpList: 'use-read' }),
+    'in-effect': Object.freeze({ commit: 'proceed', ruleScope: 'by-switch', hooksRestriction: 'use-read', httpList: 'use-read' }),
+    'in-effect-pieces': Object.freeze({ commit: 'proceed', ruleScope: 'degrade', hooksRestriction: 'use-read', httpList: 'use-read' }),
+    'unreadable-covered': Object.freeze({ commit: 'refuse', ruleScope: 'degrade', hooksRestriction: 'held-restrictions', httpList: 'use-read' }),
+    'unreadable-uncovered': Object.freeze({ commit: 'refuse', ruleScope: 'degrade', hooksRestriction: 'withhold', httpList: 'withhold' }),
+    'remote-unknown': Object.freeze({ commit: 'proceed', ruleScope: 'degrade', hooksRestriction: 'withhold', httpList: 'withhold' }),
+});
+const _hostSettingsPins = [true, true, true, true, true, true, true];
+void _hostSettingsPins;