@maudecode/talaria-web 1.11.0 → 1.12.1

package/dist/tools/updates.d.ts

@@ -31,7 +31,12 @@ export declare const runPackageNpm: BuildRun;
 export declare const isGitLockError: (output: string) => boolean;
 /** Python `_sanitize_git_diagnostic`: strip URL userinfo, GitHub token shapes, and secret query values. */
 export declare function sanitizeGitDiagnostic(output: string, limit?: number): string;
+/** One delayed retry absorbs a transient network blip; a lock conflict is not transient. */
+export declare const FETCH_RETRY_MS = 1000;
+/** `transient`: GitHub was unreachable, slow, or overloaded, so a retry can succeed; the rest describe published state. */
 export declare class ReleaseUnavailable extends Error {
+    readonly transient: boolean;
+    constructor(message: string, transient?: boolean);
 }
 export type GetJson = (path: string, opts: {
     asset: boolean;
@@ -51,6 +56,22 @@ export interface PublishedRelease {
 }
 /** Python `published_web_release`: the newest completed `release-set-<sha>` whose Web component matches the channel's tag family. */
 export declare function publishedWebRelease(channel: Channel, getJson: GetJson, now?: () => number): Promise<PublishedRelease>;
+export declare const EXPERIMENTAL_TARBALL_CAP = 200000000;
+/** The `experimental` tag of the public GHCR artifact: identity from its annotations, content by digest. */
+export interface ExperimentalRelease {
+    tag: string;
+    version: string;
+    sourceRevision: string;
+    digest: string;
+    size: number;
+}
+export interface ExperimentalRegistry {
+    release: () => Promise<ExperimentalRelease>;
+    /** The layer bytes, verified against the release digest and size. */
+    download: (release: ExperimentalRelease) => Promise<Buffer>;
+}
+/** Anonymous GHCR client with `githubJson`'s timeouts, caps, and transient classification. */
+export declare function ghcrExperimental(fetchImpl: typeof fetch): ExperimentalRegistry;
 /** The git root when `webRoot` is `<root>/web` of a Talaria checkout with a GitHub `maudecode/talaria` origin; else null. */
 export declare function checkoutRoot(webRoot: string | null, git: GitRun): Promise<string | null>;
 export interface NpmInstallInfo {
@@ -70,9 +91,17 @@ export interface ReleaseIdentity {
     runningSourceRevision: () => string | null;
 }
 /** Python `check_web_update`. */
-export declare function checkWebUpdate(webRoot: string | null, currentVersion: string, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, npmRun?: BuildRun): Promise<Dict>;
+export declare function checkWebUpdate(webRoot: string | null, currentVersion: string, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, npmRun?: BuildRun, registry?: ExperimentalRegistry): Promise<Dict>;
+/** Packaged-install collaborators: the Experimental registry and Web's state dir for channel-switch backups. */
+export interface PackagedUpdateOptions {
+    registry?: ExperimentalRegistry | undefined;
+    stateDir?: string | undefined;
+}
+export declare const CHANNEL_SWITCH_BACKUPS = 5;
+/** Copy the persisted stores to `<stateDir>/backups/channel-switch-<UTC timestamp>/`, keeping the newest few; throws on failure. */
+export declare function backupPersistedStores(stateDir: string, now?: Date, keep?: number): string;
 /** Python `apply_web_update`: fast-forward a recognized clean checkout to main or a published Stable tag. */
-export declare function applyWebUpdate(webRoot: string | null, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, build?: BuildRun, npmRun?: BuildRun, canApply?: () => boolean): Promise<Dict>;
+export declare function applyWebUpdate(webRoot: string | null, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, build?: BuildRun, npmRun?: BuildRun, canApply?: () => boolean, packaged?: PackagedUpdateOptions): Promise<Dict>;
 export interface AgentUpdatePolicy {
     supportedRevision: string;
     supportedVersion: string;
@@ -111,17 +140,30 @@ export interface UpdateServiceDeps {
     git?: GitRun;
     /** Runs the checkout's npm install/build steps after a source update (default: the npm beside this node). */
     build?: BuildRun;
-    /** Runs global npm discovery/install for packaged Stable updates. */
+    /** Runs global npm discovery/install for packaged updates. */
     npm?: BuildRun;
     getJson: GetJson;
+    /** The public GHCR Experimental artifact that npm installs follow on the Experimental channel. */
+    experimental?: ExperimentalRegistry;
+    /** Web's state dir; channel switches back up its persisted stores here first. */
+    stateDir?: string;
     identity: ReleaseIdentity;
     webuiVersion: string;
+    /** Re-derive the installed Web version after a check (tags can arrive after startup); returns the current label. */
+    refreshWebuiVersion?: () => string;
     agentDir: () => string | null;
     channel: () => Channel;
     agentChannel?: () => Channel;
     includeAgent: () => boolean;
     autoApply?: () => boolean;
     checkEnabled?: () => boolean;
+    autoNotification?: {
+        begin: () => string;
+        transition: (id: string, phase: 'restarting' | 'succeeded' | 'blocked' | 'failed', expectedIdentity?: string | null, verifiedIdentity?: {
+            revision: string | null;
+            version: string | null;
+        }) => void;
+    };
     blockers: () => RestartBlockers;
     /** Re-exec the server once active work drains (`restartWhenSafe`). */
     scheduleRestart: () => void;
@@ -138,6 +180,7 @@ export declare class UpdateService {
     private readonly cache;
     private checking;
     private checkingKey;
+    private readonly lastGood;
     private applying;
     private autoTimer;
     private autoStarted;
@@ -155,10 +198,13 @@ export declare class UpdateService {
     cachedStatus(includeAgent?: boolean, channel?: Channel, agentChannel?: Channel): Dict;
     /** 30 min cache keyed on both channels + include_agent; one in-flight check per key. */
     check(force?: boolean, includeAgent?: boolean, channel?: Channel, agentChannel?: Channel): Promise<Dict>;
+    /** A failed fetch (`stale_check`) keeps the channel's last good result until the cache TTL, so a network blip never flips the status; persistent failures surface. */
+    private keepLastGood;
     startAutoApply(intervalMs?: number): void;
     stopAutoApply(): void;
     /** Shared turn admission stays closed from update start through the supervisor restart. */
     blocksNewWork(): boolean;
+    private pendingRestartResponse;
     autoApplyOnce(): Promise<Dict | null>;
     blockedResponse(target: string): Dict | null;
     private locked;