@timurproko/a1 0.2.6-dev.736 → 0.2.7-dev.1221

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;

package/dist/ui/settings/progress-palette.generated.js

@@ -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 const SHARED_PROGRESS_PALETTE = Object.freeze({
+    "blue": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;130;160;241m",
+                "border": "\u001b[38;2;116;102;197m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;111m",
+                "border": "\u001b[38;5;98m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;63;96;226m",
+                "border": "\u001b[38;2;83;67;154m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;62m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "purple": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;167;152;215m",
+                "border": "\u001b[38;2;105;115;167m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;140m",
+                "border": "\u001b[38;5;61m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;116;89;180m",
+                "border": "\u001b[38;2;68;77;130m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;97m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "cyan": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;93;179;186m",
+                "border": "\u001b[38;2;74;128;146m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;73m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;40;122;129m",
+                "border": "\u001b[38;2;40;89;106m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;30m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "green": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;104;183;141m",
+                "border": "\u001b[38;2;75;132;120m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;72m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;51;126;88m",
+                "border": "\u001b[38;2;41;93;82m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;65m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "orange": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;231;135;83m",
+                "border": "\u001b[38;2;178;89;79m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;173m",
+                "border": "\u001b[38;5;131m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;174;80;16m",
+                "border": "\u001b[38;2;133;57;49m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;130m",
+                "border": "\u001b[38;5;95m"
+            }
+        }
+    },
+    "pink": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;223;122;199m",
+                "border": "\u001b[38;2;150;91;171m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;176m",
+                "border": "\u001b[38;5;97m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;178;56;153m",
+                "border": "\u001b[38;2;114;61;131m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;132m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    }
+});
+export const SHARED_PROGRESS_ACCENT_ANSI = SHARED_PROGRESS_PALETTE.blue.dark.truecolor.accent;

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

@@ -49,4 +49,8 @@ export interface BuildOwnedUiSettingsSectionsInput {
 }
 export declare const AGENT_SECTION_ID = "agent";
 export declare function buildOwnedUiSettingsSections(input: BuildOwnedUiSettingsSectionsInput): readonly OwnedUiSettingsSection[];
+/** The enabled parts a flagged A1 setting's comma-separated value names, as the record its dialog edits. */
+export declare function flagRecord(flags: readonly {
+    readonly key: string;
+}[], value: unknown): Record<string, boolean>;
 export declare function findOwnedUiSettingsEntry(sections: readonly OwnedUiSettingsSection[], id: string, backend: OwnedUiSettingsBackend): OwnedUiSettingsEntry | null;

package/dist/ui/settings/sections.js

@@ -5,20 +5,21 @@ export function buildOwnedUiSettingsSections(input) {
     for (const setting of input.resolution.settings) {
         const section = setting.declaration.section ?? { id: "a1", title: "A1" };
         const group = grouped.get(section.id) ?? { title: section.title, entries: [] };
+        const flagged = setting.declaration.flags;
         group.entries.push({
             id: setting.declaration.id,
             label: setting.declaration.label ?? null,
             backend: "a1",
             description: setting.declaration.description,
             value: setting.value,
-            rawValue: setting.value,
+            rawValue: flagged === undefined ? setting.value : flagRecord(flagged, setting.value),
             storedValue: setting.value,
             effectiveValue: setting.value,
             editable: true,
-            structured: false,
+            structured: flagged !== undefined,
             minimum: null,
             maximum: null,
-            flags: [],
+            flags: flagged?.map(flag => ({ ...flag, fallback: false })) ?? [],
             choices: setting.declaration.allowedValues,
             origin: setting.source,
             application: setting.declaration.application === "restart" ? "next-start" : "live",
@@ -44,6 +45,11 @@ export function buildOwnedUiSettingsSections(input) {
     };
     return Object.freeze([...ownedSections, combinedAgent]);
 }
+/** The enabled parts a flagged A1 setting's comma-separated value names, as the record its dialog edits. */
+export function flagRecord(flags, value) {
+    const enabled = new Set(typeof value === "string" ? value.split(",") : []);
+    return Object.fromEntries(flags.map(flag => [flag.key, enabled.has(flag.key)]));
+}
 export function findOwnedUiSettingsEntry(sections, id, backend) {
     for (const section of sections) {
         const entry = section.entries.find(candidate => candidate.id === id && candidate.backend === backend);