@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/controlRouter.js

@@ -1,7 +1,8 @@
 import { cancelConflictContent, cancelConflictFromError } from './wireRefusalCopy.js';
-import { PROTOCOL_ERROR_NAME, protocolErrorNameOf } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { steerPriorityMode } from './steerPriorityCapability.js';
 import { preemptReadingOfAck, preemptReadingOfError } from './preemptWire.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export class ControlSafetyError extends Error {
     code;
     cause;
@@ -156,10 +157,11 @@ export class ControlRouter {
 export function errCodes(e) {
     if (!e || typeof e !== 'object')
         return {};
-    const o = e;
-    const code = typeof o.errorCode === 'string' ? o.errorCode : undefined;
-    const name = typeof o.name === 'string' ? o.name : undefined;
-    const rawStatus = o.status ?? o.statusCode;
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    const code = typeof rawCode === 'string' ? rawCode : undefined;
+    const rawName = readThrownSlot(e, 'name');
+    const name = typeof rawName === 'string' ? rawName : undefined;
+    const rawStatus = readThrownStatusSlot(e);
     const status = typeof rawStatus === 'number' ? rawStatus : undefined;
     return { code, name, status };
 }
@@ -185,48 +187,32 @@ const STEERING_NAME_TO_SAFETY = {
     SteeringError: 'steering_other',
 };
 const STEERING_COPY = {
-    not_running: {
-        happened: 'that run is not accepting messages right now — it has just finished, is running on another server, or is not the active run of its session',
-        nextStep: 'check its current state and send the message to the run that is active',
-    },
-    invalid_content: {
-        happened: 'the message was refused because its text contains control markers the engine does not accept, so nothing was delivered',
-        nextStep: 'rewrite the message and send it again',
-    },
-    queue_full: {
-        happened: 'that run is paused and already holds as many waiting messages as it can, so this one was not accepted',
-        nextStep: 'send it again once the waiting messages have been delivered (when the run resumes or the session is woken)',
-    },
-    duplicate_input_id: {
-        happened: 'a different instruction was already accepted under this idempotency key, and that earlier instruction stands',
-        nextStep: 'if you changed the text, send the new text under a new key; otherwise do not resend it — a new key would deliver the same instruction twice',
-    },
-    ambiguous_target: {
-        happened: 'more than one running agent matches that target, so the message was not delivered',
-        nextStep: 'address a sub-agent by its tool-call id; a workflow agent cannot be singled out while another running agent shares its label, so send it again once only one does',
-    },
-    still_running: {
-        happened: 'that agent is still running, so it cannot be resumed',
-        nextStep: 'send it a message instead, or wait for it to finish',
-    },
-    blocked_by_hook: {
-        happened: "the message was not accepted: a prompt check on this deployment blocked it, so nothing was delivered",
-        nextStep: 'edit the message and send it again — that is not a duplicate submission',
-    },
-    ledger_unavailable: {
-        happened: 'the server could not record the message and refused it before anything reached the engine, so nothing was delivered',
-        nextStep: 'send the same text again later',
-    },
-    steering_other: {
-        happened: 'the message was refused for a reason this version does not recognise, so it did not land',
-        nextStep: 'report its error code if this keeps happening; do not guess what it means',
-    },
+    not_running: { happened: 'session.steerRefusal.notRunning.happened', nextStep: 'session.steerRefusal.notRunning.nextStep' },
+    invalid_content: { happened: 'session.steerRefusal.invalidContent.happened', nextStep: 'session.steerRefusal.invalidContent.nextStep' },
+    queue_full: { happened: 'session.steerRefusal.queueFull.happened', nextStep: 'session.steerRefusal.queueFull.nextStep' },
+    duplicate_input_id: { happened: 'session.steerRefusal.duplicateInputId.happened', nextStep: 'session.steerRefusal.duplicateInputId.nextStep' },
+    ambiguous_target: { happened: 'session.steerRefusal.ambiguousTarget.happened', nextStep: 'session.steerRefusal.ambiguousTarget.nextStep' },
+    still_running: { happened: 'session.steerRefusal.stillRunning.happened', nextStep: 'session.steerRefusal.stillRunning.nextStep' },
+    blocked_by_hook: { happened: 'session.steerRefusal.blockedByHook.happened', nextStep: 'session.steerRefusal.blockedByHook.nextStep' },
+    ledger_unavailable: { happened: 'session.steerRefusal.ledgerUnavailable.happened', nextStep: 'session.steerRefusal.ledgerUnavailable.nextStep' },
+    steering_other: { happened: 'session.steerRefusal.steeringOther.happened', nextStep: 'session.steerRefusal.steeringOther.nextStep' },
 };
-const adviceOfCopy = (c) => `${c.happened} — ${c.nextStep}`;
-const STEERING_ADVICE = Object.freeze(Object.fromEntries(Object.entries(STEERING_COPY).map(([k, c]) => [k, adviceOfCopy(c)])));
+const adviceOfCopy = (c, lang) => renderMessage(msg('session.steerRefusal.advice', { happened: c.happened, nextStep: c.nextStep }), lang);
+function hostQueueFactOf(v) {
+    return v === 'queued_until_turn_end' || v === 'dropped' ? v : 'unknown';
+}
+function renderedCopyOf(keys, lang, hostQueue) {
+    const happened = renderMessage(msg(keys.happened), lang);
+    const tableNextStep = renderMessage(msg(keys.nextStep), lang);
+    if (hostQueue === 'queued_until_turn_end')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.queued'), lang) };
+    if (hostQueue === 'dropped')
+        return { happened, nextStep: renderMessage(msg('session.steerRefusal.hostQueue.dropped', { nextStep: tableNextStep }), lang) };
+    return { happened, nextStep: tableNextStep };
+}
 const STEERING_OTHER_UNKNOWN_COPY = {
-    happened: 'the message was refused for a reason this version does not recognise, and whether it was delivered is not known',
-    nextStep: 'do not resend it as if it had certainly been dropped — check the run first, and report its error code if this keeps happening',
+    happened: 'session.steerRefusal.steeringOtherUnknown.happened',
+    nextStep: 'session.steerRefusal.steeringOtherUnknown.nextStep',
 };
 const CANCEL_NOT_FOUND_COPY = {
     happened: 'this server has no run with that id for you — it does not exist, or it belongs to someone else',
@@ -262,7 +248,7 @@ function steeringCopyOf(e, safety) {
     return STEERING_COPY[safety];
 }
 const STEERING_REFUSED_BEFORE_ENGINE = new Map([['ledger_unavailable', 503]]);
-export function steeringRefusedBeforeEngine(e) {
+export function steeringRefusedBeforeEngine(e, hostQueue, lang) {
     try {
         const { status } = errCodes(e);
         if (status === undefined)
@@ -270,8 +256,8 @@ export function steeringRefusedBeforeEngine(e) {
         const safety = steeringVerdict(e);
         if (safety === undefined || STEERING_REFUSED_BEFORE_ENGINE.get(safety) !== status)
             return undefined;
-        const copy = STEERING_COPY[safety];
-        return { safety, advice: STEERING_ADVICE[safety], happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(STEERING_COPY[safety], lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;
@@ -288,17 +274,19 @@ function steeringVerdict(e) {
     if (typeof code === 'string' && code.startsWith('steering.')) {
         return STEERING_CODE_TO_SAFETY.get(code) ?? 'steering_other';
     }
+    if (readThrownSlot(e, 'errorCode', 'data') === THROWN_SLOT_UNREADABLE)
+        return undefined;
     const protocolName = protocolErrorNameOf(e);
     return protocolName !== undefined ? STEERING_NAME_TO_SAFETY[protocolName] : undefined;
 }
-export function steerRefusalAdviceOf(e) {
+export function steerRefusalAdviceOf(e, hostQueue, lang) {
     try {
         const verdict = steeringVerdict(e);
         if (verdict === undefined)
             return undefined;
         const safety = steeringSafetyOf(e, verdict);
-        const copy = steeringCopyOf(e, safety);
-        return { safety, advice: adviceOfCopy(copy), happened: copy.happened, nextStep: copy.nextStep };
+        const copy = renderedCopyOf(steeringCopyOf(e, safety), lang, hostQueueFactOf(hostQueue));
+        return { safety, advice: adviceOfCopy(copy, lang), happened: copy.happened, nextStep: copy.nextStep };
     }
     catch {
         return undefined;

package/dist/coreValuePorts.d.ts

@@ -97,6 +97,27 @@ export interface RuleToolNameVerdictView {
     readonly guidance?: string;
     readonly currentName?: string;
 }
+export type RuleEntryReadingView = {
+    readonly kind: 'row';
+    readonly compiled: RuleEntryCompiledView;
+} | {
+    readonly kind: 'inert';
+    readonly reason: string;
+    readonly verdict?: string;
+    readonly guidance?: string;
+    readonly currentName?: string;
+    readonly valueType?: string;
+};
+export interface RuleEntryCompiledView {
+    readonly kind: string;
+}
+export type McpToolAxesReadView = {
+    readonly ok: true;
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -118,8 +139,10 @@ export interface CoreValuePorts {
         adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
     }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
     judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
+    readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView;
+    readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -145,3 +168,5 @@ export declare function adjudicateModelRoute(model: RouteModelView, credential:
 export declare function routePairingStatus(brain: {
     adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
 }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;
+export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView | undefined;
+export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;

package/dist/coreValuePorts.js

@@ -15,6 +15,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'adjudicateModelRoute',
     'routePairingStatus',
     'judgeRuleToolName',
+    'readRuleEntry',
+    'readMcpToolAxes',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -99,3 +101,11 @@ export function routePairingStatus(brain, model, perModelAuth) {
     const fn = port('routePairingStatus');
     return fn === undefined ? undefined : fn(brain, model, perModelAuth);
 }
+export function readRuleEntry(raw, behavior, roster) {
+    const fn = port('readRuleEntry');
+    return fn === undefined ? undefined : fn(raw, behavior, roster);
+}
+export function readMcpToolAxes(declared) {
+    const fn = port('readMcpToolAxes');
+    return fn === undefined ? undefined : fn(declared);
+}

package/dist/corruptSessionCopy.d.ts

@@ -1 +1,2 @@
-export declare function corruptSessionContent(): string;
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare function corruptSessionContent(lang?: UiLanguage): string;

package/dist/corruptSessionCopy.js

@@ -1,4 +1,4 @@
-export function corruptSessionContent() {
-    return ("This session's saved history cannot be read — its stored log is damaged — so the engine cannot open this session. " +
-        'Retrying will not help: whoever operates this engine has to repair or remove that stored log. Until then, continue in a new session.');
+import { msg, renderMessage } from './i18n/translate.js';
+export function corruptSessionContent(lang) {
+    return renderMessage(msg('session.corrupt.content'), lang);
 }

package/dist/decideFailureNote.js

@@ -1,21 +1,21 @@
 import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
-import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
+import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
 import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
-    const bucket = settingsPermissionBucketRefusalFromError(err);
+    const bucket = fieldLimitRefusalFromError(err);
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
     const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
-        (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
+        (bucket === null ? '' : ` — ${fieldLimitRefusalContent(bucket)}`) +
         (scenario === null ? '' : ` — ${scenarioNotAllowedContent(scenario, undefined, 'resumed_work')}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +

package/dist/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
     server: "7.129.1",
     core: "7.51.2",
-    sdk: "23.0.2",
+    sdk: "23.1.0",
 });

package/dist/detachWire.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
+import { readThrownSlot } from './wireFailureShape.js';
 import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
@@ -13,10 +14,10 @@ export async function resolveHeadlessDetach(env = hostEnv()) {
 }
 export const DETACH_DURABLE_OFF_400_ANCHOR = 'x-detach-on-disconnect requires a durable run';
 export function isDetachDurableOff400(err) {
+    if (readThrownSlot(err, 'status', 'data') !== 400)
+        return false;
     try {
         const e = err;
-        if (e?.status !== 400)
-            return false;
         const msg = e?.message;
         return typeof msg === 'string' && msg.includes(DETACH_DURABLE_OFF_400_ANCHOR);
     }

package/dist/devicesFace.d.ts

@@ -0,0 +1,34 @@
+import { type SeatCapabilityReading } from './seatContract.js';
+import { type DeviceExecutorManagementReading } from './deviceExecutorManagementCapability.js';
+import type { DeviceListOutcome } from './deviceRebind.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export type DevicesFaceUnavailableWhy = 'host_not_wired' | 'host_not_reported' | 'host_report_unreadable' | 'lane_absent' | 'lane_unreported';
+export type DevicesFace = {
+    readonly kind: 'unavailable';
+    readonly why: DevicesFaceUnavailableWhy;
+} | {
+    readonly kind: 'probe_pending';
+} | {
+    readonly kind: 'probe_failed';
+    readonly retryable: true;
+    readonly cause: 'transport' | 'refused' | 'unreadable';
+} | {
+    readonly kind: 'verbs_off';
+} | {
+    readonly kind: 'manage';
+    readonly probe: boolean;
+};
+export interface DevicesFaceInput {
+    readonly host: {
+        readonly kind: 'seat';
+        readonly capability: SeatCapabilityReading;
+    } | {
+        readonly kind: 'direct';
+        readonly sliceArmed: boolean;
+    };
+    readonly engine?: DeviceExecutorManagementReading | undefined;
+    readonly lastList?: DeviceListOutcome | undefined;
+}
+export declare function devicesFaceOf(input: DevicesFaceInput): DevicesFace;
+export declare function devicesWritesAllowed(face: DevicesFace): boolean;
+export declare function devicesFaceDetail(face: DevicesFace, lang?: UiLanguage): string | undefined;

package/dist/devicesFace.js

@@ -0,0 +1,90 @@
+import { seatCapabilityUnavailableDetail } from './seatContract.js';
+import { deviceLaneOpen, deviceManagementVerbsAvailable } from './deviceExecutorManagementCapability.js';
+import { ownDataField } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const freeze = (v) => Object.freeze(v);
+const field = (v, key) => {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        return ownDataField(v, key);
+    }
+    catch {
+        return undefined;
+    }
+};
+function hostProblem(host) {
+    const kind = field(host, 'kind');
+    if (kind === 'direct')
+        return field(host, 'sliceArmed') === true ? undefined : 'host_not_wired';
+    if (kind !== 'seat')
+        return 'host_report_unreadable';
+    const reading = field(host, 'capability');
+    const rk = field(reading, 'kind');
+    if (rk === 'reported')
+        return field(reading, 'available') === true ? undefined : 'host_not_wired';
+    if (rk === 'not_reported')
+        return 'host_not_reported';
+    return 'host_report_unreadable';
+}
+export function devicesFaceOf(input) {
+    const engineRaw = field(input, 'engine');
+    const engine = { kind: field(engineRaw, 'kind'), management: field(engineRaw, 'management') };
+    const lane = deviceLaneOpen(engine);
+    const listKind = field(field(input, 'lastList'), 'kind');
+    if (lane === 'no' || listKind === 'lane-absent')
+        return freeze({ kind: 'unavailable', why: 'lane_absent' });
+    const host = field(input, 'host');
+    const hostWhy = hostProblem(host);
+    if (hostWhy !== undefined)
+        return freeze({ kind: 'unavailable', why: hostWhy });
+    if (listKind === 'unarmed')
+        return freeze({ kind: 'unavailable', why: 'host_not_wired' });
+    if (lane === 'unknown') {
+        if (field(host, 'kind') === 'direct')
+            return freeze({ kind: 'unavailable', why: 'lane_unreported' });
+        if (listKind === undefined)
+            return freeze({ kind: 'probe_pending' });
+        if (listKind === 'ok')
+            return freeze({ kind: 'manage', probe: true });
+        const cause = listKind === 'transport' || listKind === 'refused' ? listKind : 'unreadable';
+        return freeze({ kind: 'probe_failed', retryable: true, cause });
+    }
+    const verbs = deviceManagementVerbsAvailable(engine);
+    if (verbs === 'no')
+        return freeze({ kind: 'verbs_off' });
+    return freeze({ kind: 'manage', probe: verbs === 'unknown' });
+}
+export function devicesWritesAllowed(face) {
+    return field(face, 'kind') === 'manage';
+}
+const UNWIRED = freeze({ kind: 'reported', available: false });
+const NOT_REPORTED = freeze({ kind: 'not_reported' });
+const MALFORMED = freeze({ kind: 'malformed' });
+export function devicesFaceDetail(face, lang) {
+    const kind = field(face, 'kind');
+    if (kind === 'manage')
+        return undefined;
+    if (kind === 'probe_pending')
+        return renderMessage(msg('session.devices.probePending'), lang);
+    if (kind === 'verbs_off')
+        return renderMessage(msg('session.devices.verbsOff'), lang);
+    if (kind === 'probe_failed') {
+        const cause = field(face, 'cause');
+        if (cause === 'transport')
+            return renderMessage(msg('session.devices.probeFailedTransport'), lang);
+        if (cause === 'refused')
+            return renderMessage(msg('session.devices.probeFailedRefused'), lang);
+        return renderMessage(msg('session.devices.probeFailedUnreadable'), lang);
+    }
+    const why = kind === 'unavailable' ? field(face, 'why') : undefined;
+    if (why === 'lane_absent')
+        return renderMessage(msg('session.devices.laneAbsent'), lang);
+    if (why === 'lane_unreported')
+        return renderMessage(msg('session.devices.laneUnreported'), lang);
+    if (why === 'host_not_wired')
+        return seatCapabilityUnavailableDetail('devices', UNWIRED);
+    if (why === 'host_not_reported')
+        return seatCapabilityUnavailableDetail('devices', NOT_REPORTED);
+    return seatCapabilityUnavailableDetail('devices', MALFORMED);
+}

package/dist/displayUntrusted.d.ts

@@ -44,6 +44,7 @@ export declare function credentialWashPasses(text: string, opts?: DisplayUntrust
     capped: boolean;
 };
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function cleanUntrustedScalar(v: string | number | bigint | boolean | null | undefined): string;
 export declare function queryCarriesCredential(query: string): boolean;
 export declare function displayConfiguredUrl(url: string, opts?: DisplayUntrustedOptions): string;
 export declare function quoteUntrustedForSentence(text: string, max: number): string | undefined;

package/dist/displayUntrusted.js

@@ -43,6 +43,9 @@ export function looksLikeKnownSecret(s) {
     for (let layer = 0; layer < 4; layer++) {
         if (scanForSecretLiteral(cur))
             return true;
+        const wide = percentBoundaryDecode(cur);
+        if (wide !== null && scanForSecretLiteral(wide.decoded))
+            return true;
         const next = percentDecodeForMatching(cur).decoded;
         if (next === cur)
             break;
@@ -301,7 +304,7 @@ function pathCandidates(src, base, path, opaqueSegments, edits, soft) {
         if (opaqueSegments) {
             let a = 0;
             let b = head.length;
-            while (a < b && !isKeyWordChar(head.charCodeAt(a)))
+            while (a < b && !isKeyWordChar(head.charCodeAt(a)) && !(head.charCodeAt(a) === 0x25 && hasNonAsciiPercentEscape(head.slice(a, a + 3))))
                 a++;
             while (b > a && !isKeyWordChar(head.charCodeAt(b - 1)))
                 b--;
@@ -1321,10 +1324,93 @@ function percentDecodeForMatching(text) {
     return { decoded: chars.join(''), offsets };
 }
 const PERCENT_ESCAPE_ASCII = /%[0-7][0-9A-Fa-f]/;
+function hasNonAsciiPercentEscape(text) {
+    return /%[89A-Fa-f][0-9A-Fa-f]/.test(text);
+}
+function isWellFormedUtf8(bytes) {
+    for (let i = 0; i < bytes.length;) {
+        const lead = bytes[i] ?? 0;
+        if (lead < 0x80) {
+            i += 1;
+            continue;
+        }
+        const need = utf8TailLength(lead);
+        if (need === 0)
+            return false;
+        for (let k = 1; k <= need; k++) {
+            const c = bytes[i + k];
+            const lo = k === 1 ? (lead === 0xe0 ? 0xa0 : lead === 0xf0 ? 0x90 : 0x80) : 0x80;
+            const hi = k === 1 ? (lead === 0xed ? 0x9f : lead === 0xf4 ? 0x8f : 0xbf) : 0xbf;
+            if (c === undefined || c < lo || c > hi)
+                return false;
+        }
+        i += need + 1;
+    }
+    return true;
+}
+function utf8TailLength(lead) {
+    if (lead >= 0xc2 && lead <= 0xdf)
+        return 1;
+    if (lead >= 0xe0 && lead <= 0xef)
+        return 2;
+    if (lead >= 0xf0 && lead <= 0xf4)
+        return 3;
+    return 0;
+}
+function percentBoundaryDecode(text) {
+    if (!hasNonAsciiPercentEscape(text))
+        return null;
+    const chars = [];
+    const from = [];
+    const to = [];
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            chars.push(text.charAt(i));
+            from.push(i);
+            to.push(i + 1);
+            i += 1;
+            continue;
+        }
+        const bytes = [];
+        let j = i;
+        while (escapeAt(j)) {
+            bytes.push(Number.parseInt(text.slice(j + 1, j + 3), 16));
+            j += 3;
+        }
+        if (isWellFormedUtf8(bytes)) {
+            for (let k = 0; k < bytes.length;) {
+                const lead = bytes[k] ?? 0;
+                const len = lead < 0x80 ? 1 : utf8TailLength(lead) + 1;
+                let cp = len === 1 ? lead : lead & (0xff >> (len + 1));
+                for (let t = 1; t < len; t++)
+                    cp = (cp << 6) | ((bytes[k + t] ?? 0) & 0x3f);
+                const ch = String.fromCodePoint(cp);
+                for (let u = 0; u < ch.length; u++) {
+                    chars.push(ch.charAt(u));
+                    from.push(i + k * 3);
+                    to.push(i + (k + len) * 3);
+                }
+                k += len;
+            }
+        }
+        else {
+            for (let k = 0; k < bytes.length; k++) {
+                const b = bytes[k] ?? 0;
+                chars.push(b < 0x80 ? String.fromCharCode(b) : ' ');
+                from.push(i + k * 3);
+                to.push(i + k * 3 + 3);
+            }
+        }
+        i = j;
+    }
+    return { decoded: chars.join(''), from, to };
+}
 const MAX_PERCENT_VIEW_LAYERS = 3;
 function percentLayers(text) {
     const out = [];
-    if (!PERCENT_ESCAPE_ASCII.test(text))
+    if (!PERCENT_ESCAPE_ASCII.test(text) && !hasNonAsciiPercentEscape(text))
         return out;
     let cur = text;
     let ps = null;
@@ -1347,6 +1433,22 @@ function percentLayers(text) {
         ps = nps;
         pe = npe;
     }
+    const bases = [[text, null, null], ...out.map((l) => [l.text, l.ps, l.pe])];
+    for (const [base, bps, bpe] of bases) {
+        const wide = percentBoundaryDecode(base);
+        if (wide === null)
+            continue;
+        const n = wide.decoded.length;
+        const nps = new Int32Array(n);
+        const npe = new Int32Array(n);
+        for (let k = 0; k < n; k++) {
+            const a = wide.from[k] ?? 0;
+            const b = wide.to[k] ?? base.length;
+            nps[k] = bps === null ? a : (bps[a] ?? 0);
+            npe[k] = bpe === null ? b : (bpe[b - 1] ?? 0);
+        }
+        out.push({ text: wide.decoded, ps: nps, pe: npe });
+    }
     return out;
 }
 function firstLabelCutInPath(path, outer = false) {
@@ -3312,7 +3414,7 @@ function proseLiteralEdits(text) {
         let end = i;
         while (end < text.length && isKeyWordChar(text.charCodeAt(end)))
             end++;
-        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) && i + 2 < end ? 2 : 0;
+        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && (PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) || hasNonAsciiPercentEscape(text.slice(i - 1, i + 2))) && i + 2 < end ? 2 : 0;
         const word = text.slice(i, end);
         if (word.startsWith('eyJ')) {
             let segEnd = end;
@@ -4134,11 +4236,19 @@ function collectCandidates(text, o, nested) {
     for (const S of surfaces) {
         const cands = [];
         const regions = [];
+        const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
         if (o.urls) {
-            const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
             urlCandidates(S.text, cands, regions, unitPos, (k) => unitPos(k) || S.painted(k), o.queryByShape ?? false, o.wholeAddress === true, o.wholeAddress === true && S.decoded !== true);
             userinfoCandidates(S, cands, o.words);
         }
+        else if (o.words && o.wholeAddress === true) {
+            const scratch = [];
+            const hostOnly = [];
+            urlCandidates(S.text, scratch, hostOnly, unitPos, (k) => unitPos(k) || S.painted(k), false, true, S.decoded !== true);
+            for (const r of hostOnly)
+                if (r[2] === 'host')
+                    regions.push(r);
+        }
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
@@ -4663,6 +4773,9 @@ export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
     return typeof out === 'string' ? out : out.text;
 }
+export function cleanUntrustedScalar(v) {
+    return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false });
+}
 const NON_SECRET_FIELD_NAMES = new Set([
     'deployment', 'deploymentname', 'deploymentid', 'name', 'tenant', 'tenantname', 'tenantid', 'region', 'location', 'zone',
     'project', 'projectname', 'projectid', 'workspace', 'workspacename', 'workspaceid', 'resource', 'resourcename', 'resourcegroup',
@@ -4775,7 +4888,42 @@ function isHighEntropyQueryValue(value) {
 }
 function isOpaqueSecretValue(value) {
     const core = valueCoreForJudging(value);
-    return core.length > 0 && (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core));
+    if (core.length === 0)
+        return false;
+    if (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core))
+        return true;
+    if (hasNonAsciiPercentEscape(core)) {
+        for (const chunk of percentByteChunks(core))
+            if (chunk.length > 0 && isHighEntropyQueryValue(chunk))
+                return true;
+    }
+    return false;
+}
+function percentByteChunks(text) {
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    const chunks = [];
+    let start = 0;
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            i += 1;
+            continue;
+        }
+        let j = i;
+        let wide = false;
+        while (escapeAt(j)) {
+            if (text.charCodeAt(j + 1) >= 0x38)
+                wide = true;
+            j += 3;
+        }
+        if (wide) {
+            chunks.push(text.slice(start, i));
+            start = j;
+        }
+        i = j;
+    }
+    chunks.push(text.slice(start));
+    return chunks;
 }
 const VALUE_PIECE_SEPARATORS = new Set(['/', '\\', '?', '#', '&', '=', ';', ':', '@', ',', '+']);
 function hasOpaquePiece(text) {