@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/serverSupportRange.js

@@ -0,0 +1,25 @@
+import { engineSupportFloorEffective, engineVersionTier } from './supportFloor.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const SERVER_SUPPORT_RANGE_REASONS = Object.freeze(['below_floor', 'version_absent', 'version_unreadable']);
+export function serverSupportRangeVerdict(version) {
+    const floor = engineSupportFloorEffective();
+    const tier = engineVersionTier(version);
+    if (tier === 'engine')
+        return Object.freeze({ kind: 'in_range', floor });
+    if (tier === 'legacy')
+        return Object.freeze({ kind: 'out_of_range', reason: 'below_floor', version: version, floor });
+    return Object.freeze({ kind: 'unknown', reason: version === undefined ? 'version_absent' : 'version_unreadable', floor });
+}
+export function serverSupportRangeSentence(verdict, lang) {
+    try {
+        if (typeof verdict !== 'object' || verdict === null || verdict.kind !== 'out_of_range')
+            return undefined;
+        const again = serverSupportRangeVerdict(verdict.version);
+        if (again.kind !== 'out_of_range')
+            return undefined;
+        return renderMessage(msg('config.engineTarget.serverBelowSupportFloor', { version: again.version, floor: again.floor }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sessionEngine.d.ts

@@ -0,0 +1,156 @@
+import type { EngineRowReading } from './engineDirectory.js';
+import type { EngineTargetCloudAuth } from './seatContract.js';
+import { type SessionMapRecord, type SessionMapStorePort } from './sessionMap.js';
+import { type MessageRef } from './i18n/translate.js';
+export type SessionEngineKind = 'local' | 'cloud';
+export type SessionEngineIdentityKind = 'self' | 'declared' | 'address';
+export type SessionEngineBindingInput = {
+    readonly role: 'self';
+} | SessionEngineRowInput | {
+    readonly role: 'external';
+    readonly address: string;
+};
+export interface SessionEngineRowInput {
+    readonly role: 'external';
+    readonly row: EngineRowReading;
+    readonly center: string;
+}
+export type SessionEngineBindingFailure = 'row-incomplete' | 'center-invalid' | 'address-invalid' | 'input-invalid';
+export type SessionEngineSelfPresentation = Readonly<Record<string, never>>;
+export interface SessionEngineDeclaredPresentation {
+    readonly center: string;
+    readonly scope: string;
+    readonly name: string;
+}
+export interface SessionEngineAddressPresentation {
+    readonly address: string;
+}
+export type SessionEngineBindingOk = SessionEngineSelfBinding | SessionEngineDeclaredBinding | SessionEngineAddressBinding;
+export interface SessionEngineSelfBinding {
+    readonly ok: true;
+    readonly identityKind: 'self';
+    readonly key: string;
+    readonly presentation: SessionEngineSelfPresentation;
+}
+export interface SessionEngineDeclaredBinding {
+    readonly ok: true;
+    readonly identityKind: 'declared';
+    readonly key: string;
+    readonly presentation: SessionEngineDeclaredPresentation;
+    readonly connect: {
+        readonly viaCenter: string;
+    };
+}
+export interface SessionEngineAddressBinding {
+    readonly ok: true;
+    readonly identityKind: 'address';
+    readonly key: string;
+    readonly presentation: SessionEngineAddressPresentation;
+    readonly connect: {
+        readonly url: string;
+    };
+}
+export type SessionEngineBinding = SessionEngineBindingOk | {
+    readonly ok: false;
+    readonly reason: SessionEngineBindingFailure;
+};
+export interface SessionEngineAssignment {
+    readonly kind: SessionEngineKind;
+    readonly identity: SessionEngineBindingOk;
+}
+export type SessionEngineView = SessionEngineSelfView | SessionEngineDeclaredView | SessionEngineAddressView;
+export interface SessionEngineSelfView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'self';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineSelfPresentation;
+    };
+}
+export interface SessionEngineDeclaredView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'declared';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineDeclaredPresentation;
+    };
+}
+export interface SessionEngineAddressView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'address';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineAddressPresentation;
+    };
+}
+export type SessionEngineReading = SessionEngineBoundReading | {
+    readonly kind: 'legacy';
+} | {
+    readonly kind: 'unresolved';
+} | {
+    readonly kind: 'none';
+};
+export interface SessionEngineBoundReading {
+    readonly kind: 'bound';
+    readonly binding: SessionEngineAssignment;
+    readonly engine: SessionEngineView;
+    readonly uuid: string;
+}
+export interface SessionEngineSessionRef {
+    readonly shellSessionId: string;
+    readonly uuid: string;
+}
+export type SessionEngineCommitRequest = {
+    readonly arm: 'create';
+    readonly binding: SessionEngineAssignment;
+} | {
+    readonly arm: 'resume';
+    readonly binding: SessionEngineAssignment;
+} | SessionEngineRecoverRequest;
+export interface SessionEngineRecoverRequest {
+    readonly arm: 'recover';
+    readonly binding: SessionEngineAssignment;
+    readonly chosenByUser?: true;
+}
+export type SessionEngineUnresolvedReason = 'request-invalid' | 'record-mismatch' | 'record-legacy' | 'record-unbound' | 'record-unreadable' | 'recover-unproven';
+export type SessionEngineCommitResult = SessionEngineCommitted | {
+    readonly kind: 'conflict';
+    readonly bound: SessionEngineView;
+} | {
+    readonly kind: 'unresolved';
+    readonly reason: SessionEngineUnresolvedReason;
+} | {
+    readonly kind: 'store-failed';
+};
+export interface SessionEngineCommitted {
+    readonly kind: 'committed';
+    readonly engine: SessionEngineView;
+    readonly notice?: MessageRef;
+}
+export interface SessionEngineWiring {
+    readonly id: string;
+    readonly selfSpawned: boolean;
+    readonly wiredAddresses: readonly string[];
+    readonly auth: EngineTargetCloudAuth | undefined;
+    readonly explicitAddresses?: readonly string[];
+}
+export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved';
+export type SessionDispatchDecision = {
+    readonly kind: 'self';
+    readonly wiringSnapshotId: string;
+} | SessionDispatchUrlTarget | SessionDispatchRefused;
+export interface SessionDispatchUrlTarget {
+    readonly kind: 'address' | 'center';
+    readonly url: string;
+    readonly wiringSnapshotId: string;
+}
+export interface SessionDispatchRefused {
+    readonly kind: 'refused';
+    readonly refusal: SessionDispatchRefusal;
+    readonly message: MessageRef;
+}
+export declare function sessionEngineBindingFor(input: SessionEngineBindingInput): SessionEngineBinding;
+export declare function isSessionEngineView(v: {} | null | undefined): boolean;
+export declare function readSessionEngine(record: SessionMapRecord | undefined): SessionEngineReading;
+export declare function commitSessionEngine(store: SessionMapStorePort, session: SessionEngineSessionRef, request: SessionEngineCommitRequest): SessionEngineCommitResult;
+export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;

