@timurproko/a1 0.2.6 → 0.2.7-dev.1222

package/dist/ui/settings/manager.js

@@ -1,10 +1,11 @@
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { assertAgentSettingDescriptor } from "../../contracts/agent-engine/index.js";
 import { OWNED_SETTING_DECLARATIONS, OWNED_UI_SETTINGS_VERSION, OWNED_UI_SETTING_DECLARATIONS, } from "./declarations.js";
-import { OWNED_UI_SETTINGS_MIGRATIONS } from "./migrations.js";
-import { documentFrom, parseOwnedUiSettingsDocument, resolveOwnedUiSettings, } from "./resolution.js";
+import { OWNED_UI_SETTINGS_MIGRATIONS, normalizeOwnedUiSettingsValues, } from "./migrations.js";
+import { parseOwnedUiSettingsDocument, resolveOwnedUiSettings, } from "./resolution.js";
 import { buildOwnedUiSettingsSections, findOwnedUiSettingsEntry, } from "./sections.js";
+import { readProfileSettingsNamespace, repairProfileSettingsDocument, updateProfileSettingsNamespace, } from "./profile-document.js";
 const PROFILE_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
 const MAX_DOCUMENT_BYTES = 256 * 1024;
 /**
@@ -15,11 +16,14 @@ const MAX_DOCUMENT_BYTES = 256 * 1024;
  */
 export class OwnedSettingsManager {
     #file;
+    #legacyFile;
+    #namespace;
     #declarations;
     #migrations;
     #agent;
     #agentProvider;
     #listeners = new Set();
+    #hiddenOwnedSettingIds;
     #hiddenAgentSettingIds;
     #agentSettingLabelOverrides;
     #resolution;
@@ -30,11 +34,19 @@ export class OwnedSettingsManager {
         if (!PROFILE_ID_PATTERN.test(options.profileId)) {
             throw new Error(`owned UI settings profile id is not a bounded slug: ${options.profileId}`);
         }
-        this.#file = path.join(path.resolve(options.configDir), "settings", `${options.profileId}.json`);
+        const profileDir = options.profileDir ?? options.configDir;
+        if (profileDir === undefined)
+            throw new Error("owned UI settings require a profile directory");
+        this.#file = path.join(path.resolve(profileDir), "settings.json");
+        this.#legacyFile = options.legacyConfigDir === undefined
+            ? null
+            : path.join(path.resolve(options.legacyConfigDir), "settings", `${options.profileId}.json`);
+        this.#namespace = options.namespace ?? options.profileId;
         this.#declarations = options.declarations ?? OWNED_UI_SETTING_DECLARATIONS;
         this.#migrations = options.migrations ?? OWNED_UI_SETTINGS_MIGRATIONS;
         this.#agent = options.agent ?? null;
         this.#agentProvider = options.agentProvider ?? null;
+        this.#hiddenOwnedSettingIds = new Set(options.hiddenOwnedSettingIds ?? []);
         this.#hiddenAgentSettingIds = new Set(options.hiddenAgentSettingIds ?? []);
         this.#agentSettingLabelOverrides = { ...(options.agentSettingLabelOverrides ?? {}) };
         this.#resolution = this.read();
@@ -49,24 +61,59 @@ export class OwnedSettingsManager {
     get resolution() {
         return this.#resolution;
     }
-    /** Reads and resolves the stored document. Never throws: every failure becomes a notice. */
+    /** Reads and resolves the product namespace. Never throws: every failure becomes a notice. */
     read() {
+        try {
+            repairProfileSettingsDocument(this.#file);
+        }
+        catch {
+            // Compatibility: recovery is opportunistic; unreadable-document handling stays authoritative.
+        }
+        const shared = readProfileSettingsNamespace(this.#file, this.#namespace);
+        if (shared.status === "available") {
+            if (Buffer.byteLength(JSON.stringify(shared.value), "utf8") > MAX_DOCUMENT_BYTES) {
+                return this.#resolveNamespace(null, `${this.#file} contains a ${this.#namespace} namespace exceeding the ${MAX_DOCUMENT_BYTES}-byte settings limit`);
+            }
+            return this.#resolveCompatibleNamespace(shared.value);
+        }
+        if (shared.status === "invalid")
+            return this.#resolveNamespace(null, shared.detail);
+        return this.#readLegacy();
+    }
+    #resolveCompatibleNamespace(values) {
+        const compatibility = normalizeOwnedUiSettingsValues(values);
+        return compatibility.values === null
+            ? this.#resolveNamespace(null, compatibility.failure ?? "product settings compatibility failed")
+            : this.#resolveNamespace(compatibility.values);
+    }
+    #resolveNamespace(values, unreadableDetail) {
+        return resolveOwnedUiSettings({
+            declarations: this.#declarations,
+            migrations: [],
+            document: values === null ? null : { version: OWNED_UI_SETTINGS_VERSION, values },
+            ...(unreadableDetail === undefined ? {} : { unreadableDetail }),
+            currentVersion: OWNED_UI_SETTINGS_VERSION,
+        });
+    }
+    #readLegacy() {
+        if (this.#legacyFile === null)
+            return this.#resolveNamespace(null);
         let raw = null;
         let unreadable = null;
         try {
-            raw = readFileSync(this.#file, "utf8");
+            raw = readFileSync(this.#legacyFile, "utf8");
         }
         catch (error) {
             if (!isMissing(error))
-                unreadable = `${this.#file} could not be read: ${describe(error)}`;
+                unreadable = `${this.#legacyFile} could not be read: ${describe(error)}`;
         }
         if (raw !== null && Buffer.byteLength(raw, "utf8") > MAX_DOCUMENT_BYTES) {
-            unreadable = `${this.#file} exceeds the ${MAX_DOCUMENT_BYTES}-byte settings limit and was ignored`;
+            unreadable = `${this.#legacyFile} exceeds the ${MAX_DOCUMENT_BYTES}-byte settings limit and was ignored`;
             raw = null;
         }
         const document = raw === null ? null : parseOwnedUiSettingsDocument(raw);
         if (raw !== null && document === null && unreadable === null) {
-            unreadable = `${this.#file} is not a valid settings document and was ignored`;
+            unreadable = `${this.#legacyFile} is not a valid settings document and was ignored`;
         }
         return resolveOwnedUiSettings({
             declarations: this.#declarations,
@@ -82,8 +129,36 @@ export class OwnedSettingsManager {
         this.#agentSnapshot = agent === null ? null : await snapshotOf(agent, this.#hiddenAgentSettingIds);
         this.#notify();
     }
+    /**
+     * Adopts values another process stored in the shared document. Notifies only when a
+     * resolved value differs, so a peer's own write echo stays silent. Restart-bound values
+     * keep their session-start effect and surface as pending instead.
+     */
+    refresh() {
+        const next = this.read();
+        if (resolvedValuesKey(next) === resolvedValuesKey(this.#resolution))
+            return false;
+        this.#resolution = next;
+        for (const setting of next.settings) {
+            const id = setting.declaration.id;
+            if (!this.#restartEffective.has(id))
+                continue;
+            if (setting.value === this.#restartEffective.get(id))
+                this.#pending.delete(id);
+            else
+                this.#pending.set(id, setting.value);
+        }
+        this.#notify();
+        return true;
+    }
     sections() {
-        return buildOwnedUiSettingsSections({ resolution: this.#resolution, agent: this.#agentSnapshot }).map(section => ({
+        const resolution = this.#hiddenOwnedSettingIds.size === 0
+            ? this.#resolution
+            : {
+                ...this.#resolution,
+                settings: this.#resolution.settings.filter(setting => !this.#hiddenOwnedSettingIds.has(setting.declaration.id)),
+            };
+        return buildOwnedUiSettingsSections({ resolution, agent: this.#agentSnapshot }).map(section => ({
             ...section,
             entries: section.entries.map(entry => {
                 if (entry.backend === "a1" && this.#restartEffective.has(entry.id)) {
@@ -113,9 +188,13 @@ export class OwnedSettingsManager {
         return () => this.#listeners.delete(listener);
     }
     async changeStructured(backend, id, value) {
-        if (backend !== "agent")
-            return failed("only an agent setting holds a structured value");
-        return await this.#changeAgentValue(id, value);
+        if (backend === "agent")
+            return await this.#changeAgentValue(id, value);
+        // Invariant: a flagged A1 setting stores its enabled parts as one value, in declaration order.
+        const flags = findOwnedUiSettingsEntry(this.sections(), id, "a1")?.flags ?? [];
+        if (flags.length === 0)
+            return failed(`${id} holds no structured value`);
+        return await this.change("a1", id, flags.filter(flag => value[flag.key] === true).map(flag => flag.key).join(","));
     }
     async change(backend, id, value) {
         const entry = findOwnedUiSettingsEntry(this.sections(), id, backend);
@@ -126,7 +205,7 @@ export class OwnedSettingsManager {
         return backend === "a1" ? this.#changeOwned(id, value) : await this.#changeAgentValue(id, value);
     }
     #changeOwned(id, value) {
-        const outcome = this.#write(this.#resolution, id, value);
+        const outcome = this.#write(id, value);
         if (!outcome.stored)
             return failed(outcome.failure ?? `${id} could not be stored`);
         const previous = this.#resolution;
@@ -141,35 +220,34 @@ export class OwnedSettingsManager {
         this.#notify();
         return changed("applied", "live", value, value);
     }
-    // Invariant: the resolved form is written with `id` set to `value` and undeclared keys preserved.
-    // Concurrency: a temporary sibling is renamed over the target, so an interrupted write leaves
-    // either the complete previous document or the complete new one.
-    #write(resolution, id, value) {
+    // Invariant: only non-default declared values and unknown product properties are stored.
+    // Concurrency: the namespace updater rereads current JSON while holding Pi's compatible lock.
+    #write(id, value) {
         const declaration = this.#declarations.find(candidate => candidate.id === id);
         if (!declaration)
             return { stored: false, failure: `unknown owned UI setting: ${id}` };
         if (!declaration.allowedValues.includes(value)) {
             return { stored: false, failure: `value ${JSON.stringify(value)} is not allowed for ${id}` };
         }
-        const current = documentFrom(resolution);
-        const next = {
-            version: OWNED_UI_SETTINGS_VERSION,
-            values: { ...current.values, [id]: value },
-        };
-        const temporary = `${this.#file}.${process.pid}.tmp`;
         try {
-            mkdirSync(path.dirname(this.#file), { recursive: true, mode: 0o700 });
-            writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-            renameSync(temporary, this.#file);
+            updateProfileSettingsNamespace(this.#file, this.#namespace, current => {
+                let latest = this.#readLegacy();
+                if (current !== null) {
+                    const compatibility = normalizeOwnedUiSettingsValues(current);
+                    if (compatibility.values === null)
+                        throw new Error(compatibility.failure ?? "product settings compatibility failed");
+                    latest = this.#resolveNamespace(compatibility.values);
+                }
+                const next = compactValues(latest);
+                if (value === declaration.defaultValue)
+                    delete next[id];
+                else
+                    next[id] = value;
+                return Object.keys(next).length === 0 ? null : next;
+            });
             return { stored: true, failure: null };
         }
         catch (error) {
-            try {
-                rmSync(temporary, { force: true });
-            }
-            catch {
-                // Security: a leftover temporary file is inert: read() only ever opens the target path.
-            }
             return { stored: false, failure: `${this.#file} could not be written: ${describe(error)}` };
         }
     }
@@ -218,6 +296,9 @@ async function snapshotOf(agent, hidden) {
         return { descriptors: [], writeAdvertised: false, failure: describe(error) };
     }
 }
+function resolvedValuesKey(resolution) {
+    return JSON.stringify(resolution.settings.map(setting => [setting.declaration.id, setting.value]));
+}
 function failed(failure) {
     return {
         status: "failed",
@@ -254,6 +335,14 @@ function fromAgentOutcome(result) {
         failure: result.failure,
     };
 }
+function compactValues(resolution) {
+    const values = { ...resolution.preserved };
+    for (const setting of resolution.settings) {
+        if (setting.value !== setting.declaration.defaultValue)
+            values[setting.declaration.id] = setting.value;
+    }
+    return values;
+}
 function isMissing(error) {
     return typeof error === "object" && error !== null && error.code === "ENOENT";
 }

package/dist/ui/settings/migrations.d.ts

@@ -9,5 +9,11 @@ export interface OwnedUiSettingsMigration {
  * is the first stored shape.
  */
 export declare const OWNED_UI_SETTINGS_MIGRATIONS: readonly OwnedUiSettingsMigration[];
+export interface OwnedUiSettingsCompatibilityResult {
+    readonly values: Readonly<Record<string, unknown>> | null;
+    readonly failure: string | null;
+}
+/** Shape-selected compatibility for the metadata-free product object. */
+export declare function normalizeOwnedUiSettingsValues(source: Readonly<Record<string, unknown>>): OwnedUiSettingsCompatibilityResult;
 export declare function assertOwnedUiSettingsMigrations(migrations: readonly OwnedUiSettingsMigration[], currentVersion?: number): void;
 export declare function migrationsFrom(migrations: readonly OwnedUiSettingsMigration[], storedVersion: number): readonly OwnedUiSettingsMigration[];

package/dist/ui/settings/migrations.js

@@ -104,7 +104,80 @@ export const OWNED_UI_SETTINGS_MIGRATIONS = Object.freeze([
             return { ...values };
         },
     }),
+    Object.freeze({
+        to: 14,
+        description: "Introduce the opt-in resident tabs preview with a disabled default.",
+        migrate(values) {
+            return { ...values };
+        },
+    }),
+    Object.freeze({
+        to: 15,
+        description: "Introduce the bounded concurrent resident-tab start limit.",
+        migrate(values) {
+            return { ...values };
+        },
+    }),
+    Object.freeze({
+        to: 16,
+        description: "Make bare A1 tabs unconditional and keep only tab UX controls.",
+        migrate(values) {
+            const migrated = { ...values };
+            delete migrated.residentTabs;
+            delete migrated.tabsMaxConcurrentStarts;
+            delete migrated.tabsUnresponsiveRestartSeconds;
+            delete migrated.tabsStallNoticeSeconds;
+            return migrated;
+        },
+    }),
+    Object.freeze({
+        to: 17,
+        description: "Introduce the shared twelve-hour time format default.",
+        migrate(values) {
+            return { ...values };
+        },
+    }),
+    Object.freeze({
+        to: 18,
+        description: "Introduce the top resident tab-bar position default.",
+        migrate(values) {
+            return { ...values };
+        },
+    }),
+    Object.freeze({
+        to: 19,
+        description: "Expand the update check into auto, notify, and no modes.",
+        migrate(values) {
+            if (values.updateCheck === true)
+                return { ...values, updateCheck: "notify" };
+            if (values.updateCheck === false)
+                return { ...values, updateCheck: "no" };
+            return { ...values };
+        },
+    }),
 ]);
+/** Shape-selected compatibility for the metadata-free product object. */
+export function normalizeOwnedUiSettingsValues(source) {
+    const values = { ...source };
+    // Compatibility: "high" is valid again, so the old speed meaning is ambiguous without legacy metadata.
+    if (values.scrollbarAppearance === "hover")
+        values.scrollbarAppearance = "auto";
+    if (values.accentColor === "default")
+        values.accentColor = "purple";
+    if (values.updateCheck === true)
+        values.updateCheck = "notify";
+    else if (values.updateCheck === false)
+        values.updateCheck = "no";
+    if (values.quitEffect === "off") {
+        if (Object.hasOwn(values, "quitAnimation") && values.quitAnimation !== false) {
+            return { values: null, failure: "legacy quitEffect conflicts with quitAnimation" };
+        }
+        values.quitAnimation = false;
+    }
+    delete values.quitEffect;
+    delete values.quitEffectDurationMs;
+    return { values, failure: null };
+}
 export function assertOwnedUiSettingsMigrations(migrations, currentVersion = OWNED_UI_SETTINGS_VERSION) {
     const firstProduced = currentVersion - migrations.length + 1;
     if (migrations.length > 0 && firstProduced < 2) {

package/dist/ui/settings/profile-document.d.ts

@@ -0,0 +1,26 @@
+export type ProfileSettingsNamespaceRead = {
+    readonly status: "missing";
+    readonly value: null;
+} | {
+    readonly status: "available";
+    readonly value: Readonly<Record<string, unknown>>;
+} | {
+    readonly status: "invalid";
+    readonly value: null;
+    readonly detail: string;
+};
+export type ProfileSettingsNamespaceUpdate = (current: Readonly<Record<string, unknown>> | null) => Readonly<Record<string, unknown>> | null;
+/** Refuse an injected namespace already claimed by the surrounding root schema. */
+export declare function assertProfileSettingsNamespaceAvailable(namespace: string, rootSettingKeys: readonly string[]): void;
+/** Read one product-owned root object without exposing unrelated profile settings. */
+export declare function readProfileSettingsNamespace(file: string, namespace: string): ProfileSettingsNamespaceRead;
+/**
+ * Remove bounded leading noise only when the remaining bytes are one complete root object.
+ * The repair is silent and uses the same lock and atomic replacement path as namespace writes.
+ */
+export declare function repairProfileSettingsDocument(file: string): boolean;
+/**
+ * Replace one root namespace through the lock protocol used by pinned Pi.
+ * The updater receives bytes reread while locked, so unrelated concurrent writes survive.
+ */
+export declare function updateProfileSettingsNamespace(file: string, namespace: string, update: ProfileSettingsNamespaceUpdate): void;

package/dist/ui/settings/profile-document.js

@@ -0,0 +1,164 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import lockfile from "proper-lockfile";
+const NAMESPACE_PATTERN = /^[a-z][a-z0-9-]*$/;
+const MAX_RECOVERABLE_PREFIX_BYTES = 256;
+/** Refuse an injected namespace already claimed by the surrounding root schema. */
+export function assertProfileSettingsNamespaceAvailable(namespace, rootSettingKeys) {
+    assertNamespace(namespace);
+    if (rootSettingKeys.includes(namespace))
+        throw new Error(`profile settings namespace collides with a root setting: ${namespace}`);
+}
+/** Read one product-owned root object without exposing unrelated profile settings. */
+export function readProfileSettingsNamespace(file, namespace) {
+    assertNamespace(namespace);
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (isMissing(error))
+            return { status: "missing", value: null };
+        return { status: "invalid", value: null, detail: `${file} could not be read: ${describe(error)}` };
+    }
+    const root = parseRoot(raw);
+    if (root === null)
+        return { status: "invalid", value: null, detail: `${file} is not a valid settings object` };
+    if (!Object.hasOwn(root, namespace))
+        return { status: "missing", value: null };
+    const value = root[namespace];
+    if (!isRecord(value)) {
+        return { status: "invalid", value: null, detail: `${file} contains a non-object ${namespace} settings namespace` };
+    }
+    return { status: "available", value: Object.freeze({ ...value }) };
+}
+/**
+ * Remove bounded leading noise only when the remaining bytes are one complete root object.
+ * The repair is silent and uses the same lock and atomic replacement path as namespace writes.
+ */
+export function repairProfileSettingsDocument(file) {
+    if (!existsSync(file))
+        return false;
+    const release = acquireLock(file);
+    try {
+        if (!existsSync(file))
+            return false;
+        const raw = readFileSync(file, "utf8");
+        if (parseRoot(raw) !== null)
+            return false;
+        const root = parseRootAfterLeadingNoise(raw);
+        if (root === null)
+            return false;
+        replaceRoot(file, root);
+        return true;
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Replace one root namespace through the lock protocol used by pinned Pi.
+ * The updater receives bytes reread while locked, so unrelated concurrent writes survive.
+ */
+export function updateProfileSettingsNamespace(file, namespace, update) {
+    assertNamespace(namespace);
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    const release = acquireLock(file);
+    try {
+        const root = existsSync(file) ? parseRoot(readFileSync(file, "utf8")) : {};
+        if (root === null)
+            throw new Error(`${file} is not a valid settings object`);
+        const existing = root[namespace];
+        if (existing !== undefined && !isRecord(existing)) {
+            throw new Error(`${file} contains a non-object ${namespace} settings namespace`);
+        }
+        const nextNamespace = update(existing === undefined ? null : Object.freeze({ ...existing }));
+        const nextRoot = { ...root };
+        if (nextNamespace === null || Object.keys(nextNamespace).length === 0)
+            delete nextRoot[namespace];
+        else
+            nextRoot[namespace] = { ...nextNamespace };
+        replaceRoot(file, nextRoot);
+    }
+    finally {
+        release();
+    }
+}
+function acquireLock(file) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return lockfile.lockSync(file, { realpath: false });
+        }
+        catch (error) {
+            if (attempt >= 9 || !isLocked(error))
+                throw error;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        }
+    }
+}
+function replaceRoot(file, root) {
+    let temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(root, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        renameSync(temporary, file);
+        temporary = null;
+    }
+    finally {
+        if (temporary !== null) {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch {
+                // Invariant: failed temporary cleanup cannot make the target document authoritative.
+            }
+        }
+    }
+}
+function parseRoot(raw) {
+    return parseRootValue(stripBom(raw));
+}
+function parseRootAfterLeadingNoise(raw) {
+    const withoutBom = stripBom(raw);
+    const start = withoutBom.indexOf("{");
+    if (start <= 0)
+        return null;
+    const prefix = withoutBom.slice(0, start);
+    if (Buffer.byteLength(prefix, "utf8") > MAX_RECOVERABLE_PREFIX_BYTES || prefix.trim().length === 0)
+        return null;
+    try {
+        JSON.parse(prefix);
+        return null;
+    }
+    catch {
+        return parseRootValue(withoutBom.slice(start));
+    }
+}
+function parseRootValue(raw) {
+    try {
+        const value = JSON.parse(raw);
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stripBom(raw) {
+    return raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNamespace(namespace) {
+    if (!NAMESPACE_PATTERN.test(namespace))
+        throw new Error(`profile settings namespace is invalid: ${namespace}`);
+}
+function isMissing(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isLocked(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ELOCKED";
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/ui/settings/progress-palette.generated.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Generated by scripts/pi/sync-progress-palette.ts from A1's named accent projection
+ * over pinned Pi 1.4.0 (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. Do not edit directly.
+ */
+export declare const SHARED_PROGRESS_PALETTE: Readonly<{
+    blue: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    purple: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    cyan: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    green: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    orange: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+    pink: {
+        dark: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+        light: {
+            truecolor: {
+                accent: string;
+                border: string;
+            };
+            "256color": {
+                accent: string;
+                border: string;
+            };
+        };
+    };
+}>;
+export declare const SHARED_PROGRESS_ACCENT_ANSI: string;