sliftutils 1.7.12 → 1.7.14

package/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "Bash(echo \"---EXIT:$?---\")",
       "Bash(yarn publish *)",
       "Bash(git push *)",
-      "Bash(yarn type *)"
+      "Bash(yarn type *)",
+      "Bash(git rm *)"
     ]
   }
 }

package/index.d.ts

@@ -223,6 +223,13 @@ declare module "sliftutils/misc/https/hostServer" {
         setDNSRecord?: boolean;
         publicIp?: string;
         allowHostnames?: string[];
+        /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+        portFallback?: {
+            /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
+            getAcquireDelay: () => number;
+            /** Reports every port we become reachable on (the alternate at mount, the main port once relayed) */
+            onListening: (port: number, isMainPort: boolean) => void;
+        };
     };
     /** Hosts a SocketFunction server on a real domain, with an automatically created and renewed Let's Encrypt HTTPS certificate (cached in the home folder, shared between processes on the machine). Expose your controllers (and any RequireController setup) before calling this. Returns the mounted nodeId. */
     export declare function hostServer(config: HostServerConfig): Promise<string>;
@@ -872,7 +879,7 @@ declare module "sliftutils/storage/ArchivesDisk" {
         private filePath;
         set(key: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
+        }): Promise<string>;
         del(key: string): Promise<void>;
         get(key: string, config?: {
             range?: {
@@ -2222,10 +2229,14 @@ declare module "sliftutils/storage/IArchives" {
          * lastModified stamps the write with that last-write time instead of now. If it is OLDER than
          * the file's current last-write time the write no-ops (so delayed / synchronized writes can
          * never clobber newer data). Times more than 15 minutes in the future are rejected.
+         *
+         * Returns the full key actually written - identical to fileName, EXCEPT for keys containing
+         * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
+         * see ArchivesChain) and the caller needs the returned key to ever read the value back.
          */
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
+        }): Promise<string>;
         del(fileName: string): Promise<void>;
         /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
         setLargeFile(config: {
@@ -2557,7 +2568,7 @@ declare module "sliftutils/storage/backblaze" {
         hasWriteAccess(): Promise<boolean>;
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
+        }): Promise<string>;
         del(fileName: string): Promise<void>;
         setLargeFile(config: {
             path: string;
@@ -2642,11 +2653,6 @@ declare module "sliftutils/storage/backblaze" {
 
 }
 
-declare module "sliftutils/storage/embeddingBench" {
-    export {};
-
-}
-
 declare module "sliftutils/storage/embeddingFormats" {
     export type EmbeddingFormat = "q8g8_2048" | "q8_g16_2048" | "q8_g16_1024" | "float32";
     export declare const EMBEDDING_FORMATS: EmbeddingFormat[];
@@ -2683,16 +2689,6 @@ declare module "sliftutils/storage/embeddingFormats" {
 
 }
 
-declare module "sliftutils/storage/faceFramesData" {
-    export declare function ensureFaceData(fileName: string, byteLength: number): Promise<string>;
-
-}
-
-declare module "sliftutils/storage/faceFramesServer" {
-    export {};
-
-}
-
 declare module "sliftutils/storage/fileSystemPointer" {
     export type FileSystemPointer = string;
     export declare function storeFileSystemPointer(config: {
@@ -2736,11 +2732,6 @@ declare module "sliftutils/storage/proxydatabase/inMemoryDatabase" {
 
 }
 
-declare module "sliftutils/storage/proxydatabase/ivfDbCheck" {
-    export {};
-
-}
-
 declare module "sliftutils/storage/proxydatabase/ivfEmbeddingDatabase" {
     import { Database } from "./Database";
     import { TransactionSetStore } from "./transactionSet";
@@ -2909,7 +2900,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
         } | undefined>;
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
+        }): Promise<string>;
         del(fileName: string): Promise<void>;
         getInfo(fileName: string): Promise<{
             writeTime: number;
@@ -2966,7 +2957,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesUrl" {
         } | undefined>;
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
+        }): Promise<string>;
         del(fileName: string): Promise<void>;
         setLargeFile(config: {
             path: string;
@@ -3019,7 +3010,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             writeTime: number;
             size: number;
         } | undefined>;
-        set(fileName: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        set(fileName: string, data: Buffer, config?: WriteConfig): Promise<string>;
         del(fileName: string, config?: WriteConfig): Promise<void>;
         getInfo(fileName: string): Promise<{
             writeTime: number;
@@ -3065,6 +3056,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         constructor(folder: string, sources: ArchivesSource[], config?: {
             onIndexChanged?: ((key: string) => void) | undefined;
             readerDiskLimit?: number | undefined;
+            getFlushDeadline?: (() => number | undefined) | undefined;
         } | undefined);
         private stopped;
         private index;
@@ -3087,6 +3079,9 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         private countEntry;
         private setIndexEntry;
         private deleteIndexEntry;
+        /** Rescans our own disk's metadata into the index - used around deploy switchovers, where the
+         *  other process wrote files to the shared folder that our index hasn't seen. */
+        rescanBase(): Promise<void>;
         /** The cheap always-current totals plus any in-progress background synchronization. */
         getSyncProgress(): {
             index: {
@@ -3139,7 +3134,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             size: number;
         } | undefined>;
         private cacheRead;
-        set(key: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        set(key: string, data: Buffer, config?: WriteConfig): Promise<string>;
         del(key: string, config?: WriteConfig): Promise<void>;
         private getWritableSources;
         private writeToSources;
@@ -3175,6 +3170,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
     /// <reference types="node" />
     /// <reference types="node" />
     import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
+    import { ServerBucketInfo } from "./storageServerState";
     export declare function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives;
     export declare class ArchivesChain implements IArchives {
         private configured;
@@ -3190,9 +3186,14 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         private init;
         private buildSources;
         private startConfigPoll;
+        private configRefreshInFlight;
+        private refreshActiveConfig;
+        private fetchLatestConfig;
         private checkForNewConfig;
         private run;
         private runWrite;
+        private lastConfigRefresh;
+        private prepareWrongTargetRetry;
         private request;
         waitingForAccess(): Promise<{
             link: string;
@@ -3235,20 +3236,14 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         /** True only when EVERY write-receiving source would accept our writes (partial write access
          *  desynchronizes sources, so it counts as no access). */
         hasWriteAccess(): Promise<boolean>;
-        private assertNotBareVariableShard;
+        /** Returns the full key written. Plain keys come back unchanged; keys containing VARIABLE_SHARD
+         *  are automatically materialized (a shard value is picked and embedded, see setVariableShard)
+         *  and the caller needs the returned key to ever read the value back. */
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
-        }): Promise<void>;
-        del(fileName: string): Promise<void>;
-        /** Writes a key containing the VARIABLE_SHARD sentinel: picks the lowest-latency up write
-         *  shard, materializes the key with a random value inside that shard's route, writes it, and
-         *  returns the FULL key actually written (the caller needs it to ever read the value back).
-         *  Unlike normal writes this CAN move to another shard when the preferred one is down (error +
-         *  socket down, same rule as reads) - each shard receives a different key, so write
-         *  consistency is preserved. */
-        setVariableShard(key: string, data: Buffer, config?: {
-            lastModified?: number;
         }): Promise<string>;
+        del(fileName: string): Promise<void>;
+        private setVariableShard;
         setLargeFile(config: {
             path: string;
             getNextData(): Promise<Buffer | undefined>;
@@ -3257,6 +3252,49 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         dispose(): void;
     }
     export declare function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain;
+    /** Every bucket an account has on one storage server - active and inactive - with each bucket's
+     *  configuration. One authenticated call (the normal trust system applies): no ArchivesChain, no
+     *  synchronization, and inactive buckets on the server stay inactive. Any URL addressing the
+     *  server works (a bucket routing URL, or just https://host:port). */
+    export declare function listServerBuckets(config: {
+        url: string;
+        account: string;
+    }): Promise<ServerBucketInfo[]>;
+    /** Live info for one bucket given its routing URL (getConfig: routing config, index totals, disk
+     *  limit, in-progress synchronization). One authenticated call to that server - a light, safe
+     *  alternative to instantiating an ArchivesChain, which would start synchronization machinery. */
+    export declare function getBucketInfo(config: {
+        url: string;
+        accountName?: string;
+    }): Promise<ArchivesConfig>;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/deployTakeover" {
+    import { RemoteConfig } from "../IArchives";
+    export type TakeoverEvent = "remapChanged" | "diskScan";
+    /** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
+     *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
+     *  port then means a real misconfiguration, not a deploy). */
+    export declare function initDeployTakeover(config: {
+        domain: string;
+        mainPort: number;
+        storageFolder: string;
+    }): Promise<boolean>;
+    /** Called when we had to listen on an alternate port (the main port was still held by our
+     *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
+    export declare function registerAltPort(port: number): Promise<void>;
+    export declare function onTakeoverEvent(listener: (event: TakeoverEvent) => void): void;
+    /** The interpretation overlay: splits every source pointing at our domain+main port so the middle
+     *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
+     *  config is never modified, and this must never be applied to data that gets persisted. */
+    export declare function applyDeployRemap(routing: RemoteConfig): RemoteConfig;
+    /** For the dying process: fast-write flush delays must never extend past this time, and after it
+     *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
+    export declare function getFlushDeadline(): number | undefined;
+    /** How long to wait between main-port acquisition attempts: tight around the predecessor's
+     *  scheduled death (when the port actually frees), relaxed otherwise. */
+    export declare function getMainPortAcquireDelay(): number;
 
 }
 
@@ -3291,6 +3329,7 @@ declare module "sliftutils/storage/remoteStorage/remoteConfig" {
     export declare function parseBackblazeUrl(url: string): {
         bucketName: string;
     };
+    export declare function replaceHostedUrlPort(url: string, port: number): string;
     export declare function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig;
     export declare function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig;
     export declare function parseRoutingData(data: Buffer): RemoteConfig;
@@ -3347,6 +3386,7 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
     /// <reference types="node" />
     /// <reference types="node" />
     import { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
+    import { ServerBucketInfo } from "./storageServerState";
     export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
     export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
     export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
@@ -3417,6 +3457,7 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         }) => Promise<ArchiveFileInfo[]>;
         getChangesAfter: (account: string, bucketName: string, time: number) => Promise<ArchiveFileInfo[]>;
         getArchivesConfig: (account: string, bucketName: string) => Promise<ArchivesConfig>;
+        listBuckets: (account: string) => Promise<ServerBucketInfo[]>;
         getIndexInfo: (account: string, bucketName: string) => Promise<{
             fileCount: number;
             byteCount: number;
@@ -3459,7 +3500,7 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     /// <reference types="node" />
     /// <reference types="node" />
     import { IBucketStore } from "./blobStore";
-    import { RemoteConfig, HostedConfig, IArchives } from "../IArchives";
+    import { RemoteConfig, HostedConfig, IArchives, ArchivesConfig } from "../IArchives";
     import type { IStorage } from "../IStorage";
     import type { AccessRequest, TrustRecord } from "./storageController";
     export type StorageServerConfig = {
@@ -3492,11 +3533,26 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
         self: HostedConfig | undefined;
         store: IBucketStore;
     };
+    export declare function addExtraListenPort(port: number): void;
     export declare function getLoadedBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined>;
     export declare function assertMutable(bucket: LoadedBucket, filePath: string, writeTime: number): Promise<void>;
     export declare function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: {
         lastModified?: number;
     }): Promise<void>;
+    export declare function getBucketConfig(bucket: LoadedBucket): ArchivesConfig;
+    export declare function rebuildAllLoadedBuckets(): Promise<void>;
+    export declare function rescanAllLoadedBucketDisks(): Promise<void>;
+    export type ServerBucketInfo = {
+        bucketName: string;
+        active: boolean;
+        config?: ArchivesConfig;
+        error?: string;
+    };
+    /** Every bucket the account has on this server, active or not, each with its configuration.
+     *  Inactive buckets are inspected straight from disk WITHOUT loading them - loading would start
+     *  their synchronization, and old invalid buckets must stay inert (their parse error is reported
+     *  instead). */
+    export declare function listAccountBuckets(account: string): Promise<ServerBucketInfo[]>;
     export declare function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void>;
     export declare function getLocalArchives(account: string, bucketName: string): IArchives;
 

package/misc/dist/yaml.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -42,4 +42,4 @@ function stringifyYAML(value) {
 }
 exports.stringifyYAML = stringifyYAML;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInlhbWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpREFBbUM7QUFFbkMsU0FBZ0IsU0FBUyxDQUFDLElBQVk7SUFDbEMsSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNuQixJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQztRQUM3QixJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDL0MsQ0FBQztJQUNELElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3ZCLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMvQyxDQUFDO0lBQ0QsSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNuQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDNUIsQ0FBQztBQVZELDhCQVVDO0FBRUQsU0FBZ0IsYUFBYSxDQUFDLEtBQWM7SUFDeEMsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ2pDLENBQUM7QUFGRCxzQ0FFQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHlhbWwgZnJvbSBcIi4veWFtbEJhc2VcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHBhcnNlWUFNTCh0ZXh0OiBzdHJpbmcpOiB1bmtub3duIHtcbiAgICB0ZXh0ID0gdGV4dC50cmltKCk7XG4gICAgaWYgKHRleHQuc3RhcnRzV2l0aChcImBgYHlhbWxcIikpIHtcbiAgICAgICAgdGV4dCA9IHRleHQuc2xpY2UoXCJgYGB5YW1sXCIubGVuZ3RoKS50cmltKCk7XG4gICAgfVxuICAgIGlmICh0ZXh0LmVuZHNXaXRoKFwiYGBgXCIpKSB7XG4gICAgICAgIHRleHQgPSB0ZXh0LnNsaWNlKDAsIC1cImBgYFwiLmxlbmd0aCkudHJpbSgpO1xuICAgIH1cbiAgICB0ZXh0ID0gdGV4dC50cmltKCk7XG4gICAgcmV0dXJuIHlhbWwucGFyc2UodGV4dCk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBzdHJpbmdpZnlZQU1MKHZhbHVlOiB1bmtub3duKTogc3RyaW5nIHtcbiAgICByZXR1cm4geWFtbC5zdHJpbmdpZnkodmFsdWUpO1xufVxuXG4iXX0=
- /* _JS_SOURCE_HASH = "842295d9e84e235d67bbc8cd2064350a75ff84df4b6d53be8b5c7822a03528fa"; */
+ /* _JS_SOURCE_HASH = "6ff947dda36cc08bf827c5dfd19667e64240e3d31c748dbe0ea2852b297ed804"; */