@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/wireRefusalCopy.js

@@ -1,10 +1,12 @@
-import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
-import { readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { appendOwnElement, guardedRead, readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 import { prepareRefusalNoteOf } from './prepareRefusal.js';
+import { PERMISSION_RULE_ISSUE_CODES, permissionRuleIssueDetail } from './permissionRuleIssue.js';
+import { ruleRefusalListText } from './ruleRefusalSentence.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
@@ -84,6 +86,82 @@ export function usageWindowExhaustedContent(detail, lang) {
         ? `${head} · ${renderMessage(msg('notice.wireRefusal.sendAgainAbout', { wait: humanWait(detail.retryAfterSec) }), lang)}`
         : `${head} · ${renderMessage(msg('notice.wireRefusal.usageWindow.unknownWait'), lang)}`;
 }
+export function quotaExhaustedFromError(err) {
+    if (readThrownSlot(err, 'status', 'data') !== 429 || readThrownSlot(err, 'errorCode', 'data') !== 'quota_exhausted')
+        return null;
+    const detail = readThrownSlot(err, 'detail', 'data');
+    const slot = (key) => (typeof detail === 'object' && detail !== null ? readThrownSlot(detail, key, 'data') : undefined);
+    const windowType = slot('windowType');
+    const remaining = slot('remaining');
+    const resetAt = slot('resetAt');
+    const isEstimate = slot('isEstimate');
+    const pool = slot('pool');
+    const retryAfterSec = slot('retryAfterSec');
+    return {
+        ...(windowType === 'fiveHour' || windowType === 'weekly' || windowType === 'budget' ? { windowType } : {}),
+        ...(typeof remaining === 'number' && Number.isFinite(remaining) ? { remaining } : {}),
+        ...(typeof resetAt === 'string' || resetAt === null ? { resetAt } : {}),
+        ...(typeof isEstimate === 'boolean' ? { isEstimate } : {}),
+        ...(typeof pool === 'string' && pool.length > 0 ? { pool } : {}),
+        ...(typeof retryAfterSec === 'number' && Number.isFinite(retryAfterSec) ? { retryAfterSec } : {}),
+    };
+}
+const QUOTA_MONTH_KEYS = [
+    'notice.failure.month.jan',
+    'notice.failure.month.feb',
+    'notice.failure.month.mar',
+    'notice.failure.month.apr',
+    'notice.failure.month.may',
+    'notice.failure.month.jun',
+    'notice.failure.month.jul',
+    'notice.failure.month.aug',
+    'notice.failure.month.sep',
+    'notice.failure.month.oct',
+    'notice.failure.month.nov',
+    'notice.failure.month.dec',
+];
+export function quotaResetInstantText(resetAtIso, nowMs, lang) {
+    const t = Date.parse(resetAtIso);
+    if (!Number.isFinite(t))
+        return undefined;
+    const d = new Date(t);
+    const now = new Date(nowMs);
+    const hm = `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+    const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
+    if (sameDay)
+        return hm;
+    const monthKey = QUOTA_MONTH_KEYS[d.getMonth()];
+    return renderMessage(msg('notice.failure.quota.instantOtherDay', { month: monthKey === undefined ? '' : msg(monthKey), day: d.getDate(), time: hm }), lang);
+}
+export function quotaExhaustedContent(detail, nowMs, lang) {
+    const part = (key, params) => renderMessage(msg(key, params), lang);
+    const parts = [];
+    if (detail.windowType === 'fiveHour')
+        parts.push(part('notice.failure.quota.fiveHour'));
+    else if (detail.windowType === 'weekly')
+        parts.push(part('notice.failure.quota.weekly'));
+    else if (detail.windowType === 'budget') {
+        if (detail.pool === 'personal')
+            parts.push(part('notice.failure.quota.budgetPersonal'));
+        else if (detail.pool)
+            parts.push(part('notice.failure.quota.budgetPool', { pool: detail.pool }));
+        else
+            parts.push(part('notice.failure.quota.budget'));
+    }
+    else
+        parts.push(part('notice.failure.quota.usage'));
+    if (typeof detail.remaining === 'number' && Number.isFinite(detail.remaining)) {
+        parts.push(detail.windowType === 'budget'
+            ? part('notice.failure.quota.remainingBudget', { amount: `$${(detail.remaining / 1_000_000).toFixed(2)}` })
+            : part('notice.failure.quota.remainingTokens', { count: detail.remaining.toLocaleString('en-US') }));
+    }
+    const resetText = typeof detail.resetAt === 'string' ? quotaResetInstantText(detail.resetAt, nowMs, lang) : undefined;
+    if (resetText)
+        parts.push(detail.isEstimate === false ? part('notice.failure.quota.resetAt', { time: resetText }) : part('notice.failure.quota.resetAround', { time: resetText }));
+    parts.push(part('notice.failure.quota.refresh'));
+    parts.push(part('notice.failure.quota.noBypass'));
+    return parts.join(part('notice.failure.quota.join'));
+}
 const positiveFinite = (v) => typeof v === 'number' && Number.isFinite(v) && v > 0;
 export function fleetLeaseUnavailableFromError(err) {
     if (err === null || typeof err !== 'object')
@@ -142,7 +220,7 @@ const RETIRED_DECISION_KEY = 'settledBy';
 const APPROVAL_NON_BINDING_FIELDS = new Set(['hostDecision', 'approver']);
 export function denyAttributionRefusalFromError(err, sentAttributionKey) {
     try {
-        if (err === null || typeof err !== 'object')
+        if (!isSlotCarrier(err))
             return null;
         const o = err;
         const rawStatus = readThrownStatusSlot(o);
@@ -255,44 +333,20 @@ const BUCKET_OF_FIELD = Object.freeze({
 });
 const nonNegInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined);
 const posInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 1 ? v : undefined);
-export function settingsPermissionBucketRefusalFromError(err) {
-    const r = fieldLimitRefusalFromError(err);
-    if (r === null)
-        return null;
-    const bucket = Object.hasOwn(BUCKET_OF_FIELD, r.field) ? BUCKET_OF_FIELD[r.field] : undefined;
-    if (bucket === undefined || (r.reason !== 'over_cap' && r.reason !== 'bad_entry'))
-        return null;
-    if (r.reason === 'over_cap') {
-        return Object.freeze({
-            bucket,
-            reason: r.reason,
-            ...(r.count !== undefined ? { count: r.count } : {}),
-            ...(r.cap !== undefined ? { cap: r.cap } : {}),
-            ...(r.folded === true ? { folded: true } : {}),
-        });
-    }
-    return Object.freeze({ bucket, reason: r.reason, ...(r.index !== undefined ? { index: r.index } : {}), ...(r.folded === true ? { folded: true } : {}) });
-}
 export function fieldLimitRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
             return null;
-        if (effectiveWireErrorCode(err) !== FIELD_INVALID)
-            return null;
-        let outer;
-        try {
-            outer = err.errorCode;
-        }
-        catch {
+        const coded = effectiveWireCodeReading(err);
+        if (coded.code !== FIELD_INVALID)
             return null;
-        }
         const field = readErrorString(err, 'field');
         if (field === undefined || field.length === 0)
             return null;
         const reason = readErrorString(err, 'reason');
+        const folded = coded.folded;
         if (reason !== 'over_cap' && reason !== 'too_long' && reason !== 'bad_entry')
             return null;
-        const folded = outer === RESUME_POLICY_FOLD_CODE;
         if (reason === 'bad_entry') {
             const index = nonNegInt(readErrorNumber(err, 'index'));
             return Object.freeze({ field, reason, ...(index !== undefined ? { index } : {}), ...(folded ? { folded: true } : {}) });
@@ -311,6 +365,48 @@ export function fieldLimitRefusalFromError(err) {
         return null;
     }
 }
+function hooksCoordinateOf(path) {
+    const lead = path !== undefined && path[0] === 'hooks';
+    let out = lead ? 'settings' : HOOK_MATCHER_REFUSAL_FIELD;
+    for (const seg of path ?? [])
+        out += typeof seg === 'number' ? `[${seg}]` : `.${seg}`;
+    return out;
+}
+export function fieldLimitRefusalOfSettingsHooks(refusal) {
+    try {
+        if (typeof refusal !== 'object' || refusal === null)
+            return null;
+        const reason = readOwnDataValue(refusal, 'reason');
+        if (reason !== 'over_cap' && reason !== 'too_long')
+            return null;
+        const rawPath = readOwnDataValue(refusal, 'path');
+        let path;
+        if (Array.isArray(rawPath)) {
+            const out = [];
+            for (let i = 0; i < rawPath.length; i++) {
+                const seg = Object.hasOwn(rawPath, i) ? rawPath[i] : undefined;
+                if (typeof seg === 'string' || (typeof seg === 'number' && Number.isSafeInteger(seg) && seg >= 0))
+                    out.push(seg);
+                else {
+                    out.length = 0;
+                    break;
+                }
+            }
+            path = out.length > 0 ? out : undefined;
+        }
+        const count = nonNegInt(readOwnDataValue(refusal, 'count'));
+        const cap = posInt(readOwnDataValue(refusal, 'cap'));
+        return Object.freeze({
+            field: hooksCoordinateOf(path),
+            reason,
+            ...(count !== undefined ? { count } : {}),
+            ...(cap !== undefined ? { cap } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
 const FIELD_LIMIT_REFUSAL_UNKNOWN = 'The engine refused this request: a list in it has too many entries, or a text in it is too long · Nothing was trimmed or dropped — shorten it, then send the request again';
 const FIELD_LIMIT_FIELD_MAX = 120;
 export function fieldLimitRefusalContent(detail, lang) {
@@ -721,6 +817,124 @@ export function autonomyLaneRefusalFromError(err) {
 export function autonomyLaneRefusalContent(lang) {
     return renderMessage(msg('notice.wireRefusal.autonomyLane'), lang);
 }
+const REQUEST_UNPROCESSABLE = 'request.unprocessable';
+const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;
+const nonEmptyString = (v) => (typeof v === 'string' && v !== '' ? v : undefined);
+function unsupportedRuleProblemAt(list, i) {
+    try {
+        const item = readOwnDataValue(list, String(i));
+        if (typeof item !== 'object' || item === null)
+            return undefined;
+        const reason = readOwnDataValue(item, 'reason');
+        if (typeof reason !== 'string' || !reason.startsWith('unsupported.') || !PERMISSION_RULE_ISSUE_CODES.includes(reason))
+            return undefined;
+        const field = guardedRead(() => nonEmptyString(readOwnDataValue(item, 'field')));
+        const entry = guardedRead(() => nonEmptyString(readOwnDataValue(item, 'entry')));
+        return Object.freeze({ code: reason, ...(field !== undefined ? { field } : {}), ...(entry !== undefined ? { entry } : {}) });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function unsupportedRuleRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== REQUEST_UNPROCESSABLE)
+            return null;
+        const detail = readErrorRecord(err, 'detail');
+        if (detail === undefined)
+            return null;
+        let list;
+        let length = 0;
+        try {
+            const raw = readOwnDataValue(detail, 'problems');
+            if (Array.isArray(raw)) {
+                list = raw;
+                const n = raw.length;
+                length = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, UNSUPPORTED_RULE_PROBLEMS_MAX) : 0;
+            }
+        }
+        catch {
+            list = undefined;
+        }
+        if (list === undefined)
+            return null;
+        const problems = [];
+        for (let i = 0; i < length; i += 1) {
+            const p = unsupportedRuleProblemAt(list, i);
+            if (p !== undefined)
+                problems.push(p);
+        }
+        const first = problems[0];
+        if (first === undefined)
+            return null;
+        const folded = effective.folded;
+        return Object.freeze({ code: first.code, problems: Object.freeze(problems), ...(folded ? { folded: true } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+function unsupportedRuleSentenceItems(detail, lang) {
+    const items = [];
+    const seen = new Set();
+    try {
+        const list = readOwnDataValue(detail, 'problems');
+        if (Array.isArray(list)) {
+            const len = readOwnDataValue(list, 'length');
+            const n = typeof len === 'number' && Number.isSafeInteger(len) && len > 0 ? Math.min(len, UNSUPPORTED_RULE_PROBLEMS_MAX) : 0;
+            for (let i = 0; i < n; i += 1) {
+                try {
+                    const p = readOwnDataValue(list, String(i));
+                    if (typeof p !== 'object' || p === null)
+                        continue;
+                    const code = readOwnDataValue(p, 'code');
+                    if (typeof code !== 'string' || !code.startsWith('unsupported.'))
+                        continue;
+                    const entry = nonEmptyString(readOwnDataValue(p, 'entry'));
+                    const key = `${entry ?? ''}\u0000${code}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    appendOwnElement(items, { ...(entry !== undefined ? { rule: entry } : {}), reason: permissionRuleIssueDetail(code, undefined, undefined, lang) });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        items.length = 0;
+    }
+    if (items.length > 0)
+        return items;
+    let code;
+    try {
+        code = readOwnDataValue(detail, 'code');
+    }
+    catch {
+        code = undefined;
+    }
+    return [{ reason: permissionRuleIssueDetail(code, undefined, undefined, lang) }];
+}
+export function unsupportedRuleRefusalContent(detail, lang) {
+    const subject = typeof detail === 'object' && detail !== null ? detail : { code: '' };
+    const items = unsupportedRuleSentenceItems(subject, lang);
+    let folded = false;
+    try {
+        folded = readOwnDataValue(subject, 'folded') === true;
+    }
+    catch {
+        folded = false;
+    }
+    const many = items.length > 1;
+    const list = ruleRefusalListText(items, lang);
+    const key = folded ? (many ? 'notice.wireRefusal.unsupportedRule.stored.other' : 'notice.wireRefusal.unsupportedRule.stored') : many ? 'notice.wireRefusal.unsupportedRule.other' : 'notice.wireRefusal.unsupportedRule';
+    return renderMessage(msg(key, many ? { detail: list, count: items.length } : { detail: list }), lang);
+}
 export function userAttachmentRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
@@ -766,7 +980,14 @@ export function userAttachmentRefusalFromError(err) {
     }
 }
 export function userAttachmentRefusalContent(detail) {
-    return prepareRefusalNoteOf(USER_ATTACHMENT_INVALID_ERROR_CODE, detail);
+    let index;
+    try {
+        index = detail === undefined || detail === null ? undefined : detail.index;
+    }
+    catch {
+        index = undefined;
+    }
+    return prepareRefusalNoteOf(USER_ATTACHMENT_INVALID_ERROR_CODE, typeof index === 'number' ? { index } : undefined);
 }
 export function userInvokedSkillRefusalFromError(err) {
     return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;

package/dist/wiringFleetDoctor.d.ts

@@ -0,0 +1,3 @@
+import type { WiringManifestFleetView } from './adapter/downstream/wiringManifestView.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare function wiringFleetDoctorDetail(view: WiringManifestFleetView | null | undefined, lang?: UiLanguage): string | null;

package/dist/wiringFleetDoctor.js

@@ -0,0 +1,21 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { readOwnDataValue } from './ownKey.js';
+const UNKNOWN_TIER_ECHO_MAX = 64;
+export function wiringFleetDoctorDetail(view, lang) {
+    try {
+        if (typeof view !== 'object' || view === null || Array.isArray(view))
+            return null;
+        const tier = readOwnDataValue(view, 'subagentTranscripts');
+        if (typeof tier !== 'string' || tier.length === 0)
+            return null;
+        if (tier === 'full')
+            return renderMessage(msg('doctor.wiring.fleetTranscripts.full'), lang);
+        if (tier === 'rows' || tier === 'none')
+            return renderMessage(msg('doctor.wiring.fleetTranscripts.noPromise', { tier }), lang);
+        return renderMessage(msg('doctor.wiring.fleetTranscripts.unknownTier', { tier: capForDisplay(tier, UNKNOWN_TIER_ECHO_MAX) }), lang);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/workflow.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare function rowIdTail(id: string): string;
 export declare function isWorkflowAgentTaskId(taskId: string): boolean;
 export declare function recordWorkflowAgentTaskId(taskId: string): void;
@@ -8,4 +9,4 @@ export declare function parseWorkflowPollEnvelope(body: string): {
     status: string;
     name?: string;
 } | null;
-export declare function projectWorkflowTaskOutput(jsonSrc: string): string;
+export declare function projectWorkflowTaskOutput(jsonSrc: string, lang?: UiLanguage): string;

package/dist/workflow.js

@@ -1,3 +1,5 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export function rowIdTail(id) {
     return id.split(/\s+/).pop() ?? id;
 }
@@ -38,13 +40,48 @@ export function parseWorkflowPollEnvelope(body) {
         return null;
     }
 }
-export function projectWorkflowTaskOutput(jsonSrc) {
+const RESUME_REASON_MAX = 120;
+const RESUME_PART_JOIN = ' · ';
+function resumeCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined;
+}
+function workflowResumeLine(resume, lang) {
+    if (typeof resume !== 'object' || resume === null || Array.isArray(resume))
+        return undefined;
+    const own = (key) => (Object.hasOwn(resume, key) ? resume[key] : undefined);
+    const replayed = resumeCount(own('replayed'));
+    const journaledRaw = resumeCount(own('journal_entries'));
+    const journaled = replayed !== undefined && journaledRaw !== undefined && replayed > journaledRaw ? undefined : journaledRaw;
+    const parts = [];
+    if (replayed !== undefined) {
+        parts.push(renderMessage(replayed === 0 && journaled === 0
+            ? msg('session.workflowResume.noJournal')
+            : journaled !== undefined
+                ? msg('session.workflowResume.counts', { replayed, journaled })
+                : msg('session.workflowResume.countsOnly', { replayed }), lang));
+    }
+    const ordinal = resumeCount(own('replay_stopped_at'));
+    const reasonRaw = own('replay_stopped_reason');
+    const reasonShown = typeof reasonRaw === 'string' ? displayUntrusted(reasonRaw, { max: RESUME_REASON_MAX }) : '';
+    const reason = reasonShown.trim() === '' ? undefined : reasonShown;
+    if (ordinal !== undefined && reason !== undefined)
+        parts.push(renderMessage(msg('session.workflowResume.stopAt', { ordinal, reason }), lang));
+    else if (ordinal !== undefined)
+        parts.push(renderMessage(msg('session.workflowResume.stopAtNoReason', { ordinal }), lang));
+    else if (reason !== undefined)
+        parts.push(renderMessage(msg('session.workflowResume.stop', { reason }), lang));
+    return parts.length === 0 ? undefined : renderMessage(msg('session.workflowResume.line', { detail: parts.join(RESUME_PART_JOIN) }), lang);
+}
+export function projectWorkflowTaskOutput(jsonSrc, lang) {
     try {
         const j = JSON.parse(jsonSrc);
         const parts = [];
         if (j.agents && typeof j.agents.done === 'number' && typeof j.agents.total === 'number') {
             parts.push(`agents: ${j.agents.done}/${j.agents.total} done${typeof j.agents.failed === 'number' && j.agents.failed > 0 ? ` (${j.agents.failed} failed)` : ''}`);
         }
+        const resumeLine = workflowResumeLine(j.resume, lang);
+        if (resumeLine !== undefined)
+            parts.push(resumeLine);
         if (Array.isArray(j.agent_runs)) {
             for (const r of j.agent_runs) {
                 if (!r || typeof r !== 'object')

package/dist/workflowClient.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRun, WorkflowStreamEvent } from '@sema-agent/sdk';
+import type { WorkflowRun, WorkflowRunPark, WorkflowStreamEvent } from '@sema-agent/sdk';
 import { type WireAuthTokenSource } from './engineWireSdk.js';
 import type { WorkflowRunState, WorkflowToolCall } from './workflowMonitor.js';
 export interface LiveWorkflowController {
@@ -49,12 +49,7 @@ export interface LiveWorkflowConfig {
     fetchImpl?: typeof fetch;
 }
 export declare function projectWorkflowRun(run: WorkflowRun): WorkflowRunState;
-export interface WorkflowParkRowView {
-    callKey: string;
-    sessionId: string;
-    originRunId: string;
-    originUnconfirmed?: true;
-}
+export type WorkflowParkRowView = WorkflowRunPark;
 export declare function readWorkflowParks(run: unknown): readonly WorkflowParkRowView[] | undefined;
 export declare function readWorkflowResumeAdmissionIncomplete(run: unknown): boolean;
 export interface WorkflowActivityAgentView {

package/dist/workflowsJournalCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
@@ -21,7 +21,7 @@ const reader = createEngineCapReader({
     name: 'workflowsJournal',
     project: projectWorkflowsJournalCapability,
 });
-export function observedWorkflowsJournal(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedWorkflowsJournal(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function workflowsJournalAvailable(reading) {

package/dist/writeProtectionCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectWriteProtectionCapability(caps) {
@@ -66,7 +66,7 @@ const reader = createEngineCapReader({
     name: 'writeProtection',
     project: projectWriteProtectionCapability,
 });
-export function observedWriteProtection(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedWriteProtection(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 const WP_DETAIL_MAX = 40;