@peers-app/peers-sdk 0.30.1 → 0.30.3

package/dist/contracts/system/file-storage-contract.d.ts

@@ -14,7 +14,7 @@ export interface IChunkMigrationResult {
     files: number;
     /** Distinct chunks those rows list, less the skipped ones. */
     needed: number;
-    /** Chunks only orphaned legacy bundle rows list, which aren't copied. */
+    /** Chunks only orphaned runtime bundle rows list, which aren't copied. */
     skippedBundleChunks: number;
     /** Needed chunks the store already had. */
     alreadyStored: number;
@@ -35,6 +35,86 @@ export interface IChunkMigrationResult {
  * `verified`.
  */
 export type ChunkMigrationState = "not-needed" | "pending" | "running" | "blocked" | "verified";
+/** Why a file is retained, or where it is in its local retention window. */
+export type FileCollectionState = "kept" | "referenced" | "never" | "waiting" | "expired" | "unindexed" | "disabled";
+/** Ordinary-file retention on this device; runtime bundles always use grace alone. */
+export type FileRetention = number | "never";
+/** One context's part of a collection plan; chunk totals may overlap other contexts. */
+export interface IFileCollectionContextResult {
+    dataContextId: string;
+    disabled: boolean;
+    retentionMs: FileRetention;
+    files: number;
+    expiredFiles: number;
+    /** Chunks/bytes eligible in this plan, including shared expired chunks; a concurrent put can keep them longer. */
+    chunksEligible: number;
+    bytesEligible: number;
+    rowsDeleted: number;
+    /** Next file deadline after this run's planning time. */
+    nextExpirationAt?: number;
+    /** Next chunk age deadline among expired files (deletion requires strictly older). */
+    nextChunkAt?: number;
+}
+/** A collection run. Dry runs report eligible chunks/bytes and bundle rows in the deletion totals, but delete nothing. */
+export interface IFileCollectionResult {
+    state: "completed" | "skipped" | "stopped";
+    dryRun: boolean;
+    reason?: string;
+    contexts: IFileCollectionContextResult[];
+    files: number;
+    expiredFiles: number;
+    liveChunks: number;
+    chunksFreed: number;
+    bytesFreed: number;
+    rowsDeleted: number;
+    problems: string[];
+    startedAt: number;
+    finishedAt: number;
+}
+/** A file in a paged, device-local list. */
+export interface IListedFile {
+    fileId: string;
+    name: string;
+    fileSize: number;
+    mimeType: string;
+    kept: boolean;
+    legacy: boolean;
+    /** Runtime-owned bundle, whether saved by an older or current installer. */
+    runtimeBundle: boolean;
+    referenceCount: number;
+    referenceTables: string[];
+    chunks: "all" | "some" | "none";
+    unreferencedAt?: number;
+    state: FileCollectionState;
+    /** Earliest collection deadline here; shared chunks and the chunk age floor can keep bytes longer. */
+    expiresAt?: number;
+    /** Why there is no deadline, when applicable. */
+    retainedReason?: string;
+}
+/** Context totals, counting logical file bytes (shared content counts for each file). */
+export interface IFileListSummary {
+    files: number;
+    bytes: number;
+    states: Record<FileCollectionState, number>;
+    retentionMs: FileRetention;
+}
+/** Keyset paging in file-id order. */
+export interface IListFilesInput {
+    after?: string;
+    /** Page size, 1–200; defaults to 50. */
+    limit?: number;
+}
+/** One page and context totals, with a cursor only when more rows remain. */
+export interface IListFilesResult {
+    files: IListedFile[];
+    nextCursor?: string;
+    summary: IFileListSummary;
+}
+/** Forced reindex outcome for every loaded context. */
+export interface IFileReindexResult {
+    contexts: number;
+    problems: string[];
+}
 /** This device's chunk storage for the signed-in account. */
 export interface IFileStorageStatus {
     /** The account's chunk store. */
@@ -48,6 +128,12 @@ export interface IFileStorageStatus {
         /** Accounts on this device still to migrate; it can be removed once none are left. */
         waitingAccounts: string[];
     };
+    /** Collection's state in this session and its next scheduled run. */
+    collection?: {
+        state: "idle" | "running" | "skipped" | "stopped";
+        lastRun?: IFileCollectionResult;
+        nextRunAt?: number;
+    };
     /** The migration of the legacy store. */
     migration: {
         state: ChunkMigrationState;
@@ -60,6 +146,14 @@ export interface IFileStorageConsumer {
     tools: {
         /** The chunk store's size, the legacy store, and where the migration stands. */
         getStatus(): Promise<IFileStorageStatus>;
+        /** Free expired files' unshared chunks, or report what would be freed now. */
+        collect(input?: {
+            dryRun?: boolean;
+        }): Promise<IFileCollectionResult>;
+        /** Page through the caller's context, with its summary. */
+        listFiles(input?: IListFilesInput): Promise<IListFilesResult>;
+        /** Rebuild every loaded context's file references after raw SQL edits. */
+        reindex(): Promise<IFileReindexResult>;
         /** Copy this account's chunks out of the legacy store now, and verify them. */
         migrate(): Promise<IChunkMigrationResult>;
         /** Copy again, then delete the legacy store once every account on the device has migrated. */
@@ -70,7 +164,7 @@ export interface IFileStorageConsumer {
     };
 }
 /**
- * Return the System File Storage v1 declaration: this device's chunk store and the migration
- * of its legacy chunks. Only the user's own screens and CLI on this device may call it.
+ * Return System File Storage v1: local collection, file inspection, reference reindexing and
+ * legacy migration. Only the user's own screens and CLI on this device may call it.
  */
 export declare function getFileStorageContractDefinition(): IContractDefinition;

package/dist/contracts/system/file-storage-contract.js

@@ -23,8 +23,8 @@ const migrationResultFields = [
     field("finishedAt", field_type_1.FieldType.number, "When it finished."),
 ];
 /**
- * Return the System File Storage v1 declaration: this device's chunk store and the migration
- * of its legacy chunks. Only the user's own screens and CLI on this device may call it.
+ * Return System File Storage v1: local collection, file inspection, reference reindexing and
+ * legacy migration. Only the user's own screens and CLI on this device may call it.
  */
 function getFileStorageContractDefinition() {
     return {
@@ -32,7 +32,7 @@ function getFileStorageContractDefinition() {
         version: exports.FILE_STORAGE_CONTRACT_VERSION,
         devTag: "dev",
         name: "System File Storage",
-        description: "This device's chunk store and the migration of its legacy chunks.",
+        description: "This device's file storage, collection and legacy migration.",
         tables: [],
         observables: [],
         events: [],
@@ -47,6 +47,54 @@ function getFileStorageContractDefinition() {
                         optional: true,
                     }),
                     field("migration", field_type_1.FieldType.object, "The migration's state and last run."),
+                    field("collection", field_type_1.FieldType.object, "Collection's state, last run and next run.", {
+                        optional: true,
+                    }),
+                ],
+            },
+            {
+                name: "collect",
+                usageDescription: "Free expired files' unshared chunks on this device, or preview collection.",
+                inputFields: [
+                    field("dryRun", field_type_1.FieldType.boolean, "Report only; delete nothing.", { optional: true }),
+                ],
+                outputFields: [
+                    field("state", field_type_1.FieldType.string, "completed, skipped, or stopped."),
+                    field("dryRun", field_type_1.FieldType.boolean, "Whether this was a preview."),
+                    field("reason", field_type_1.FieldType.string, "Why it skipped or stopped.", { optional: true }),
+                    ...["contexts", "problems"].map((name) => field(name, field_type_1.FieldType.any, name)),
+                    ...[
+                        "files",
+                        "expiredFiles",
+                        "liveChunks",
+                        "chunksFreed",
+                        "bytesFreed",
+                        "rowsDeleted",
+                        "startedAt",
+                        "finishedAt",
+                    ].map((name) => field(name, field_type_1.FieldType.number, name)),
+                ],
+            },
+            {
+                name: "listFiles",
+                usageDescription: "List this context's files and their local collection deadlines, in pages.",
+                inputFields: [
+                    field("after", field_type_1.FieldType.string, "Continue after this file id.", { optional: true }),
+                    field("limit", field_type_1.FieldType.number, "Page size, 1–200; default 50.", { optional: true }),
+                ],
+                outputFields: [
+                    field("files", field_type_1.FieldType.any, "The page of files."),
+                    field("nextCursor", field_type_1.FieldType.string, "Continue with this cursor.", { optional: true }),
+                    field("summary", field_type_1.FieldType.object, "Context counts, logical bytes and retention."),
+                ],
+            },
+            {
+                name: "reindex",
+                usageDescription: "Rebuild file references in every loaded context after raw SQL edits.",
+                inputFields: [],
+                outputFields: [
+                    field("contexts", field_type_1.FieldType.number, "Contexts reindexed."),
+                    field("problems", field_type_1.FieldType.any, "Tables that could not be opened or indexed."),
                 ],
             },
             {

package/dist/contracts/system/mesh-metrics-types.d.ts

@@ -0,0 +1,148 @@
+/** Trigger for an overlapping, at most five-minute connectivity measurement. */
+export type MeshEpisodeReason = "startup" | "resume" | "network-change" | "connection-loss";
+/** Provenance of a dial; explicit requests and group joins are also distinguished. */
+export type MeshDialReason = "own-device" | "group-network-info" | "broadcast-answer" | "configured-server" | "lan-scan" | "websocket-upgrade" | "incoming" | "direct-request" | "group-join";
+/** Bounded path categories used for lifetime counters; attempts also retain the address. */
+export type MeshPath = "websocket" | "webrtc" | "cloud" | "discovery";
+/** Failure categories, independent of free-form transport error messages. */
+export type MeshFailureReason = "ttl0" | "no-route" | "signaling-timeout" | "socket-error" | "socket-timeout" | "handshake" | "rejected" | "closed" | "superseded" | "unsupported";
+/** Observed stage; timestamps are offsets in milliseconds from the attempt's queued time. */
+export type MeshStage = "queued" | "started" | "authenticated" | "admitted" | "ready" | "firstSync";
+/** Optional observational metadata passed through a dial without affecting its result. */
+export interface IMeshDial {
+    attemptId?: string;
+    reason?: MeshDialReason;
+    targetDeviceId?: string;
+}
+/** One dial or inbound connection. Missing stages have not been observed. */
+export interface IMeshAttempt {
+    attemptId: string;
+    targetDeviceId?: string;
+    reason: MeshDialReason;
+    direction: "outgoing" | "incoming";
+    path: MeshPath;
+    address?: string;
+    queuedAt: number;
+    stages: Partial<Record<MeshStage, number>>;
+    answeredDeviceId?: string;
+    expectedIdentity?: boolean;
+    answered: boolean;
+    lastSignalFailure?: {
+        reason: "ttl0" | "no-route";
+        detail?: string;
+    };
+    ready: Record<string, number>;
+    firstSync: Record<string, number>;
+    outcome: "pending" | "admitted" | "failed" | "unfinished";
+    endReason?: "buffer-evicted" | "disposed";
+    endedAt?: number;
+    durationMs?: number;
+    failure?: {
+        stage: MeshStage;
+        reason: MeshFailureReason;
+        detail?: string;
+    };
+    doubleDial: boolean;
+    offline: boolean;
+    outOfOrder: boolean;
+}
+/** Millisecond durations derived from one episode; absent means not observed. */
+export interface IMeshDurations {
+    T_first?: number;
+    T_own?: number;
+    T_cover?: number;
+    T_resume?: number;
+    repairStart?: number;
+}
+/** Coverage at the latest observation (at completion for a finished episode). */
+export interface IMeshContextCoverage {
+    dataContextId: string;
+    possibleSourceDeviceIds: string[];
+    usableDeviceIds: string[];
+    excluded: boolean;
+}
+/** One connectivity episode, independent of any other episode in flight. */
+export interface IMeshEpisode {
+    episodeId: string;
+    reason: MeshEpisodeReason;
+    trigger?: string;
+    startedAt: number;
+    endedAt?: number;
+    durationMs?: number;
+    outcome: "active" | "covered" | "unfinished";
+    endReason?: "covered" | "deadline" | "buffer-evicted" | "disposed";
+    metrics: IMeshDurations;
+    contexts: IMeshContextCoverage[];
+}
+/** Nearest-rank percentiles of observed values only; count exposes the denominator. */
+export interface IMeshPercentiles {
+    count: number;
+    p50?: number;
+    p90?: number;
+    p95?: number;
+    p99?: number;
+}
+/** Lifetime dial totals. Incoming connections are separate from the outgoing-dial ratio. */
+export interface IMeshPathCounters {
+    dials: number;
+    connections: number;
+    incomingConnections: number;
+    dialsPerConnection: number | null;
+    failures: Partial<Record<MeshFailureReason, number>>;
+}
+/** Shared relay totals and current gauges, also exposed on non-Services hosts. */
+export interface IMeshServicesCounters {
+    directRelays: number;
+    floodsForwarded: number;
+    floodsPruned: number;
+    pendingEmits: number;
+    concurrentConnections: number;
+    connects: number;
+    disconnects: number;
+}
+/** In-memory diagnostics snapshot. No history survives a runtime restart. */
+export interface IMeshStats {
+    startedAt: number;
+    sampledAt: number;
+    uptimeMs: number;
+    readyToDialMs?: number;
+    limits: {
+        episodes: number;
+        attempts: number;
+        episodeMs: number;
+    };
+    currentEpisodes: IMeshEpisode[];
+    recentEpisodes: IMeshEpisode[];
+    percentiles: Record<keyof IMeshDurations, IMeshPercentiles>;
+    counters: {
+        paths: Record<MeshPath, IMeshPathCounters>;
+        lanScan: {
+            scans: number;
+            probes: number;
+            connected: number;
+        };
+        unfinishedAttempts: number;
+        doubleDials: number;
+        offlineDials: number;
+        offlineDialsPerHour: number;
+        broadcasts: {
+            sent: number;
+            answered: number;
+            ttl0: number;
+            failed: number;
+            pending: number;
+            perHour: number;
+        };
+        services: IMeshServicesCounters;
+    };
+    recentAttempts: IMeshAttempt[];
+    recentBroadcasts: IMeshBroadcast[];
+}
+/** A discovery broadcast and its observed reply, bounded with the attempt history. */
+export interface IMeshBroadcast {
+    broadcastId: string;
+    dataContextId?: string;
+    sentAt: number;
+    durationMs?: number;
+    outcome: "pending" | "answered" | "ttl0" | "failed";
+}

package/dist/contracts/system/mesh-metrics-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/system/network-contracts.d.ts

@@ -4,12 +4,15 @@ import type { Observable } from "../../observable";
 import type { INetworkInfo } from "../../types/peer-device";
 import type { IContractConsumerBase } from "../contract-proxy";
 import type { IContractDefinition } from "../types";
+import type { IMeshStats } from "./mesh-metrics-types";
+export type * from "./mesh-metrics-types";
 /** Version of the built-in System Network Diagnostics contract. */
 export declare const NETWORK_DIAGNOSTICS_CONTRACT_VERSION = 1;
 /** Version of the built-in System Network Control contract. */
 export declare const NETWORK_CONTROL_CONTRACT_VERSION = 1;
 /** Stable IDs for tools in System Network Diagnostics v1. */
 export declare const networkDiagnosticsToolIds: {
+    readonly getMeshStats: string;
     readonly getOverview: "00ms1yb50ym353ads0gel5jpv";
     readonly getConnections: "00ms1yb50ykny9kdgiclpa1t4";
     readonly getGroupSyncStatus: "00ms1yb50yp2q7jr0jglzsztq";
@@ -241,6 +244,11 @@ export interface INetworkDiagnosticsConsumer extends IContractConsumerBase {
         getOverview(): Promise<{
             overview: INetworkOverview;
         }>;
+        getMeshStats(input?: {
+            limit?: number;
+        }): Promise<{
+            stats: IMeshStats;
+        }>;
         getConnections(): Promise<{
             connections: INetworkConnectionInfo[];
         }>;

package/dist/contracts/system/network-contracts.js

@@ -6,12 +6,18 @@ exports.getNetworkControlContractDefinition = getNetworkControlContractDefinitio
 const system_ids_1 = require("../../system-ids");
 const field_type_1 = require("../../types/field-type");
 const system_contracts_1 = require("../system-contracts");
+const tool_catalog_identity_1 = require("../tool-catalog-identity");
 /** Version of the built-in System Network Diagnostics contract. */
 exports.NETWORK_DIAGNOSTICS_CONTRACT_VERSION = 1;
 /** Version of the built-in System Network Control contract. */
 exports.NETWORK_CONTROL_CONTRACT_VERSION = 1;
 /** Stable IDs for tools in System Network Diagnostics v1. */
 exports.networkDiagnosticsToolIds = {
+    getMeshStats: (0, tool_catalog_identity_1.deriveToolCatalogId)({
+        contractId: system_ids_1.networkDiagnosticsContractId,
+        version: exports.NETWORK_DIAGNOSTICS_CONTRACT_VERSION,
+        toolName: "getMeshStats",
+    }),
     getOverview: "00ms1yb50ym353ads0gel5jpv",
     getConnections: "00ms1yb50ykny9kdgiclpa1t4",
     getGroupSyncStatus: "00ms1yb50yp2q7jr0jglzsztq",
@@ -46,6 +52,16 @@ function getNetworkDiagnosticsContractDefinition() {
         description: "Portable local network, connection, and synchronization diagnostics.",
         tables: [],
         tools: [
+            {
+                name: "getMeshStats",
+                usageDescription: "Read bounded in-memory connectivity episodes, attempts, percentiles and relay counters.",
+                inputFields: [
+                    field("limit", field_type_1.FieldType.number, "Maximum recent attempts and broadcasts (default 50, range 0–500). Episodes and counters are always complete.", { optional: true }),
+                ],
+                outputFields: [
+                    field("stats", field_type_1.FieldType.object, "Connectivity measurements since runtime startup."),
+                ],
+            },
             {
                 name: "getOverview",
                 usageDescription: "Return aggregate network and group information.",

package/dist/data/files/chunk-store.d.ts

@@ -44,6 +44,11 @@ export interface ChunkStore {
      * @returns How many chunks were deleted.
      */
     delete(hashes: readonly string[], storedBefore: number): Promise<number>;
+    /**
+     * Delete on an already-open store without yielding, so collection's liveness check and
+     * deletion are one synchronous step. Node stores provide this; IndexedDB cannot.
+     */
+    deleteSync?(hashes: readonly string[], storedBefore: number): IChunkStoreStats;
     /**
      * A page of stored chunks, in hash order.
      *
@@ -76,6 +81,8 @@ export declare class MemoryChunkStore implements ChunkStore {
     get(hash: string): Promise<Uint8Array | undefined>;
     put(hash: string, bytes: Uint8Array): Promise<void>;
     delete(hashes: readonly string[], storedBefore: number): Promise<number>;
+    /** Delete without yielding, using the same age check as the persistent Node store. */
+    deleteSync(hashes: readonly string[], storedBefore: number): IChunkStoreStats;
     list(opts?: {
         after?: string;
         limit?: number;

package/dist/data/files/chunk-store.js

@@ -32,12 +32,17 @@ class MemoryChunkStore {
         this.chunks.set(hash, { bytes: stored?.bytes ?? new Uint8Array(bytes), storedAt: this.now() });
     }
     async delete(hashes, storedBefore) {
-        let deleted = 0;
+        return this.deleteSync(hashes, storedBefore).count;
+    }
+    /** Delete without yielding, using the same age check as the persistent Node store. */
+    deleteSync(hashes, storedBefore) {
+        const deleted = { count: 0, bytes: 0 };
         for (const hash of hashes) {
             const stored = this.chunks.get(hash);
             if (stored && stored.storedAt < storedBefore) {
                 this.chunks.delete(hash);
-                deleted++;
+                deleted.count++;
+                deleted.bytes += stored.bytes.length;
             }
         }
         return deleted;

package/dist/data/files/file-rows.d.ts

@@ -31,6 +31,12 @@ export declare function isLegacyFileId(fileId: string): boolean;
  * @param file - The row's id and name.
  */
 export declare function isLegacyBundleFile(file: Pick<IFile, "fileId" | "name">): boolean;
+/**
+ * Whether this is a runtime-owned package bundle: a legacy bundle, or a derived file with
+ * an installer bundle name, JavaScript MIME type and keep=false. Read keep through its
+ * identity when an older device relayed the row without that column.
+ */
+export declare function isRuntimeBundleFile(file: IFile): boolean;
 /**
  * Whether a file is kept: never collected, even with nothing referencing it. A legacy row always
  * is. A row relayed by a build that predates `keep` arrives without it; its id, derived from
@@ -39,6 +45,8 @@ export declare function isLegacyBundleFile(file: Pick<IFile, "fileId" | "name">)
  * @param file - The row.
  */
 export declare function isKeptFile(file: IFile): boolean;
+/** Whether an unreferenced file may expire, including the runtime's bundle exception. */
+export declare function isCollectableFile(file: IFile): boolean;
 /**
  * Whether two rows describe the same file, ignoring how an older build stored it (no `keep`, no
  * MIME type).
@@ -58,7 +66,8 @@ export declare function isSameFile(a: IFile, b: IFile): boolean;
 export declare function fileRowProblem(file: IFile, recordId: string): string | undefined;
 /**
  * The `Files` write check: a new row must pass {@link fileRowProblem}; a stored row never
- * changes (rewriting the same file is allowed); and only a legacy bundle row may be deleted.
+ * changes (rewriting the same file is allowed); and only a stored runtime bundle row may be
+ * deleted. Unknown legacy ids remain allowed.
  *
  * @param existing - The row as stored, if any.
  * @param candidate - The row to store, or undefined for a delete.

package/dist/data/files/file-rows.js

@@ -3,13 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileIdFor = fileIdFor;
 exports.isLegacyFileId = isLegacyFileId;
 exports.isLegacyBundleFile = isLegacyBundleFile;
+exports.isRuntimeBundleFile = isRuntimeBundleFile;
 exports.isKeptFile = isKeptFile;
+exports.isCollectableFile = isCollectableFile;
 exports.isSameFile = isSameFile;
 exports.fileRowProblem = fileRowProblem;
 exports.checkFileWrite = checkFileWrite;
 /**
  * The rules every `Files` row meets, on every device: ids derived from the content, rows that
- * never change, and deletes only of runtime-owned legacy bundle rows. Each device checks an
+ * never change, and deletes only of runtime bundle rows. Each device checks an
  * incoming row in full, so no member can put other content under a file's id.
  */
 const derived_row_id_1 = require("../derived-row-id");
@@ -57,6 +59,18 @@ function isLegacyFileId(fileId) {
 function isLegacyBundleFile(file) {
     return isLegacyFileId(file.fileId) && BUNDLE_FILE_NAME.test(file.name);
 }
+/**
+ * Whether this is a runtime-owned package bundle: a legacy bundle, or a derived file with
+ * an installer bundle name, JavaScript MIME type and keep=false. Read keep through its
+ * identity when an older device relayed the row without that column.
+ */
+function isRuntimeBundleFile(file) {
+    return (isLegacyBundleFile(file) ||
+        (!isLegacyFileId(file.fileId) &&
+            BUNDLE_FILE_NAME.test(file.name) &&
+            file.mimeType === "application/javascript" &&
+            !isKeptFile(file)));
+}
 /**
  * Whether a file is kept: never collected, even with nothing referencing it. A legacy row always
  * is. A row relayed by a build that predates `keep` arrives without it; its id, derived from
@@ -71,6 +85,10 @@ function isKeptFile(file) {
         return file.keep;
     return fileIdFor({ ...file, keep: false }) !== file.fileId;
 }
+/** Whether an unreferenced file may expire, including the runtime's bundle exception. */
+function isCollectableFile(file) {
+    return isRuntimeBundleFile(file) || !isKeptFile(file);
+}
 /**
  * Whether two rows describe the same file, ignoring how an older build stored it (no `keep`, no
  * MIME type).
@@ -133,7 +151,8 @@ function fileRowProblem(file, recordId) {
 }
 /**
  * The `Files` write check: a new row must pass {@link fileRowProblem}; a stored row never
- * changes (rewriting the same file is allowed); and only a legacy bundle row may be deleted.
+ * changes (rewriting the same file is allowed); and only a stored runtime bundle row may be
+ * deleted. Unknown legacy ids remain allowed.
  *
  * @param existing - The row as stored, if any.
  * @param candidate - The row to store, or undefined for a delete.
@@ -142,9 +161,14 @@ function fileRowProblem(file, recordId) {
  */
 function checkFileWrite(existing, candidate, recordId) {
     if (!candidate) {
-        if (isLegacyFileId(recordId) && (!existing || isLegacyBundleFile(existing)))
+        if (existing ? isRuntimeBundleFile(existing) : isLegacyFileId(recordId))
             return;
-        throw (0, write_checks_1.writeNotAuthorized)("Files", "a file can't be deleted");
+        if (existing)
+            throw (0, write_checks_1.writeNotAuthorized)("Files", "a file can't be deleted");
+        // An unknown derived id carries no evidence that the row is a bundle. Refuse its delete
+        // so a later non-bundle row is still materialized from its authorized history. No later
+        // membership data changes that, so sync needn't keep the refusal for recovery.
+        throw (0, write_checks_1.writeRefusedForGood)("Files", "a file can't be deleted");
     }
     if (existing) {
         if (!isSameFile(existing, candidate))

package/dist/data/files/file-write-stream.d.ts

@@ -28,7 +28,8 @@ export declare class FileWriteStream {
     private storeChunk;
     /**
      * Store the last chunk and save the file's row. Saving content that already has a row (the
-     * same bytes, name, MIME type and `keep`) writes no row and returns the stored one.
+     * same bytes, name, MIME type and `keep`) returns the stored one; only a package bundle's row
+     * is written again, so a peer that deleted it gets it back.
      *
      * @returns The file's row.
      */

package/dist/data/files/file-write-stream.js

@@ -76,7 +76,8 @@ class FileWriteStream {
     }
     /**
      * Store the last chunk and save the file's row. Saving content that already has a row (the
-     * same bytes, name, MIME type and `keep`) writes no row and returns the stored one.
+     * same bytes, name, MIME type and `keep`) returns the stored one; only a package bundle's row
+     * is written again, so a peer that deleted it gets it back.
      *
      * @returns The file's row.
      */

package/dist/data/files/file.types.d.ts

@@ -59,6 +59,21 @@ export declare const FILE_MAX_CHUNKS = 1024;
 export declare const FILE_MAX_SIZE: number;
 /** Most chunks a read fetches from other devices at once, so a large file isn't one stream. */
 export declare const FILE_FETCH_WINDOW = 16;
+/** Default time an unreferenced file is retained, before the grace period (30 days). */
+export declare const FILE_RETENTION_MS: number;
+/** Extra time for a reference to reach devices holding the bytes (7 days). */
+export declare const FILE_COLLECTION_GRACE_MS: number;
+/** Minimum age of a stored chunk before collection (one day, longer than a write session). */
+export declare const FILE_CHUNK_FLOOR_MS: number;
+/**
+ * Collection delays. `PEERS_FILE_COLLECTION_DELAY_MS` overrides all three for tests only;
+ * absent or invalid uses the constants. Explicit group retention is unaffected.
+ */
+export declare function fileCollectionDelays(): {
+    retentionMs: number;
+    graceMs: number;
+    chunkFloorMs: number;
+};
 /**
  * A file's `fileHash`: the SHA-256 of its chunk hashes as JSON, in order.
  *

package/dist/data/files/file.types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FILE_FETCH_WINDOW = exports.FILE_MAX_SIZE = exports.FILE_MAX_CHUNKS = exports.FILE_CHUNK_SIZE = exports.filesMetaData = exports.fileSchema = void 0;
+exports.FILE_CHUNK_FLOOR_MS = exports.FILE_COLLECTION_GRACE_MS = exports.FILE_RETENTION_MS = exports.FILE_FETCH_WINDOW = exports.FILE_MAX_SIZE = exports.FILE_MAX_CHUNKS = exports.FILE_CHUNK_SIZE = exports.filesMetaData = exports.fileSchema = void 0;
+exports.fileCollectionDelays = fileCollectionDelays;
 exports.fileHashOf = fileHashOf;
 exports.computeFileHash = computeFileHash;
 const zod_1 = require("zod");
@@ -38,6 +39,26 @@ exports.FILE_MAX_CHUNKS = 1024;
 exports.FILE_MAX_SIZE = exports.FILE_MAX_CHUNKS * exports.FILE_CHUNK_SIZE;
 /** Most chunks a read fetches from other devices at once, so a large file isn't one stream. */
 exports.FILE_FETCH_WINDOW = 16;
+/** Default time an unreferenced file is retained, before the grace period (30 days). */
+exports.FILE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+/** Extra time for a reference to reach devices holding the bytes (7 days). */
+exports.FILE_COLLECTION_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+/** Minimum age of a stored chunk before collection (one day, longer than a write session). */
+exports.FILE_CHUNK_FLOOR_MS = 24 * 60 * 60 * 1000;
+/**
+ * Collection delays. `PEERS_FILE_COLLECTION_DELAY_MS` overrides all three for tests only;
+ * absent or invalid uses the constants. Explicit group retention is unaffected.
+ */
+function fileCollectionDelays() {
+    const value = typeof process === "undefined" ? undefined : process.env.PEERS_FILE_COLLECTION_DELAY_MS;
+    const override = value === undefined || value.trim() === "" ? NaN : Number(value);
+    const delay = (fallback) => Number.isFinite(override) && override >= 0 ? override : fallback;
+    return {
+        retentionMs: delay(exports.FILE_RETENTION_MS),
+        graceMs: delay(exports.FILE_COLLECTION_GRACE_MS),
+        chunkFloorMs: delay(exports.FILE_CHUNK_FLOOR_MS),
+    };
+}
 /**
  * A file's `fileHash`: the SHA-256 of its chunk hashes as JSON, in order.
  *

package/dist/data/files/files.d.ts

@@ -28,8 +28,9 @@ export declare class FilesTable extends Table<IFile> {
     /**
      * Store a file's row as it is, after the checks every device makes: a new row must have the
      * id derived from its content (or be a legacy row), and a stored row never changes. Storing
-     * the same file again writes nothing. Writers use {@link saveFile} or a write stream; this is
-     * for copying a row from another context with its id.
+     * an existing ordinary file again writes nothing; saving a runtime bundle publishes a newer
+     * synced snapshot, including when restoring a deleted row. Writers use {@link saveFile} or a
+     * write stream; this is for copying a row from another context with its id.
      *
      * @param fileRecord - The row.
      * @returns The row as stored.
@@ -73,11 +74,11 @@ export declare class FilesTable extends Table<IFile> {
      */
     fetchFile(fileId: string): Promise<boolean>;
     /**
-     * Delete a legacy bundle row, which the runtime owns. Every other file is permanent: it's
+     * Delete a runtime bundle row, which the runtime owns. Every other file is permanent: it's
      * collected once nothing references it. Chunks stay stored, since other files may share them.
      *
      * @param fileId - File to delete. A missing file is not an error.
-     * @throws When the file isn't a legacy bundle row.
+     * @throws When the file isn't a runtime bundle row.
      */
     deleteFile(fileId: string): Promise<void>;
 }

package/dist/data/files/files.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilesTable = void 0;
 exports.Files = Files;
 const user_context_singleton_1 = require("../../context/user-context-singleton");
-const rpc_types_1 = require("../../rpc-types");
 const orm_1 = require("../orm");
 const table_definitions_system_1 = require("../orm/table-definitions.system");
 const chunk_store_1 = require("./chunk-store");
@@ -46,8 +45,9 @@ class FilesTable extends orm_1.Table {
     /**
      * Store a file's row as it is, after the checks every device makes: a new row must have the
      * id derived from its content (or be a legacy row), and a stored row never changes. Storing
-     * the same file again writes nothing. Writers use {@link saveFile} or a write stream; this is
-     * for copying a row from another context with its id.
+     * an existing ordinary file again writes nothing; saving a runtime bundle publishes a newer
+     * synced snapshot, including when restoring a deleted row. Writers use {@link saveFile} or a
+     * write stream; this is for copying a row from another context with its id.
      *
      * @param fileRecord - The row.
      * @returns The row as stored.
@@ -56,11 +56,18 @@ class FilesTable extends orm_1.Table {
     async saveFileRecord(fileRecord) {
         const existing = await super.get(fileRecord.fileId);
         (0, file_rows_1.checkFileWrite)(existing, fileRecord, fileRecord.fileId);
-        if (existing)
+        const runtimeBundle = (0, file_rows_1.isRuntimeBundleFile)(fileRecord);
+        if (existing && !runtimeBundle)
             return existing;
-        // Another save or sync apply may have inserted the row since the read. In particular, the
-        // personal context has no data-source write check, so never let this become an update.
-        const saved = await super.save(fileRecord, { insertOnly: true });
+        // An ordinary file inserted since the read must stay untouched. Bundles can be rewritten
+        // identically so their pending reuse reaches collection's write watch and other devices.
+        const saved = await super.save(existing ?? fileRecord, {
+            insertOnly: !runtimeBundle || !existing,
+            // Even when still present locally, a reused bundle needs a new snapshot: another device
+            // may have deleted it, and collection's write watch must protect this pending reuse.
+            restoreIfDeleted: runtimeBundle,
+            saveAsSnapshot: runtimeBundle,
+        });
         (0, file_rows_1.checkFileWrite)(saved, fileRecord, fileRecord.fileId);
         return saved;
     }
@@ -132,11 +139,11 @@ class FilesTable extends orm_1.Table {
         return complete;
     }
     /**
-     * Delete a legacy bundle row, which the runtime owns. Every other file is permanent: it's
+     * Delete a runtime bundle row, which the runtime owns. Every other file is permanent: it's
      * collected once nothing references it. Chunks stay stored, since other files may share them.
      *
      * @param fileId - File to delete. A missing file is not an error.
-     * @throws When the file isn't a legacy bundle row.
+     * @throws When the file isn't a runtime bundle row.
      */
     async deleteFile(fileId) {
         const fileRecord = await super.get(fileId);
@@ -158,18 +165,3 @@ exports.FilesTable = FilesTable;
 function Files(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(file_types_1.filesMetaData, file_types_1.fileSchema);
 }
-// Deprecated RPCs, kept only for Family Hub 0.3.x until its port is Home's version. New code
-// uses System Files, which is bound to the caller's own data context.
-rpc_types_1.rpcServerCalls.getFileContentsBase64 = async (fileId) => {
-    const data = await Files().getFileContents(fileId);
-    if (data === null) {
-        throw new Error(`File not found: ${fileId}`);
-    }
-    return Buffer.from(data).toString("base64");
-};
-rpc_types_1.rpcServerCalls.saveFile = async (input) => {
-    const encoding = input.encoding || "utf8";
-    const dataBuffer = encoding === "base64" ? Buffer.from(input.data, "base64") : Buffer.from(input.data, "utf8");
-    // Kept: Family Hub 0.3.x doesn't declare its file fields, so nothing would reference these.
-    return await Files().saveFile({ name: input.name, mimeType: input.mimeType, keep: true }, new Uint8Array(dataBuffer));
-};

package/dist/data/groups.d.ts

@@ -12,6 +12,13 @@ export declare const groupSchema: z.ZodObject<{
     iconClassName: z.ZodOptional<z.ZodString>;
     publicRole: z.ZodOptional<z.ZodNativeEnum<typeof GroupMemberRole>>;
     disabled: z.ZodOptional<z.ZodBoolean>;
+    fileRetention: z.ZodOptional<z.ZodObject<{
+        days: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"never">]>;
+    }, "strip", z.ZodTypeAny, {
+        days: number | "never";
+    }, {
+        days: number | "never";
+    }>>;
     founderUserId: z.ZodEffects<z.ZodString, string, string>;
     signature: z.ZodString;
     signedAt: z.ZodOptional<z.ZodNumber>;
@@ -29,6 +36,9 @@ export declare const groupSchema: z.ZodObject<{
     iconClassName?: string | undefined;
     signedAt?: number | undefined;
     publicRole?: GroupMemberRole | undefined;
+    fileRetention?: {
+        days: number | "never";
+    } | undefined;
 }, {
     name: string;
     description: string;
@@ -41,6 +51,9 @@ export declare const groupSchema: z.ZodObject<{
     iconClassName?: string | undefined;
     signedAt?: number | undefined;
     publicRole?: GroupMemberRole | undefined;
+    fileRetention?: {
+        days: number | "never";
+    } | undefined;
 }>;
 /** A signed group record shared between personal and group contexts. */
 export type IGroup = z.infer<typeof groupSchema>;

package/dist/data/groups.js

@@ -60,6 +60,12 @@ exports.groupSchema = zod_1.z.object({
         .optional()
         .describe("Whether the group is publicly readable"),
     disabled: zod_1.z.boolean().optional().describe("Whether the group is currently disabled"),
+    // An object column stores JSON, so the number reads back as signed; a union would be a TEXT
+    // column that returns "30.0", and the row's signature would then fail.
+    fileRetention: zod_1.z
+        .object({ days: zod_1.z.union([zod_1.z.number().int().nonnegative(), zod_1.z.literal("never")]) })
+        .optional()
+        .describe("Days to retain unreferenced files before the grace period, or never; absent means 30 days."),
     founderUserId: zod_types_1.zodPeerId.describe("The user ID of the group founder"),
     signature: zod_1.z.string().describe("The signed hash of this data excluding the signature itself"),
     signedAt: zod_1.z

package/dist/data/orm/write-checks.d.ts

@@ -89,3 +89,18 @@ export declare function deletedSignedAt(tableName: string, context: ITableWriteC
  * @param reason - Why, for logs and the sync recovery queue.
  */
 export declare function writeNotAuthorized(tableName: string, reason: string): Error;
+/**
+ * A {@link writeNotAuthorized} refusal that no data arriving later can lift, unlike one that
+ * waits on Users, Groups or GroupMembers rows still to sync. Sync keeps no recovery entry for
+ * such a refused delete of a record it has no row or other history for.
+ *
+ * @param tableName - Table the write was for.
+ * @param reason - Why, for logs.
+ */
+export declare function writeRefusedForGood(tableName: string, reason: string): Error;
+/**
+ * Whether an error is a {@link writeRefusedForGood} refusal.
+ *
+ * @param error - The error a write check threw.
+ */
+export declare function isWriteRefusedForGood(error: unknown): boolean;

package/dist/data/orm/write-checks.js

@@ -7,6 +7,8 @@ exports.checkLocalSave = checkLocalSave;
 exports.signingStamp = signingStamp;
 exports.deletedSignedAt = deletedSignedAt;
 exports.writeNotAuthorized = writeNotAuthorized;
+exports.writeRefusedForGood = writeRefusedForGood;
+exports.isWriteRefusedForGood = isWriteRefusedForGood;
 /**
  * Prefix of every refusal from a {@link TableWriteCheck}. Sync recovery parks a change refused
  * with it, and checks it again only from local history, when the group's authority changes.
@@ -120,3 +122,22 @@ async function deletedSignedAt(tableName, context, existing) {
 function writeNotAuthorized(tableName, reason) {
     return new Error(`${exports.WRITE_NOT_AUTHORIZED}: ${tableName}: ${reason}`);
 }
+/**
+ * A {@link writeNotAuthorized} refusal that no data arriving later can lift, unlike one that
+ * waits on Users, Groups or GroupMembers rows still to sync. Sync keeps no recovery entry for
+ * such a refused delete of a record it has no row or other history for.
+ *
+ * @param tableName - Table the write was for.
+ * @param reason - Why, for logs.
+ */
+function writeRefusedForGood(tableName, reason) {
+    return Object.assign(writeNotAuthorized(tableName, reason), { refusedForGood: true });
+}
+/**
+ * Whether an error is a {@link writeRefusedForGood} refusal.
+ *
+ * @param error - The error a write check threw.
+ */
+function isWriteRefusedForGood(error) {
+    return error?.refusedForGood === true;
+}

package/dist/device/connection.d.ts

@@ -21,6 +21,9 @@ export declare class Connection {
     private _remoteDeviceInfo;
     /** Trust assigned to the remote identity once the handshake completes. */
     trustLevel: TrustLevel;
+    /** Synchronous diagnostics only; observer errors cannot affect handshake results. */
+    onHandshakeObserved?: (stage: "authenticated" | "failed", error?: unknown) => void;
+    private observeHandshake;
     /** Server-side hook fired shortly after the successful handshake reply has been sent. */
     onHandshakeComplete: ((deviceInfo: IDeviceInfo) => void) | undefined;
     /** RPC timeout for {@link Connection.emit}. */

package/dist/device/connection.js

@@ -32,6 +32,16 @@ class Connection {
     };
     /** Trust assigned to the remote identity once the handshake completes. */
     trustLevel = socket_type_1.TrustLevel.Unknown;
+    /** Synchronous diagnostics only; observer errors cannot affect handshake results. */
+    onHandshakeObserved;
+    observeHandshake(stage, error) {
+        try {
+            this.onHandshakeObserved?.(stage, error);
+        }
+        catch {
+            /* diagnostics never affect the handshake */
+        }
+    }
     /** Server-side hook fired shortly after the successful handshake reply has been sent. */
     onHandshakeComplete;
     /** RPC timeout for {@link Connection.emit}. */
@@ -133,6 +143,7 @@ class Connection {
             }
         }
         catch (e) {
+            this.observeHandshake("failed", e);
             console.error("Error handling completeHandshake", e);
             callback({ error: e?.message ?? String(e), errorType: "RPC_ERROR" });
         }
@@ -412,6 +423,7 @@ class Connection {
         };
         this.trustLevel = trustLevel;
         this._verified = true;
+        this.observeHandshake("authenticated");
         return handshakeResponse;
     }
     /**
@@ -459,6 +471,7 @@ class Connection {
             return handshakeResponse;
         }
         catch (e) {
+            this.observeHandshake("failed", e);
             // A failed or timed-out attempt must neither retain its ephemeral secret nor let a
             // late reply authenticate it. Do not clear state belonging to a newer handshake.
             if (generation === this.handshakeGeneration)
@@ -522,6 +535,7 @@ class Connection {
                 : remoteDeviceInfo.deviceName,
         };
         this._verified = true;
+        this.observeHandshake("authenticated");
         this._connectionAddress = remoteAddress;
         return handshakeResponse;
     }

package/dist/invites/invite-messages.d.ts

@@ -344,6 +344,13 @@ export declare const groupApprovalSchema: z.ZodObject<{
         iconClassName: z.ZodOptional<z.ZodString>;
         publicRole: z.ZodOptional<z.ZodNativeEnum<typeof import("../data").GroupMemberRole>>;
         disabled: z.ZodOptional<z.ZodBoolean>;
+        fileRetention: z.ZodOptional<z.ZodObject<{
+            days: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"never">]>;
+        }, "strip", z.ZodTypeAny, {
+            days: number | "never";
+        }, {
+            days: number | "never";
+        }>>;
         founderUserId: z.ZodEffects<z.ZodString, string, string>;
         signature: z.ZodString;
         signedAt: z.ZodOptional<z.ZodNumber>;
@@ -361,6 +368,9 @@ export declare const groupApprovalSchema: z.ZodObject<{
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     }, {
         name: string;
         description: string;
@@ -373,6 +383,9 @@ export declare const groupApprovalSchema: z.ZodObject<{
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     }>>;
     membership: z.ZodLazy<z.ZodObject<{
         groupMemberId: z.ZodEffects<z.ZodString, string, string>;
@@ -654,6 +667,9 @@ export declare const groupApprovalSchema: z.ZodObject<{
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     };
     seed: {
         users: {
@@ -734,6 +750,9 @@ export declare const groupApprovalSchema: z.ZodObject<{
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     };
     seed: {
         users: {
@@ -1296,6 +1315,13 @@ export declare const inviteMessageSchema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         iconClassName: z.ZodOptional<z.ZodString>;
         publicRole: z.ZodOptional<z.ZodNativeEnum<typeof import("../data").GroupMemberRole>>;
         disabled: z.ZodOptional<z.ZodBoolean>;
+        fileRetention: z.ZodOptional<z.ZodObject<{
+            days: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"never">]>;
+        }, "strip", z.ZodTypeAny, {
+            days: number | "never";
+        }, {
+            days: number | "never";
+        }>>;
         founderUserId: z.ZodEffects<z.ZodString, string, string>;
         signature: z.ZodString;
         signedAt: z.ZodOptional<z.ZodNumber>;
@@ -1313,6 +1339,9 @@ export declare const inviteMessageSchema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     }, {
         name: string;
         description: string;
@@ -1325,6 +1354,9 @@ export declare const inviteMessageSchema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     }>>;
     membership: z.ZodLazy<z.ZodObject<{
         groupMemberId: z.ZodEffects<z.ZodString, string, string>;
@@ -1606,6 +1638,9 @@ export declare const inviteMessageSchema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     };
     seed: {
         users: {
@@ -1686,6 +1721,9 @@ export declare const inviteMessageSchema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         iconClassName?: string | undefined;
         signedAt?: number | undefined;
         publicRole?: import("../data").GroupMemberRole | undefined;
+        fileRetention?: {
+            days: number | "never";
+        } | undefined;
     };
     seed: {
         users: {

package/dist/rpc-types.d.ts

@@ -29,28 +29,6 @@ export interface IRemoteLogsQueryInput {
 export declare const rpcServerCalls: {
     encryptData: (value: string, groupId?: string) => Promise<string>;
     tableMethodCall: (dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>;
-    /**
-     * @deprecated Use System Files (`SystemFiles`, `readWholeFile`). Kept only for Family Hub
-     * 0.3.x; deleted once its port is Home's version.
-     */
-    getFileContentsBase64: (fileId: string) => Promise<string>;
-    /**
-     * @deprecated Use System Files (`SystemFiles`). Kept only for Family Hub 0.3.x; deleted once
-     * its port is Home's version.
-     */
-    saveFile: (input: {
-        name: string;
-        mimeType?: string;
-        data: string;
-        encoding?: "utf8" | "base64";
-        fileId?: string;
-    }) => Promise<{
-        fileId: string;
-        name: string;
-        fileSize: number;
-        fileHash: string;
-        mimeType?: string;
-    }>;
     deleteLocalDatabase: () => Promise<void>;
     /** Returns info about the pre-migration data directory, or `null` if already cleaned up. */
     getOldDataDirInfo: () => Promise<{

package/dist/rpc-types.js

@@ -14,16 +14,6 @@ function rpcStub(rpcName) {
 exports.rpcServerCalls = {
     encryptData: rpcStub("encryptData"),
     tableMethodCall: rpcStub("tableMethodCall"),
-    /**
-     * @deprecated Use System Files (`SystemFiles`, `readWholeFile`). Kept only for Family Hub
-     * 0.3.x; deleted once its port is Home's version.
-     */
-    getFileContentsBase64: rpcStub("getFileContentsBase64"),
-    /**
-     * @deprecated Use System Files (`SystemFiles`). Kept only for Family Hub 0.3.x; deleted once
-     * its port is Home's version.
-     */
-    saveFile: rpcStub("saveFile"),
     deleteLocalDatabase: rpcStub("deleteLocalDatabase"),
     /** Returns info about the pre-migration data directory, or `null` if already cleaned up. */
     getOldDataDirInfo: rpcStub("getOldDataDirInfo"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.30.1",
+  "version": "0.30.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"