@chainingintention/pi-web-cn 2.202610.4 → 2.202611.1

package/dist/pi-web-plugins/workspace-tasks/config.js

@@ -1,5 +1,4 @@
 // Generated from pi-web-plugins/workspace-tasks/config.ts. Do not edit directly.
-import { t } from "./i18n.js";
 export const TASKS_CONFIG_PATH = ".pi-web/tasks.json";
 export const TASKS_CONFIG_VERSION = 1;
 const taskIdPattern = /^[a-z][a-z0-9.-]*$/u;
@@ -9,18 +8,18 @@ export function parseTasksConfigText(text) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        return { ok: false, error: t("bundled.workspace-tasks.invalid.json.17242b", "Invalid JSON: {value1}", { value1: error instanceof Error ? error.message : String(error) }) };
+        return { ok: false, error: { kind: "json", error: error instanceof Error ? error.message : String(error) } };
     }
     return parseTasksConfig(parsed);
 }
 export function parseTasksConfig(value) {
     if (!isRecord(value))
-        return invalid(t("bundled.workspace-tasks.config.must.be.an.object.ac0503", "Config must be an object"));
+        return invalid({ kind: "object" });
     if (value["version"] !== TASKS_CONFIG_VERSION)
-        return invalid(t("bundled.workspace-tasks.config.version.must.be.1.ca03d7", "Config version must be 1"));
+        return invalid({ kind: "version" });
     const tasks = value["tasks"];
     if (!Array.isArray(tasks))
-        return invalid(t("bundled.workspace-tasks.config.tasks.must.be.an.array.5c6ec9", "Config tasks must be an array"));
+        return invalid({ kind: "tasks" });
     const ids = new Set();
     const parsedTasks = [];
     for (const [index, task] of tasks.entries()) {
@@ -28,36 +27,36 @@ export function parseTasksConfig(value) {
         if (!parsedTask.ok)
             return parsedTask;
         if (ids.has(parsedTask.task.id))
-            return invalid(t("bundled.workspace-tasks.duplicate.task.id.bd4749", "Duplicate task id: {value1}", { value1: parsedTask.task.id }));
+            return invalid({ kind: "duplicate", id: parsedTask.task.id });
         ids.add(parsedTask.task.id);
         parsedTasks.push(parsedTask.task);
     }
     return { ok: true, config: { version: TASKS_CONFIG_VERSION, tasks: parsedTasks } };
 }
 function parseTask(value, index) {
-    const label = t("bundled.workspace-tasks.task.17bccc", "Task {value1}", { value1: String(index + 1) });
+    index += 1;
     if (!isRecord(value))
-        return invalid(t("bundled.workspace-tasks.must.be.an.object.f7baec", "{value1} must be an object", { value1: label }));
-    const id = requireNonEmptyString(value, "id", label);
+        return invalid({ kind: "task-object", index });
+    const id = requireNonEmptyString(value, "id", index);
     if (!id.ok)
         return id;
     if (!taskIdPattern.test(id.value))
-        return invalid(t("bundled.workspace-tasks.id.must.match.8c38f3", "{value1} id must match {value2}", { value1: label, value2: taskIdPattern.source }));
-    const title = requireNonEmptyString(value, "title", label);
+        return invalid({ kind: "id", index, pattern: taskIdPattern.source });
+    const title = requireNonEmptyString(value, "title", index);
     if (!title.ok)
         return title;
-    const command = requireNonEmptyString(value, "command", label);
+    const command = requireNonEmptyString(value, "command", index);
     if (!command.ok)
         return command;
-    const description = optionalNonEmptyString(value, "description", label);
+    const description = optionalNonEmptyString(value, "description", index);
     if (!description.ok)
         return description;
-    const group = optionalNonEmptyString(value, "group", label);
+    const group = optionalNonEmptyString(value, "group", index);
     if (!group.ok)
         return group;
     const confirm = value["confirm"];
     if (confirm !== undefined && typeof confirm !== "boolean")
-        return invalid(t("bundled.workspace-tasks.confirm.must.be.a.boolean.f785a1", "{value1} confirm must be a boolean", { value1: label }));
+        return invalid({ kind: "confirm", index });
     return {
         ok: true,
         task: {
@@ -70,18 +69,18 @@ function parseTask(value, index) {
         },
     };
 }
-function requireNonEmptyString(record, key, label) {
+function requireNonEmptyString(record, key, index) {
     const value = record[key];
     if (typeof value !== "string" || value.trim() === "")
-        return invalid(t("bundled.workspace-tasks.must.be.a.non.empty.string.838d0a", "{value1} {value2} must be a non-empty string", { value1: label, value2: key }));
+        return invalid({ kind: "required", index, field: key });
     return { ok: true, value };
 }
-function optionalNonEmptyString(record, key, label) {
+function optionalNonEmptyString(record, key, index) {
     const value = record[key];
     if (value === undefined)
         return { ok: true, value: undefined };
     if (typeof value !== "string" || value.trim() === "")
-        return invalid(t("bundled.workspace-tasks.must.be.a.non.empty.string.when.provided.a6f9ee", "{value1} {value2} must be a non-empty string when provided", { value1: label, value2: key }));
+        return invalid({ kind: "optional", index, field: key });
     return { ok: true, value };
 }
 function invalid(error) {

package/dist/pi-web-plugins/workspace-tasks/pi-web-plugin.js

@@ -1,7 +1,8 @@
 // Generated from pi-web-plugins/workspace-tasks/pi-web-plugin.ts. Do not edit directly.
-import { t, setTranslator } from "./i18n.js";
+import { createTasksLocalization } from "./tasksLocalization.js";
 import { TASKS_CONFIG_PATH } from "./config.js";
 import { defineTasksPanelElement, tasksPanelBadge } from "./tasksPanelElement.js";
+import { setTranslator } from "./i18n.js";
 const stylesheetIntegrationCapability = {
     pluginId: "pi-web", id: "stylesheet-integration", version: 1,
     parse(value) {
@@ -19,10 +20,14 @@ function isStylesheetIntegration(value) {
 }
 const plugin = {
     apiVersion: 4,
-    name: t("bundled.workspace-tasks.workspace.tasks.b4ef49", "Workspace tasks"),
+    name: "Workspace tasks",
     requires: [stylesheetIntegrationCapability],
-    activate: ({ runtimePluginId, html, svg, translate }) => {
+    activate: ({ runtimePluginId, html, svg, localization, translate }) => {
         setTranslator(translate);
+        if (localization === undefined)
+            throw new Error("The Workspace Tasks plugin requires a localization-capable PI WEB host");
+        const translations = createTasksLocalization(localization);
+        const { messages } = translations;
         defineTasksPanelElement();
         let stylesheetIntegration;
         return {
@@ -33,9 +38,9 @@ const plugin = {
                 actions: [
                     {
                         id: "workspace.open-tasks",
-                        title: t("bundled.workspace-tasks.open.workspace.tasks.6243e7", "Open workspace tasks"),
-                        description: t("bundled.workspace-tasks.open.the.workspace.tasks.tab.configure.tasks.in.d72915", "Open the workspace tasks tab. Configure tasks in {value1}.", { value1: TASKS_CONFIG_PATH }),
-                        group: t("bundled.workspace-tasks.workspace.379798", "Workspace"),
+                        get title() { return messages.t("openTasks"); },
+                        get description() { return messages.t("openDescription", { path: TASKS_CONFIG_PATH }); },
+                        get group() { return messages.t("workspace"); },
                         enabled: (context) => context.state.selectedWorkspace !== undefined,
                         run: (context) => {
                             if (context.state.selectedWorkspace === undefined)
@@ -47,7 +52,7 @@ const plugin = {
                 workspacePanels: [
                     {
                         id: "workspace.tasks",
-                        title: t("bundled.workspace-tasks.tasks.525304", "Tasks"),
+                        get title() { return messages.t("tasks"); },
                         icon: svg `
               <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
                 <path d="M9 6h11"></path>
@@ -60,7 +65,7 @@ const plugin = {
             `,
                         order: 40,
                         badge: (context) => tasksPanelBadge(context),
-                        render: (context) => html `<pi-web-workspace-tasks-panel .stylesheetIntegration=${stylesheetIntegration} .context=${context}></pi-web-workspace-tasks-panel>`,
+                        render: (context) => html `<pi-web-workspace-tasks-panel .translations=${translations} .stylesheetIntegration=${stylesheetIntegration} .context=${context}></pi-web-workspace-tasks-panel>`,
                     },
                 ],
             },

package/dist/pi-web-plugins/workspace-tasks/tasks.messages.js

@@ -0,0 +1,45 @@
+// Generated from pi-web-plugins/workspace-tasks/tasks.messages.ts. Do not edit directly.
+function text(message, description) {
+    return { message, description };
+}
+export default {
+    workspaceTasks: text("Workspace Tasks", "Tasks toolbar title"),
+    tasks: text("Tasks", "Workspace panel tab title"),
+    workspace: text("Workspace", "Action palette group"),
+    openTasks: text("Open Workspace Tasks", "Action that opens the Tasks tab"),
+    openDescription: text("Open the workspace Tasks tab. Configure tasks in {path}.", "Action description; path is a config file path"),
+    selectWorkspace: text("Select a workspace.", "Empty panel with no selected workspace"),
+    refresh: text("Refresh", "Reload task configuration"),
+    openTerminal: text("Open Terminal", "Open the workspace terminal"),
+    loading: text("Loading {path}…", "Task configuration loading state"),
+    missing: text("No workspace tasks configured here.", "Missing optional tasks configuration"),
+    missingHint: text("{path} is optional. Create it in this workspace if you want custom tasks.", "Help for a missing tasks file"),
+    unavailable: text("Could not load workspace tasks.", "Task configuration failure heading"),
+    refreshHint: text("Fix {path}, then click Refresh.", "Recovery instruction for invalid tasks configuration"),
+    empty: text("No tasks are defined in {path}. Add tasks to the file, then click Refresh.", "Loaded configuration with no tasks"),
+    instructions: text("Tasks run in a dedicated workspace terminal, then switch to that terminal. Edit {path} and click Refresh to reload.", "Instructions above task list"),
+    taskGone: text("That task is no longer available. Click Refresh, then try again.", "Task disappeared before dispatch"),
+    refreshing: text("Refreshing {path}…", "Refresh operation status"),
+    loaded: text("Loaded {count, plural, one {# task} other {# tasks}}.", "Refresh success with task count"),
+    busy: text("Another task is already starting. Wait for it to finish dispatching, then try again.", "Concurrent task dispatch blocked"),
+    confirm: text("Run {title}?\n\n{command}", "Native task confirmation; title and command are unmodified user content"),
+    cancelled: text("Cancelled {title}.", "Task confirmation cancelled"),
+    starting: text("Starting {title}…", "Task dispatch in progress"),
+    started: text("Started terminal command “{title}”.", "Terminal command dispatch success"),
+    selectTerminal: text("Select a workspace before opening a terminal.", "Terminal action without workspace"),
+    dispatching: text("Dispatching…", "Task button while dispatching"),
+    run: text("Run", "Dispatch a task"),
+    readError: text("Unable to read {path}: {error}", "Read failure; backend error is unmodified"),
+    binary: text("{path} must be a text file", "Binary task configuration rejected"),
+    truncated: text("{path} is too large and was truncated", "Truncated task configuration rejected"),
+    invalidJson: text("Invalid JSON: {error}", "JSON parse failure; native parser diagnostic is unmodified"),
+    configObject: text("Config must be an object", "Task configuration validation failure"),
+    configVersion: text("Config version must be {version, number}", "Required tasks schema version; field name version is an identifier"),
+    configTasks: text("Config tasks must be an array", "Tasks field validation; tasks is a field identifier"),
+    duplicate: text("Duplicate task id: {id}", "Duplicate user-specified task identifier"),
+    taskObject: text("Task {index, number} must be an object", "Invalid task at one-based array index"),
+    taskId: text("Task {index, number} id must match {pattern}", "Invalid task id; pattern is a regular expression"),
+    requiredField: text("Task {index, number} {field} must be a non-empty string", "Required task field validation; field is a schema identifier"),
+    optionalField: text("Task {index, number} {field} must be a non-empty string when provided", "Optional task field validation; field is a schema identifier"),
+    taskConfirm: text("Task {index, number} confirm must be a boolean", "Invalid confirm field at one-based task index"),
+};

package/dist/pi-web-plugins/workspace-tasks/tasksLocalization.js

@@ -0,0 +1,33 @@
+// Generated from pi-web-plugins/workspace-tasks/tasksLocalization.ts. Do not edit directly.
+import { TASKS_CONFIG_PATH, TASKS_CONFIG_VERSION } from "./config.js";
+import definitions from "./tasks.messages.js";
+export function createTasksLocalization(localization) {
+    const messages = localization.registerMessages("tasks", definitions);
+    return {
+        localization,
+        messages,
+        loadIssue: (issue) => {
+            switch (issue.kind) {
+                case "read": return messages.t("readError", { path: TASKS_CONFIG_PATH, error: issue.error });
+                case "unexpected": return issue.error;
+                case "binary": return messages.t("binary", { path: TASKS_CONFIG_PATH });
+                case "truncated": return messages.t("truncated", { path: TASKS_CONFIG_PATH });
+                case "config": return configIssue(issue.issue);
+            }
+        },
+    };
+    function configIssue(issue) {
+        switch (issue.kind) {
+            case "json": return messages.t("invalidJson", { error: issue.error });
+            case "object": return messages.t("configObject");
+            case "version": return messages.t("configVersion", { version: TASKS_CONFIG_VERSION });
+            case "tasks": return messages.t("configTasks");
+            case "duplicate": return messages.t("duplicate", { id: issue.id });
+            case "task-object": return messages.t("taskObject", { index: issue.index });
+            case "id": return messages.t("taskId", { index: issue.index, pattern: issue.pattern });
+            case "required": return messages.t("requiredField", { index: issue.index, field: issue.field });
+            case "optional": return messages.t("optionalField", { index: issue.index, field: issue.field });
+            case "confirm": return messages.t("taskConfirm", { index: issue.index });
+        }
+    }
+}

package/dist/pi-web-plugins/workspace-tasks/tasksPanelElement.js

@@ -2,7 +2,7 @@
 import { t } from "./i18n.js";
 import { TASKS_CONFIG_PATH } from "./config.js";
 import { runWorkspaceTaskInTerminal } from "./taskRunner.js";
-import { loadWorkspaceTasksConfig, tasksConfigRefreshHint, tasksConfigUnavailableMessage } from "./workspaceTasksClient.js";
+import { loadWorkspaceTasksConfig } from "./workspaceTasksClient.js";
 export const tasksPanelTagName = "pi-web-workspace-tasks-panel";
 const configChangedEvent = "pi-web-workspace-tasks-config-changed";
 const configCache = new Map();
@@ -15,6 +15,26 @@ export function tasksPanelBadge(context) {
     return state?.kind === "unavailable" ? "!" : undefined;
 }
 export class PiWebTasksPanel extends HTMLElement {
+    translationsValue;
+    releaseLocalization;
+    set translations(value) {
+        if (value === this.translationsValue)
+            return;
+        this.releaseLocalization?.();
+        this.releaseLocalization = undefined;
+        this.translationsValue = value;
+        if (this.isConnected)
+            this.subscribeLocalization();
+        this.render();
+    }
+    subscribeLocalization() {
+        this.releaseLocalization ??= this.translationsValue?.localization.subscribe(() => { this.render(); });
+    }
+    get messages() {
+        if (this.translationsValue === undefined)
+            throw new Error("Tasks panel localization has not been initialized");
+        return this.translationsValue.messages;
+    }
     integration;
     releaseStyles;
     set stylesheetIntegration(value) {
@@ -28,6 +48,7 @@ export class PiWebTasksPanel extends HTMLElement {
     }
     contextValue;
     runningTaskId;
+    taskDispatchVersion = 0;
     status;
     root;
     localStyle = document.createElement("style");
@@ -53,34 +74,39 @@ export class PiWebTasksPanel extends HTMLElement {
         // doing so resets the mobile scroll position and can replace buttons mid-click.
         if (previousKey === nextKey)
             return;
+        this.taskDispatchVersion += 1;
         this.runningTaskId = undefined;
         this.status = undefined;
         this.render();
     }
     connectedCallback() {
+        this.subscribeLocalization();
         this.releaseStyles ??= this.integration?.registerRoot(this.root, { sharedUi: true });
         window.addEventListener(configChangedEvent, this.onConfigChanged);
         this.render();
     }
     disconnectedCallback() {
+        this.releaseLocalization?.();
+        this.releaseLocalization = undefined;
         this.releaseStyles?.();
         this.releaseStyles = undefined;
         window.removeEventListener(configChangedEvent, this.onConfigChanged);
     }
     render() {
+        if (this.translationsValue === undefined)
+            return;
         const context = this.contextValue;
         if (context === undefined) {
-            this.setContent(`<section class="empty">${escapeHtml(t("bundled.workspace-tasks.select.a.workspace.95796d", "Select a workspace."))}</section>`);
+            this.setContent(`<section class="empty">${escapeHtml(this.messages.t("selectWorkspace"))}</section>`);
             return;
         }
         const state = getOrLoadWorkspaceConfig(context);
         this.setContent(`
-
-      <section class="toolbar ui-toolbar">
-        <strong class="ui-toolbar-title toolbar-title">${escapeHtml(t("bundled.workspace-tasks.workspace.tasks.b4ef49", "Workspace tasks"))}</strong>
+      <section class="ui-toolbar toolbar">
+        <strong class="ui-toolbar-title toolbar-title">${escapeHtml(this.messages.t("workspaceTasks"))}</strong>
         <span class="ui-toolbar-group">
-          <button type="button" class="ui-button" data-refresh-config ${state.kind === "loading" ? "disabled" : ""}>${escapeHtml(t("bundled.workspace-tasks.refresh.aee887", "Refresh"))}</button>
-          <button type="button" class="ui-button" data-open-terminal>${escapeHtml(t("bundled.workspace-tasks.open.terminal.b89a0e", "Open terminal"))}</button>
+          <button type="button" class="ui-button" data-refresh-config ${state.kind === "loading" ? "disabled" : ""}>${escapeHtml(this.messages.t("refresh"))}</button>
+          <button type="button" class="ui-button" data-open-terminal>${escapeHtml(this.messages.t("openTerminal"))}</button>
         </span>
       </section>
       ${this.renderStatus()}
@@ -105,7 +131,7 @@ export class PiWebTasksPanel extends HTMLElement {
             return Promise.resolve();
         const task = taskFromConfigState(getCachedWorkspaceConfig(context), taskId);
         if (task === undefined) {
-            this.status = { kind: "error", message: t("bundled.workspace-tasks.this.task.is.no.longer.available.click.refresh.and.try.again.158c41", "This task is no longer available. Click Refresh and try again.") };
+            this.status = { kind: "error", message: () => this.messages.t("taskGone") };
             this.render();
             return Promise.resolve();
         }
@@ -116,74 +142,87 @@ export class PiWebTasksPanel extends HTMLElement {
     }
     renderConfigState(state) {
         if (state.kind === "loading")
-            return `<p class="muted">${escapeHtml(t("bundled.workspace-tasks.loading.9f624f", "Loading {value1}...", { value1: TASKS_CONFIG_PATH }))}</p>`;
+            return `<p class="muted">${escapeHtml(this.messages.t("loading", { path: TASKS_CONFIG_PATH }))}</p>`;
         if (state.kind === "missing")
-            return renderMissingState(state);
+            return `<div class="empty-state"><strong>${escapeHtml(this.messages.t("missing"))}</strong><p>${escapeHtml(this.messages.t("missingHint", { path: TASKS_CONFIG_PATH }))}</p></div>`;
         if (state.kind === "unavailable")
-            return renderUnavailableState(state);
+            return `<div class="status error"><strong>${escapeHtml(this.messages.t("unavailable"))}</strong><p>${escapeHtml(this.messages.t("refreshHint", { path: TASKS_CONFIG_PATH }))}</p><pre>${escapeHtml(this.translationsValue?.loadIssue(state.detail))}</pre></div>`;
         if (state.config.tasks.length === 0)
-            return `<p class="muted">${escapeHtml(t("bundled.workspace-tasks.no.tasks.defined.in.add.tasks.to.the.file.then.click.refresh.3af272", "No tasks defined in {value1}. Add tasks to the file, then click Refresh.", { value1: state.path }))}</p>`;
+            return `<p class="muted">${escapeHtml(this.messages.t("empty", { path: state.path }))}</p>`;
         return `
-      <p class="muted">${escapeHtml(t("bundled.workspace-tasks.tasks.run.in.a.dedicated.workspace.terminal.and.switch.to.it.edit.3188f4", "Tasks run in a dedicated workspace terminal and switch to it. Edit {value1}, then click Refresh to reload.", { value1: state.path }))}</p>
-      ${renderTaskGroups(state.config.tasks, this.runningTaskId)}
+      <p class="muted">${escapeHtml(this.messages.t("instructions", { path: state.path }))}</p>
+      ${renderTaskGroups(state.config.tasks, this.runningTaskId, this.messages)}
     `;
     }
     renderStatus() {
         if (this.status === undefined)
             return "";
         const detail = this.status.detail === undefined ? "" : `<pre>${escapeHtml(this.status.detail)}</pre>`;
-        return `<div class="status panel-status ${escapeAttr(this.status.kind)}">${escapeHtml(this.status.message)}${detail}</div>`;
+        return `<div class="status panel-status ${escapeAttr(this.status.kind)}">${escapeHtml(this.status.message())}${detail}</div>`;
     }
     async refreshConfig(context) {
-        this.status = { kind: "info", message: t("bundled.workspace-tasks.refreshing.b85709", "Refreshing {value1}...", { value1: TASKS_CONFIG_PATH }) };
+        this.status = { kind: "info", message: () => this.messages.t("refreshing", { path: TASKS_CONFIG_PATH }) };
         configCache.set(cacheKeyForContext(context), { kind: "loading" });
         this.render();
         const state = await refreshWorkspaceConfig(context);
         if (!this.isCurrentContext(context))
             return;
         this.status = state.kind === "loaded"
-            ? { kind: "success", message: t("bundled.workspace-tasks.loaded.tasks.cc36a1", "Loaded {value1} tasks.", { value1: String(state.config.tasks.length) }) }
+            ? { kind: "success", message: () => this.messages.t("loaded", { count: state.config.tasks.length }) }
             : undefined;
         this.render();
     }
     async dispatchTask(context, task) {
         if (this.runningTaskId !== undefined) {
-            this.status = { kind: "info", message: t("bundled.workspace-tasks.another.task.is.starting.wait.for.dispatch.to.finish.and.try.agai.e4971f", "Another task is starting. Wait for dispatch to finish and try again.") };
+            this.status = { kind: "info", message: () => this.messages.t("busy") };
             this.render();
             return;
         }
-        if (task.confirm && !window.confirm(t("bundled.workspace-tasks.run.e5ba41", "Run {value1}?\n\n{value2}", { value1: task.title, value2: task.command }))) {
-            this.status = { kind: "info", message: t("bundled.workspace-tasks.cancelled.1a65c2", "Cancelled {value1}.", { value1: task.title }) };
+        if (task.confirm && !window.confirm(this.messages.t("confirm", { title: task.title, command: task.command }))) {
+            this.status = { kind: "info", message: () => this.messages.t("cancelled", { title: task.title }) };
             this.render();
             return;
         }
+        const dispatchVersion = ++this.taskDispatchVersion;
         this.runningTaskId = task.id;
-        this.status = { kind: "info", message: t("bundled.workspace-tasks.starting.80ae5c", "Starting {value1}...", { value1: task.title }) };
+        this.status = { kind: "info", message: () => this.messages.t("starting", { title: task.title }) };
         this.render();
         try {
             const handle = await runWorkspaceTaskInTerminal(context.terminal, task);
-            if (!this.isCurrentContext(context))
+            if (this.isCurrentContext(context) && dispatchVersion === this.taskDispatchVersion) {
+                this.status = {
+                    kind: "info",
+                    message: () => this.messages.t("started", { title: handle.run.title }),
+                    detail: task.command,
+                };
+                this.runningTaskId = undefined;
+                this.render();
+            }
+            const completed = await handle.completed;
+            if (!this.isCurrentContext(context) || dispatchVersion !== this.taskDispatchVersion)
                 return;
             this.status = {
-                kind: "success",
-                message: t("bundled.workspace-tasks.started.terminal.command.318e6c", "Started terminal command \"{value1}\".", { value1: handle.run.title }),
-                detail: task.command,
+                kind: completed.status === "succeeded" ? "success" : "error",
+                message: () => completed.status === "succeeded"
+                    ? t("bundled.workspace-tasks.completed", "Completed {title}.", { title: completed.title })
+                    : t("bundled.workspace-tasks.failed", "Failed {title}.", { title: completed.title }),
+                detail: completed.exitCode === undefined ? task.command
+                    : t("bundled.workspace-tasks.exit-code", "Exit code: {code}\n{command}", { code: String(completed.exitCode), command: task.command }),
             };
-            this.runningTaskId = undefined;
             this.render();
         }
         catch (error) {
-            if (!this.isCurrentContext(context))
+            if (!this.isCurrentContext(context) || dispatchVersion !== this.taskDispatchVersion)
                 return;
             this.runningTaskId = undefined;
-            this.status = { kind: "error", message: error instanceof Error ? error.message : String(error) };
+            this.status = { kind: "error", message: () => error instanceof Error ? error.message : String(error) };
             this.render();
         }
     }
     openWorkspaceTerminal(terminalId) {
         const context = this.contextValue;
         if (context === undefined) {
-            this.status = { kind: "error", message: t("bundled.workspace-tasks.select.a.workspace.before.opening.a.terminal.1f87b4", "Select a workspace before opening a terminal.") };
+            this.status = { kind: "error", message: () => this.messages.t("selectTerminal") };
             this.render();
             return;
         }
@@ -209,9 +248,7 @@ async function refreshWorkspaceConfig(context) {
     const key = cacheKeyForContext(context);
     const state = await loadWorkspaceTasksConfig(context.files).catch((error) => ({
         kind: "unavailable",
-        message: tasksConfigUnavailableMessage(),
-        hint: tasksConfigRefreshHint(),
-        detail: error instanceof Error ? error.message : String(error),
+        detail: { kind: "unexpected", error: error instanceof Error ? error.message : String(error) },
     }));
     configCache.set(key, state);
     context.host.requestRender();
@@ -221,15 +258,8 @@ async function refreshWorkspaceConfig(context) {
 function cacheKeyForContext(context) {
     return `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
 }
-function renderMissingState(state) {
-    return `<div class="empty-state"><strong>${escapeHtml(state.message)}</strong><p>${escapeHtml(state.hint)}</p></div>`;
-}
-function renderUnavailableState(state) {
-    const detail = state.detail === undefined ? "" : `<pre>${escapeHtml(state.detail)}</pre>`;
-    return `<div class="status error"><strong>${escapeHtml(state.message)}</strong><p>${escapeHtml(state.hint)}</p>${detail}</div>`;
-}
-function renderTaskGroups(tasks, runningTaskId) {
-    return `<div class="tasks">${groupTasks(tasks).map((group) => renderTaskGroup(group, runningTaskId)).join("")}</div>`;
+function renderTaskGroups(tasks, runningTaskId, messages) {
+    return `<div class="tasks">${groupTasks(tasks).map((group) => renderTaskGroup(group, runningTaskId, messages)).join("")}</div>`;
 }
 function groupTasks(tasks) {
     const groups = [];
@@ -244,11 +274,11 @@ function groupTasks(tasks) {
     }
     return groups;
 }
-function renderTaskGroup(group, runningTaskId) {
+function renderTaskGroup(group, runningTaskId, messages) {
     const title = group.title === undefined ? "" : `<h3>${escapeHtml(group.title)}</h3>`;
-    return `<section class="task-group">${title}${group.tasks.map((task) => renderTask(task, runningTaskId)).join("")}</section>`;
+    return `<section class="task-group">${title}${group.tasks.map((task) => renderTask(task, runningTaskId, messages)).join("")}</section>`;
 }
-function renderTask(task, runningTaskId) {
+function renderTask(task, runningTaskId, messages) {
     const running = runningTaskId === task.id;
     const disabled = runningTaskId !== undefined;
     const description = task.description === undefined ? "" : `<span>${escapeHtml(task.description)}</span>`;
@@ -259,7 +289,7 @@ function renderTask(task, runningTaskId) {
         ${description}
         <code>${escapeHtml(task.command)}</code>
       </div>
-      <button type="button" class="ui-button ui-button--primary" data-task-id="${escapeAttr(task.id)}" ${disabled ? "disabled" : ""}>${escapeHtml(running ? t("bundled.workspace-tasks.dispatching.f0ad17", "Dispatching...") : t("bundled.workspace-tasks.run.75b269", "Run"))}</button>
+      <button type="button" class="ui-button ui-button--primary" data-task-id="${escapeAttr(task.id)}" ${disabled ? "disabled" : ""}>${escapeHtml(running ? messages.t("dispatching") : messages.t("run"))}</button>
     </article>
   `;
 }
@@ -271,7 +301,6 @@ function taskFromConfigState(state, taskId) {
 function taskStyles() {
     return `
       :host { display: contents; }
-      .toolbar { border-bottom: 1px solid var(--pi-border-muted); }
       .toolbar-title { padding-inline: 10px; }
       .viewer { box-sizing: border-box; min-height: 0; overflow: auto; padding: 12px; }
       .tasks-viewer { display: grid; align-content: start; gap: 12px; }

package/dist/pi-web-plugins/workspace-tasks/workspaceTasksClient.js

@@ -1,10 +1,5 @@
 // Generated from pi-web-plugins/workspace-tasks/workspaceTasksClient.ts. Do not edit directly.
-import { t } from "./i18n.js";
 import { TASKS_CONFIG_PATH, parseTasksConfigText } from "./config.js";
-export const tasksConfigMissingMessage = () => t("bundled.workspace-tasks.no.workspace.tasks.configured.here.bb6994", "No workspace tasks configured here.");
-export const tasksConfigMissingHint = () => t("bundled.workspace-tasks.is.optional.create.it.in.this.workspace.for.custom.tasks.306cdb", "{value1} is optional. Create it in this workspace for custom tasks.", { value1: TASKS_CONFIG_PATH });
-export const tasksConfigUnavailableMessage = () => t("bundled.workspace-tasks.could.not.load.workspace.tasks.977b0c", "Could not load workspace tasks.");
-export const tasksConfigRefreshHint = () => t("bundled.workspace-tasks.fix.then.click.refresh.04d032", "Fix {value1}, then click Refresh.", { value1: TASKS_CONFIG_PATH });
 const missingWorkspaceFileError = "Path does not exist";
 export async function loadWorkspaceTasksConfig(files) {
     let file;
@@ -13,41 +8,20 @@ export async function loadWorkspaceTasksConfig(files) {
             ? await files.readFile(TASKS_CONFIG_PATH)
             : await files.readOptionalFile(TASKS_CONFIG_PATH);
         if (optionalFile === undefined)
-            return missing();
+            return { kind: "missing" };
         file = optionalFile;
     }
     catch (error) {
-        if (errorMessage(error) === missingWorkspaceFileError)
-            return missing();
-        return unavailable(t("bundled.workspace-tasks.unable.to.read.3b416a", "Unable to read {value1}: {value2}", { value1: TASKS_CONFIG_PATH, value2: formatUnknownError(error) }));
+        if (error instanceof Error && error.message === missingWorkspaceFileError)
+            return { kind: "missing" };
+        return { kind: "unavailable", detail: { kind: "read", error: error instanceof Error ? error.message : String(error) } };
     }
     if (file.binary)
-        return unavailable(t("bundled.workspace-tasks.must.be.a.text.file.3648c8", "{value1} must be a text file", { value1: TASKS_CONFIG_PATH }));
+        return { kind: "unavailable", detail: { kind: "binary" } };
     if (file.truncated)
-        return unavailable(t("bundled.workspace-tasks.is.too.large.and.was.truncated.ce18be", "{value1} is too large and was truncated", { value1: TASKS_CONFIG_PATH }));
+        return { kind: "unavailable", detail: { kind: "truncated" } };
     const result = parseTasksConfigText(file.content);
     if (!result.ok)
-        return unavailable(result.error);
+        return { kind: "unavailable", detail: { kind: "config", issue: result.error } };
     return { kind: "loaded", config: result.config, path: TASKS_CONFIG_PATH };
 }
-function missing() {
-    return {
-        kind: "missing",
-        message: tasksConfigMissingMessage(),
-        hint: tasksConfigMissingHint(),
-    };
-}
-function unavailable(detail) {
-    return {
-        kind: "unavailable",
-        message: tasksConfigUnavailableMessage(),
-        hint: tasksConfigRefreshHint(),
-        detail,
-    };
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : undefined;
-}
-function formatUnknownError(error) {
-    return error instanceof Error ? error.message : String(error);
-}