package/dist/sessionEngine.js

@@ -0,0 +1,464 @@
+import { engineNamespaceKeyFor } from './sessionMap.js';
+import { carriesNoCredentialSlots, isCenterRelativePath, tupleOriginUrlOf } from './engineAddress.js';
+import { ownSendableField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { slotReadOf } from './wireFailureShape.js';
+import { msg } from './i18n/translate.js';
+const V1 = 'v1';
+const SELF_KEY = JSON.stringify([V1, 'self']);
+const EMPTY = Object.freeze({});
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isCanonicalAddress(s) {
+    return s !== '' && tupleOriginUrlOf(s) !== undefined && engineNamespaceKeyFor(s) === s;
+}
+function decodeKey(key) {
+    let parsed;
+    try {
+        parsed = JSON.parse(key);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed) || !parsed.every((x) => typeof x === 'string'))
+        return undefined;
+    const t = parsed;
+    if (JSON.stringify(t) !== key || t[0] !== V1)
+        return undefined;
+    if (t[1] === 'self' && t.length === 2)
+        return { identityKind: 'self' };
+    if (t[1] === 'declared' && t.length === 5) {
+        const [, , center, scope, name] = t;
+        return isCanonicalAddress(center) && scope !== '' && name !== '' ? { identityKind: 'declared', center, scope, name } : undefined;
+    }
+    if (t[1] === 'address' && t.length === 3) {
+        const address = t[2];
+        return isCanonicalAddress(address) ? { identityKind: 'address', address } : undefined;
+    }
+    return undefined;
+}
+const fail = (reason) => Object.freeze({ ok: false, reason });
+function selfBinding() {
+    return Object.freeze({ ok: true, identityKind: 'self', key: SELF_KEY, presentation: EMPTY });
+}
+function declaredBinding(center, scope, name, viaCenter) {
+    return Object.freeze({
+        ok: true,
+        identityKind: 'declared',
+        key: JSON.stringify([V1, 'declared', center, scope, name]),
+        presentation: Object.freeze({ center, scope, name }),
+        connect: Object.freeze({ viaCenter }),
+    });
+}
+function addressBinding(raw) {
+    const u = tupleOriginUrlOf(raw);
+    if (u === undefined || !carriesNoCredentialSlots(u))
+        return fail('address-invalid');
+    const address = engineNamespaceKeyFor(raw);
+    return Object.freeze({
+        ok: true,
+        identityKind: 'address',
+        key: JSON.stringify([V1, 'address', address]),
+        presentation: Object.freeze({ address }),
+        connect: Object.freeze({ url: raw }),
+    });
+}
+export function sessionEngineBindingFor(input) {
+    try {
+        if (!isObj(input))
+            return fail('input-invalid');
+        const role = readOwnDataValue(input, 'role');
+        const row = slotReadOf(input, 'row');
+        const address = slotReadOf(input, 'address');
+        const center = slotReadOf(input, 'center');
+        if (role === 'self') {
+            return row.presence === 'absent' && address.presence === 'absent' && center.presence === 'absent' ? selfBinding() : fail('input-invalid');
+        }
+        if (role !== 'external')
+            return fail('input-invalid');
+        const rowGiven = row.presence !== 'absent';
+        if (rowGiven === (address.presence !== 'absent'))
+            return fail('input-invalid');
+        if (!rowGiven) {
+            if (center.presence !== 'absent')
+                return fail('input-invalid');
+            return address.presence === 'present' && typeof address.value === 'string' ? addressBinding(address.value) : fail('address-invalid');
+        }
+        if (row.presence !== 'present' || !isObj(row.value))
+            return fail('row-incomplete');
+        const r = row.value;
+        const name = readOwnDataNonEmptyString(r, 'name');
+        const scope = readOwnDataNonEmptyString(r, 'scope');
+        const viaCenter = readOwnDataNonEmptyString(r, 'viaCenter');
+        if (name === undefined || scope === undefined || viaCenter === undefined || !isCenterRelativePath(viaCenter))
+            return fail('row-incomplete');
+        if (center.presence !== 'present' || typeof center.value !== 'string' || tupleOriginUrlOf(center.value) === undefined)
+            return fail('center-invalid');
+        return declaredBinding(engineNamespaceKeyFor(center.value), scope, name, viaCenter);
+    }
+    catch {
+        return fail('input-invalid');
+    }
+}
+function assignmentOf(kindRaw, keyRaw, connectSlot) {
+    if (kindRaw !== 'local' && kindRaw !== 'cloud')
+        return undefined;
+    if (typeof keyRaw !== 'string')
+        return undefined;
+    const decoded = decodeKey(keyRaw);
+    if (decoded === undefined)
+        return undefined;
+    const connectAbsent = connectSlot.presence === 'absent' || (connectSlot.presence === 'present' && connectSlot.value === undefined);
+    let identity;
+    if (decoded.identityKind === 'self') {
+        if (!connectAbsent)
+            return undefined;
+        identity = selfBinding();
+    }
+    else {
+        if (connectSlot.presence !== 'present' || !isObj(connectSlot.value))
+            return undefined;
+        const c = connectSlot.value;
+        if (decoded.identityKind === 'address') {
+            const url = readOwnDataValue(c, 'url');
+            if (typeof url !== 'string')
+                return undefined;
+            const re = addressBinding(url);
+            if (!re.ok || re.key !== keyRaw)
+                return undefined;
+            identity = re;
+        }
+        else {
+            const viaCenter = readOwnDataNonEmptyString(c, 'viaCenter');
+            if (viaCenter === undefined || !isCenterRelativePath(viaCenter))
+                return undefined;
+            identity = declaredBinding(decoded.center, decoded.scope, decoded.name, viaCenter);
+            if (identity.key !== keyRaw)
+                return undefined;
+        }
+    }
+    return Object.freeze({ kind: kindRaw, identity });
+}
+function sameAssignment(a, b) {
+    if (a.kind !== b.kind || a.identity.key !== b.identity.key || a.identity.identityKind !== b.identity.identityKind)
+        return false;
+    if (a.identity.identityKind === 'address' && b.identity.identityKind === 'address')
+        return a.identity.connect.url === b.identity.connect.url;
+    if (a.identity.identityKind === 'declared' && b.identity.identityKind === 'declared')
+        return a.identity.connect.viaCenter === b.identity.connect.viaCenter;
+    return true;
+}
+function viewOf(a) {
+    const id = a.identity;
+    if (id.identityKind === 'self')
+        return Object.freeze({ kind: a.kind, identityKind: 'self', identity: Object.freeze({ key: id.key, presentation: id.presentation }) });
+    if (id.identityKind === 'declared')
+        return Object.freeze({ kind: a.kind, identityKind: 'declared', identity: Object.freeze({ key: id.key, presentation: id.presentation }) });
+    return Object.freeze({ kind: a.kind, identityKind: 'address', identity: Object.freeze({ key: id.key, presentation: id.presentation }) });
+}
+function snapshotOf(a) {
+    const id = a.identity;
+    if (id.identityKind === 'address')
+        return { kind: a.kind, key: id.key, connect: { url: id.connect.url } };
+    if (id.identityKind === 'declared')
+        return { kind: a.kind, key: id.key, connect: { viaCenter: id.connect.viaCenter } };
+    return { kind: a.kind, key: id.key };
+}
+export function isSessionEngineView(v) {
+    try {
+        if (!isObj(v))
+            return false;
+        const kind = ownSendableField(v, 'kind');
+        if (kind !== 'local' && kind !== 'cloud')
+            return false;
+        const identityKind = ownSendableField(v, 'identityKind');
+        const identity = ownSendableField(v, 'identity');
+        if (!isObj(identity))
+            return false;
+        const key = ownSendableField(identity, 'key');
+        const presentation = ownSendableField(identity, 'presentation');
+        if (typeof key !== 'string' || !isObj(presentation))
+            return false;
+        const decoded = decodeKey(key);
+        if (decoded === undefined || decoded.identityKind !== identityKind)
+            return false;
+        const fields = decoded.identityKind === 'self' ? {} : decoded.identityKind === 'declared' ? { center: decoded.center, scope: decoded.scope, name: decoded.name } : { address: decoded.address };
+        if (Reflect.ownKeys(presentation).length !== Object.keys(fields).length)
+            return false;
+        return Object.keys(fields).every((k) => ownSendableField(presentation, k) === fields[k]);
+    }
+    catch {
+        return false;
+    }
+}
+function entryIdOf(record, key) {
+    const engines = slotReadOf(record, 'engines');
+    if (engines.presence !== 'present' || !isObj(engines.value))
+        return undefined;
+    const entry = slotReadOf(engines.value, key);
+    if (entry.presence !== 'present' || !isObj(entry.value))
+        return undefined;
+    return readOwnDataNonEmptyString(entry.value, 'engineSessionId');
+}
+function hasHistory(record) {
+    const engines = slotReadOf(record, 'engines');
+    if (engines.presence === 'unreadable')
+        return true;
+    if (engines.presence === 'present' && engines.value !== undefined) {
+        if (!isObj(engines.value))
+            return true;
+        if (Reflect.ownKeys(engines.value).length > 0)
+            return true;
+    }
+    const top = slotReadOf(record, 'engineSessionId');
+    if (top.presence === 'unreadable')
+        return true;
+    return top.presence === 'present' && top.value !== undefined && top.value !== '';
+}
+export function readSessionEngine(record) {
+    try {
+        if (record === undefined || record === null)
+            return NONE;
+        if (!isObj(record))
+            return UNRESOLVED;
+        const snap = slotReadOf(record, 'boundEngine');
+        if (snap.presence === 'unreadable')
+            return UNRESOLVED;
+        if (snap.presence === 'present' && snap.value !== undefined) {
+            if (!isObj(snap.value))
+                return UNRESOLVED;
+            const s = snap.value;
+            const binding = assignmentOf(readOwnDataValue(s, 'kind'), readOwnDataValue(s, 'key'), slotReadOf(s, 'connect'));
+            if (binding === undefined)
+                return UNRESOLVED;
+            const uuid = entryIdOf(record, binding.identity.key);
+            if (uuid === undefined)
+                return UNRESOLVED;
+            return Object.freeze({ kind: 'bound', binding, engine: viewOf(binding), uuid });
+        }
+        return hasHistory(record) ? LEGACY : NONE;
+    }
+    catch {
+        return UNRESOLVED;
+    }
+}
+const NONE = Object.freeze({ kind: 'none' });
+const LEGACY = Object.freeze({ kind: 'legacy' });
+const UNRESOLVED = Object.freeze({ kind: 'unresolved' });
+function judgeNotice(a) {
+    return a.identity.identityKind === 'self' && a.kind !== 'local' ? msg('session.engine.selfNotLocal') : undefined;
+}
+function committed(a) {
+    const notice = judgeNotice(a);
+    const engine = viewOf(a);
+    return Object.freeze(notice === undefined ? { kind: 'committed', engine } : { kind: 'committed', engine, notice });
+}
+const unresolvedCommit = (reason) => Object.freeze({ kind: 'unresolved', reason });
+const STORE_FAILED = Object.freeze({ kind: 'store-failed' });
+function requestAssignmentOf(raw) {
+    if (!isObj(raw))
+        return undefined;
+    const identity = readOwnDataValue(raw, 'identity');
+    if (!isObj(identity) || readOwnDataValue(identity, 'ok') !== true)
+        return undefined;
+    const a = assignmentOf(readOwnDataValue(raw, 'kind'), readOwnDataValue(identity, 'key'), slotReadOf(identity, 'connect'));
+    if (a === undefined || readOwnDataValue(identity, 'identityKind') !== a.identity.identityKind)
+        return undefined;
+    return a;
+}
+function legacyKeyOf(a) {
+    const id = a.identity;
+    if (id.identityKind === 'self')
+        return 'local';
+    if (id.identityKind === 'address')
+        return engineNamespaceKeyFor(id.connect.url);
+    const center = tupleOriginUrlOf(id.presentation.center);
+    return center === undefined ? undefined : engineNamespaceKeyFor(center.origin + id.connect.viaCenter);
+}
+const nextOf = (step) => (Object.hasOwn(step, 'next') ? step.next : undefined);
+function firstWrite(prior, session, a, now) {
+    const engines = { ...(prior?.engines ?? {}) };
+    const existing = Object.hasOwn(engines, a.identity.key) ? engines[a.identity.key] : undefined;
+    Object.defineProperty(engines, a.identity.key, {
+        value: { ...existing, engineSessionId: session.uuid, updatedAt: now },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    return { ...prior, shellSessionId: session.shellSessionId, boundEngine: snapshotOf(a), engines, updatedAt: now };
+}
+function commitStep(prior, session, arm, a, chosenByUser) {
+    const reading = readSessionEngine(prior);
+    if (prior !== undefined && prior !== null) {
+        const handle = isObj(prior) ? readOwnDataValue(prior, 'shellSessionId') : undefined;
+        if (handle !== session.shellSessionId) {
+            return { result: reading.kind === 'bound' ? Object.freeze({ kind: 'conflict', bound: reading.engine }) : unresolvedCommit('record-mismatch') };
+        }
+    }
+    if (reading.kind === 'unresolved')
+        return { result: unresolvedCommit('record-unreadable') };
+    if (reading.kind === 'bound') {
+        if (sameAssignment(reading.binding, a) && reading.uuid === session.uuid)
+            return { result: committed(a) };
+        return { result: Object.freeze({ kind: 'conflict', bound: reading.engine }) };
+    }
+    const now = new Date().toISOString();
+    if (reading.kind === 'none') {
+        if (arm !== 'create')
+            return { result: unresolvedCommit('record-unbound') };
+        return { result: committed(a), next: firstWrite(prior, session, a, now) };
+    }
+    if (arm !== 'recover')
+        return { result: unresolvedCommit('record-legacy') };
+    const oldKey = legacyKeyOf(a);
+    const proven = oldKey !== undefined &&
+        isObj(prior) &&
+        entryIdOf(prior, oldKey) === session.uuid &&
+        (a.identity.identityKind !== 'declared' || chosenByUser) &&
+        (entryIdOf(prior, a.identity.key) ?? session.uuid) === session.uuid;
+    if (!proven)
+        return { result: unresolvedCommit('recover-unproven') };
+    return { result: committed(a), next: firstWrite(prior, session, a, now) };
+}
+export function commitSessionEngine(store, session, request) {
+    let readMergeWrite;
+    let ref;
+    let arm;
+    let assignment;
+    let chosenByUser = false;
+    try {
+        if (!isObj(store) || !isObj(session) || !isObj(request))
+            return unresolvedCommit('request-invalid');
+        const rmw = methodOf(store, 'readMergeWrite');
+        if (rmw === undefined)
+            return unresolvedCommit('request-invalid');
+        readMergeWrite = (build) => rmw.call(store, build);
+        const shellSessionId = readOwnDataNonEmptyString(session, 'shellSessionId');
+        const uuid = readOwnDataNonEmptyString(session, 'uuid');
+        if (shellSessionId === undefined || uuid === undefined)
+            return unresolvedCommit('request-invalid');
+        ref = Object.freeze({ shellSessionId, uuid });
+        const armRaw = readOwnDataValue(request, 'arm');
+        if (armRaw !== 'create' && armRaw !== 'resume' && armRaw !== 'recover')
+            return unresolvedCommit('request-invalid');
+        arm = armRaw;
+        const a = requestAssignmentOf(readOwnDataValue(request, 'binding'));
+        if (a === undefined)
+            return unresolvedCommit('request-invalid');
+        assignment = a;
+        if (arm === 'recover')
+            chosenByUser = readOwnDataValue(request, 'chosenByUser') === true;
+    }
+    catch {
+        return unresolvedCommit('request-invalid');
+    }
+    let step;
+    try {
+        const returned = readMergeWrite((prior) => {
+            step = commitStep(prior, ref, arm, assignment, chosenByUser);
+            return nextOf(step);
+        });
+        if (step === undefined)
+            return STORE_FAILED;
+        if (nextOf(step) !== undefined && !isObj(returned))
+            return STORE_FAILED;
+        return step.result;
+    }
+    catch {
+        return STORE_FAILED;
+    }
+}
+function methodOf(o, key) {
+    try {
+        const v = o[key];
+        return typeof v === 'function' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const REFUSAL_KEYS = {
+    'not-wired': 'session.engine.dispatch.notWired',
+    'scope-mismatch': 'session.engine.dispatch.scopeMismatch',
+    'scope-unproven': 'session.engine.dispatch.scopeUnproven',
+    unresolved: 'session.engine.dispatch.unresolved',
+};
+const refused = (refusal) => Object.freeze({ kind: 'refused', refusal, message: msg(REFUSAL_KEYS[refusal]) });
+function authOf(ctx) {
+    const slot = slotReadOf(ctx, 'auth');
+    if (slot.presence === 'absent' || (slot.presence === 'present' && slot.value === undefined))
+        return { kind: 'none' };
+    if (slot.presence !== 'present' || !isObj(slot.value))
+        return { kind: 'unknown' };
+    const a = slot.value;
+    const kind = readOwnDataValue(a, 'kind');
+    if (kind === 'token')
+        return { kind: 'token' };
+    if (kind !== 'registry')
+        return { kind: 'unknown' };
+    const registryUrl = readOwnDataValue(a, 'registryUrl');
+    const u = typeof registryUrl === 'string' ? tupleOriginUrlOf(registryUrl) : undefined;
+    if (u === undefined || typeof registryUrl !== 'string')
+        return { kind: 'unknown' };
+    const scopeSlot = slotReadOf(a, 'scope');
+    if (scopeSlot.presence === 'unreadable')
+        return { kind: 'unknown' };
+    const scope = scopeSlot.presence === 'present' && typeof scopeSlot.value === 'string' && scopeSlot.value !== '' ? scopeSlot.value : undefined;
+    return { kind: 'registry', center: engineNamespaceKeyFor(registryUrl), origin: u.origin, scope };
+}
+function addressSetOf(ctx, key) {
+    const out = new Set();
+    const v = readOwnDataValue(ctx, key);
+    if (!Array.isArray(v))
+        return out;
+    const n = readOwnDataValue(v, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return out;
+    for (let i = 0; i < n; i += 1) {
+        const s = readOwnDataValue(v, String(i));
+        if (typeof s === 'string' && tupleOriginUrlOf(s) !== undefined)
+            out.add(engineNamespaceKeyFor(s));
+    }
+    return out;
+}
+export function sessionDispatchTarget(reading, ctx) {
+    try {
+        if (!isObj(reading) || readOwnDataValue(reading, 'kind') !== 'bound')
+            return refused('unresolved');
+        const a = requestAssignmentOf(readOwnDataValue(reading, 'binding'));
+        if (a === undefined)
+            return refused('unresolved');
+        if (!isObj(ctx))
+            return refused('not-wired');
+        const id = readOwnDataNonEmptyString(ctx, 'id');
+        if (id === undefined)
+            return refused('not-wired');
+        const identity = a.identity;
+        if (identity.identityKind === 'self') {
+            return readOwnDataValue(ctx, 'selfSpawned') === true ? Object.freeze({ kind: 'self', wiringSnapshotId: id }) : refused('not-wired');
+        }
+        const auth = authOf(ctx);
+        if (identity.identityKind === 'declared') {
+            if (auth.kind !== 'registry' || auth.center !== identity.presentation.center || auth.scope === undefined)
+                return refused('scope-unproven');
+            if (auth.scope !== identity.presentation.scope)
+                return refused('scope-mismatch');
+            return Object.freeze({ kind: 'center', url: auth.origin + identity.connect.viaCenter, wiringSnapshotId: id });
+        }
+        const url = identity.connect.url;
+        const u = tupleOriginUrlOf(url);
+        if (u === undefined)
+            return refused('unresolved');
+        const address = engineNamespaceKeyFor(url);
+        const viaOtherOrigin = auth.kind === 'registry' && auth.origin !== u.origin;
+        const explicitDirect = auth.kind === 'none' && addressSetOf(ctx, 'explicitAddresses').has(address) && u.pathname.replace(/\/+$/, '') === '';
+        if (!viaOtherOrigin && !explicitDirect)
+            return refused('scope-unproven');
+        if (!addressSetOf(ctx, 'wiredAddresses').has(address))
+            return refused('not-wired');
+        return Object.freeze({ kind: 'address', url, wiringSnapshotId: id });
+    }
+    catch {
+        return refused('unresolved');
+    }
+}

package/dist/sessionMap.d.ts

@@ -15,15 +15,25 @@ export interface SessionMapRecord {
         reason: string;
         at: string;
     };
+    boundEngine?: SessionEngineSnapshot;
     updatedAt: string;
 }
+export interface SessionEngineSnapshot {
+    kind: 'local' | 'cloud';
+    key: string;
+    connect?: {
+        url: string;
+    } | {
+        viaCenter: string;
+    };
+}
 export declare function engineNamespaceKeyFor(baseUrl: string | undefined): string;
 export type SessionMapMergeVerdict = {
     ok: true;
     record: SessionMapRecord;
 } | {
     ok: false;
-    reason: 'no-shell-session-id' | 'no-engine-session-id';
+    reason: 'no-shell-session-id' | 'no-engine-session-id' | 'bound-entry-conflict';
 };
 export declare function mergeSessionMapRecord(prior: SessionMapRecord | undefined, partial: Partial<SessionMapRecord> & {
     shellSessionId?: string;