@timurproko/a1 0.2.7-dev.754 → 0.2.7-dev.767

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/resolution.d.ts

@@ -42,4 +42,6 @@ export interface ResolveOwnedUiSettingsInput {
  */
 export declare function resolveOwnedUiSettings(input: ResolveOwnedUiSettingsInput): OwnedUiSettingsResolution;
 export declare function settingValue(resolution: OwnedUiSettingsResolution, id: string): OwnedUiSettingValue | null;
+/** Resolve the launch-routing flag without constructing the UI settings manager. */
+export declare function resolveResidentTabsSetting(document: OwnedUiSettingsDocument | null): boolean;
 export declare function documentFrom(resolution: OwnedUiSettingsResolution): OwnedUiSettingsDocument;

package/dist/ui/settings/resolution.js

@@ -1,4 +1,4 @@
-import { OWNED_UI_SETTINGS_VERSION, findOwnedUiSettingDeclaration, } from "./declarations.js";
+import { OWNED_SETTING_DECLARATIONS, OWNED_UI_SETTINGS_VERSION, findOwnedUiSettingDeclaration, } from "./declarations.js";
 import { migrationsFrom } from "./migrations.js";
 export function parseOwnedUiSettingsDocument(raw) {
     let parsed;
@@ -122,6 +122,18 @@ export function resolveOwnedUiSettings(input) {
 export function settingValue(resolution, id) {
     return resolution.settings.find(setting => setting.declaration.id === id)?.value ?? null;
 }
+/** Resolve the launch-routing flag without constructing the UI settings manager. */
+export function resolveResidentTabsSetting(document) {
+    if (document === null || document.version !== OWNED_UI_SETTINGS_VERSION)
+        return false;
+    const resolution = resolveOwnedUiSettings({
+        declarations: [OWNED_SETTING_DECLARATIONS.residentTabs],
+        migrations: [],
+        document,
+        currentVersion: OWNED_UI_SETTINGS_VERSION,
+    });
+    return settingValue(resolution, "residentTabs") === true;
+}
 export function documentFrom(resolution) {
     const values = { ...resolution.preserved };
     for (const setting of resolution.settings) {

package/dist/ui/settings/sections.js

@@ -2,7 +2,11 @@ export const AGENT_SECTION_ID = "agent";
 const BOOLEAN_CHOICES = Object.freeze([true, false]);
 export function buildOwnedUiSettingsSections(input) {
     const grouped = new Map();
+    const residentTabsEnabled = input.resolution.settings
+        .find(setting => setting.declaration.id === "residentTabs")?.value === true;
     for (const setting of input.resolution.settings) {
+        if (!residentTabsEnabled && ["tabsUnresponsiveRestartSeconds", "tabsStallNoticeSeconds"].includes(setting.declaration.id))
+            continue;
         const section = setting.declaration.section ?? { id: "a1", title: "A1" };
         const group = grouped.get(section.id) ?? { title: section.title, entries: [] };
         group.entries.push({

package/docs/architecture/internal-naming.md

@@ -31,7 +31,7 @@ The exact externally branded key/member authority is `config/internal-naming-pol
 | `A1_PROCESS_GUARDIAN_PATH` | Explicit executable override in `src/foundation/process-containment/native-guardian-containment.ts`, also configured by CI; exact existing exposure-review entry. |
 | `A1_PROBE_TRACE` | Opt-in diagnostics read by native terminal-host code; exact existing exposure-review entry. |
 | `A1_BUILD_VERBOSE`, `A1_DEV_SHELL` | Developer invocation controls in the build helper and development launcher; exact existing exposure-review entries. |
-| `A1_PANE_ID`, `A1_TERMINAL_SESSION_ID` | Produced by `native/terminal-host/src/workspace.rs` and exported to launched programs; external integration names, unchanged. |
+| `A1_PANE_ID`, `A1_TERMINAL_SESSION_ID` | Reserved compatibility identities retained in the product identity manifest; the resident host does not currently emit them. |
 
 Pending review preserves a possible external interface, not an obsolete private alias. Once a setting is established as private, it cannot keep its branded spelling through that category.