Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Update terminology (#2159)

Leendert de Borst0b65c248ea11
diff --git a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
index b1506395b..7f9ecd130 100644
--- a/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
+++ b/apps/browser-extension/src/entrypoints/background/VaultMessageHandler.ts
@@ -15,7 +15,7 @@ import { multiManifestRendering } from '@aliasvault/client/sharing/MultiManifest
import { SharingService } from '@aliasvault/client/sharing/SharingService';
import { recordManifestRevisions } from '@aliasvault/client/sync/ManifestRevisions';
import { clearDirtyScopes, getDirtyScopes } from '@aliasvault/client/sync/VaultDirtyState';
-import { vaultRequiresManifestMigration, VaultMigrationKind, type VaultMigrationStatus } from '@aliasvault/client/sync/VaultManifestMigration';
+import { vaultRequiresManifestMigration, VaultMigrationKind } from '@aliasvault/client/sync/VaultManifestMigration';
import { type VaultMutationScope, DEFAULT_VAULT_MUTATION_SCOPE, hasUserVisibleScope } from '@aliasvault/client/sync/VaultMutationScope';
import { runFullVaultSync, runVaultManifestMigration, runVaultMigrationStatus, type IVaultSyncEngineHost, type VaultSyncOptions, type VaultSyncPhase as EngineSyncPhase, type VaultSyncStoreOutcome, type VaultSyncStoreRequest } from '@aliasvault/client/sync/VaultSyncEngine';
import { getVaultSyncHoldReason } from '@aliasvault/client/sync/VaultSyncHold';
@@ -797,13 +797,13 @@ export async function handleStoreEncryptedVault(request: {
/**
* Classify the pending migration status.
*/
-export async function handleGetVaultMigrationStatus(): Promise<VaultMigrationStatus> {
+export async function handleGetVaultMigrationStatus(): Promise<VaultMigrationKind> {
try {
const result = await runVaultMigrationStatus(syncEngineHost);
- return { kind: result.kind as VaultMigrationKind, serverConfirmed: result.serverConfirmed };
+ return result.kind as VaultMigrationKind;
} catch (error) {
devWarn('[ManifestMigration] Could not classify the pending migration, assuming it crosses the storage format:', error);
- return { kind: VaultMigrationKind.StorageFormatUpgrade, serverConfirmed: false };
+ return VaultMigrationKind.StorageFormatUpgrade;
}
}
@@ -1614,7 +1614,7 @@ export async function handleGroupCreateVault(message: { groupId: string; name: s
}
/**
- * Invite a member of a family to one of its shared manifests, handing them the manifest's key sealed for them.
+ * Invite a member of a family to one of its shared manifests, handing them the manifest's key encrypted to their account keypair.
*
* The recipient is picked off the family's own roster, so this never names an account outside the family.
* @param message - the family, the manifest, and the member being invited.
diff --git a/apps/browser-extension/src/entrypoints/popup/pages/auth/Unlock.tsx b/apps/browser-extension/src/entrypoints/popup/pages/auth/Unlock.tsx
index 5916f4d38..bdac2e692 100644
--- a/apps/browser-extension/src/entrypoints/popup/pages/auth/Unlock.tsx
+++ b/apps/browser-extension/src/entrypoints/popup/pages/auth/Unlock.tsx
@@ -427,7 +427,7 @@ const Unlock: React.FC = () => {
/*
* KEK/VEK: when the PIN was set up before the vault key migration, the PIN-protected key is the old
- * password-derived key (now the KEK). Upgrade to the VEK and re-seal the PIN store so future PIN unlocks
+ * password-derived key (now the KEK). Upgrade to the VEK and re-encrypt the PIN store so future PIN unlocks
* return the VEK directly.
*/
passwordHashBase64 = await VaultKeyService.resolveStoredUnlockKey(passwordHashBase64, key => setupPin(pinToUse, key));
diff --git a/apps/browser-extension/src/entrypoints/popup/pages/auth/Upgrade.tsx b/apps/browser-extension/src/entrypoints/popup/pages/auth/Upgrade.tsx
index 21b40760f..15f7605d0 100644
--- a/apps/browser-extension/src/entrypoints/popup/pages/auth/Upgrade.tsx
+++ b/apps/browser-extension/src/entrypoints/popup/pages/auth/Upgrade.tsx
@@ -196,12 +196,12 @@ const Upgrade: React.FC = () => {
}, [loadStoredDatabase, refreshSyncState, navigate, setIsInitialLoading, t]);
/**
- * Ask the background what the manifest migration would do, and either put it to the user or run it.
+ * Ask the background what the manifest migration would do, and either prompt the user or run it.
*/
const startManifestUpgrade = useCallback(async (): Promise<void> => {
- const plan = await sendMessage('GET_VAULT_MIGRATION_STATUS');
+ const pending = await sendMessage('GET_VAULT_MIGRATION_STATUS');
- if (plan.kind === VaultMigrationKind.StorageFormatUpgrade) {
+ if (pending === VaultMigrationKind.StorageFormatUpgrade) {
setKind(UpgradeKind.StorageFormat);
setStage('consent');
setIsInitialLoading(false);
diff --git a/apps/browser-extension/src/entrypoints/popup/pages/settings/FamilySharingSettings.tsx b/apps/browser-extension/src/entrypoints/popup/pages/settings/FamilySharingSettings.tsx
index ba3e15246..ad8abe562 100644
--- a/apps/browser-extension/src/entrypoints/popup/pages/settings/FamilySharingSettings.tsx
+++ b/apps/browser-extension/src/entrypoints/popup/pages/settings/FamilySharingSettings.tsx
@@ -445,7 +445,7 @@ const FamilySharingSettings: React.FC = () => {
)}
</div>
- {/* Inviting somebody seals this vault's key for them, which an admin who holds no grant on it cannot do. */}
+ {/* Inviting somebody encrypts this vault's key for them, which an admin who holds no grant on it cannot do. */}
{canAdminister && !iHoldKey && (
<p className="text-xs text-gray-500 dark:text-gray-400">{t('sharing.family.cannotInviteWithoutAccess')}</p>
)}
diff --git a/apps/browser-extension/src/utils/messaging/ExtensionMessaging.ts b/apps/browser-extension/src/utils/messaging/ExtensionMessaging.ts
index cdfc8a998..9c028ae18 100644
--- a/apps/browser-extension/src/utils/messaging/ExtensionMessaging.ts
+++ b/apps/browser-extension/src/utils/messaging/ExtensionMessaging.ts
@@ -36,7 +36,7 @@ import type { VaultSyncPhase } from '@/utils/types/messaging/VaultSyncPhase';
import type { VaultSyncState } from '@/utils/types/messaging/VaultSyncState';
import type { ItemUsageAction } from '@aliasvault/client/database';
-import type { VaultMigrationStatus } from '@aliasvault/client/sync/VaultManifestMigration';
+import type { VaultMigrationKind } from '@aliasvault/client/sync/VaultManifestMigration';
import type { VaultMutationScope } from '@aliasvault/client/sync/VaultMutationScope';
import type { EncryptionKeyDerivationParams } from '@aliasvault/models/metadata';
import type { PasswordSettings } from '@aliasvault/models/vault';
@@ -91,7 +91,7 @@ export interface IExtensionMessageProtocol {
GET_TOTP_SECRETS(data: { itemIds: string[] }): { success: boolean; secrets?: Record<string, TotpSecret>; error?: string };
GET_TWO_FACTOR_STATE(): TwoFactorState | null;
GET_VAULT(): VaultResponse;
- GET_VAULT_MIGRATION_STATUS(): VaultMigrationStatus;
+ GET_VAULT_MIGRATION_STATUS(): VaultMigrationKind;
GET_WEBAUTHN_SETTINGS(data: any): WebAuthnSettingsResponse;
GROUP_CREATE_VAULT(data: { groupId: string; name: string }): { success: boolean; error?: string; apiErrorCode?: string };
GROUP_INVITE_MEMBER(data: { groupId: string; manifestId: string; userId: string }): { success: boolean; error?: string; apiErrorCode?: string };
diff --git a/apps/server/AliasVault.Admin/Main/Pages/Users/View/Index.razor b/apps/server/AliasVault.Admin/Main/Pages/Users/View/Index.razor
index 393bdcadb..ada5b41b5 100644
--- a/apps/server/AliasVault.Admin/Main/Pages/Users/View/Index.razor
+++ b/apps/server/AliasVault.Admin/Main/Pages/Users/View/Index.razor
@@ -581,7 +581,7 @@ Do you want to proceed with the restoration?")) {
/// <summary>
/// Whether the user holds any state that only exists on the current storage format because of vault sharing: a
- /// grant on a shared manifest, a membership of a shared group, or an invitation sealed to their account keypair.
+ /// grant on a shared manifest, a membership of a shared group, or an invitation encrypted to their account keypair.
/// Reverting such a user would delete the keypair all of that is encrypted to, so the revert is not offered.
/// </summary>
/// <param name="dbContext">The database context to query.</param>
diff --git a/apps/server/AliasVault.Api/Controllers/V2/AuthController.cs b/apps/server/AliasVault.Api/Controllers/V2/AuthController.cs
index 9bf08a664..bd21bab14 100644
--- a/apps/server/AliasVault.Api/Controllers/V2/AuthController.cs
+++ b/apps/server/AliasVault.Api/Controllers/V2/AuthController.cs
@@ -428,7 +428,7 @@ public class AuthController(IAliasServerDbContextFactory dbContextFactory, UserM
return BadRequest(ApiErrorCodeHelper.CreateValidationErrorResponse(apiErrorCode, 400));
}
- // Every new account is created on the account-key model, so the client must mint the whole hierarchy up front.
+ // Every new account is created on the account-key model, so the client must generate the whole hierarchy up front.
// Reject an incomplete or oversized one before any row is written, so a rejected attempt leaves no account behind.
if (!model.HasCompleteAccountKeys)
{
diff --git a/apps/server/AliasVault.Api/Controllers/V2/GroupsController.cs b/apps/server/AliasVault.Api/Controllers/V2/GroupsController.cs
index 0ba74c1e2..4e11aa3fc 100644
--- a/apps/server/AliasVault.Api/Controllers/V2/GroupsController.cs
+++ b/apps/server/AliasVault.Api/Controllers/V2/GroupsController.cs
@@ -89,7 +89,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
.Where(u => allMemberIds.Contains(u.Id))
.ToDictionaryAsync(u => u.Id, u => u.UserName ?? string.Empty);
- // Only an admin can hand a manifest key to somebody, so only an admin is served the keys to seal one with.
+ // Only an admin can hand a manifest key to somebody, so only an admin is served the keys to encrypt one with.
var administeredMemberIds = allMembers.Where(m => administeredGroupIds.Contains(m.GroupId)).Select(m => m.UserId);
var publicKeys = administeredGroupIds.Count > 0 ? await GrantHelper.GetPrimaryKeysAsync(context, administeredMemberIds) : [];
@@ -200,7 +200,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
}
catch (DbUpdateException)
{
- // The client-minted manifest id is already taken, which a fresh id makes vanishingly unlikely; the client asks again.
+ // The client-generated manifest id is already taken, which a fresh id makes vanishingly unlikely; the client asks again.
return BadRequest(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.MANIFEST_ID_TAKEN, 400));
}
@@ -210,7 +210,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
}
/// <summary>
- /// Offer a member of the group access to one of its shared manifests, handing over the manifest key sealed for them in
+ /// Offer a member of the group access to one of its shared manifests, handing over the manifest key encrypted for them in
/// the same call. The offer becomes a grant once they accept it.
/// </summary>
/// <param name="groupId">The group ID.</param>
@@ -264,13 +264,13 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
return BadRequest(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.NOT_GROUP_MEMBER, 400));
}
- // The sealed key and the offer have to be about the same person.
+ // The encrypted key and the offer have to be about the same person.
if (!string.Equals(model.Grant.RecipientUserId, model.UserId, StringComparison.Ordinal))
{
return BadRequest(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.RECIPIENT_KEY_NOT_FOUND, 400));
}
- // The key it was sealed for must really be theirs.
+ // The key it was encrypted for must really be theirs.
if (!await context.UserGrantKeys.AnyAsync(k => k.Id == model.Grant.RecipientPublicKeyId && k.UserId == model.UserId))
{
return NotFound(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.RECIPIENT_KEY_NOT_FOUND, 404));
@@ -535,7 +535,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
return NotFound(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.INVITATION_NOT_FOUND, 404));
}
- // If the current manifest key version is different from the one the invitation was sealed under, it is no longer valid.
+ // If the current manifest key version is different from the one the invitation was encrypted under, it is no longer valid.
if (manifestKeyVersion.Value != invitation.VaultKeyVersion)
{
CloseInvitation(invitation, GroupInvitationState.Stale);
@@ -552,7 +552,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
invitation.RespondedAt = timeProvider.UtcNow;
invitation.UpdatedAt = timeProvider.UtcNow;
- // The sealed copy has become the grant, so it stops being a second copy of the key lying around.
+ // The encrypted copy has become the grant, so it stops being a second copy of the key lying around.
invitation.EncryptedVek = null;
invitation.EncryptedName = null;
invitation.UserGrantKeyId = null;
@@ -683,7 +683,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
}
/// <summary>
- /// Close an offer of access, dropping the manifest key sealed inside it.
+ /// Close an offer of access, dropping the manifest key encrypted inside it.
/// </summary>
/// <param name="invitation">The invitation to close.</param>
/// <param name="state">The state it ends in.</param>
@@ -698,7 +698,7 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
}
/// <summary>
- /// Turn the manifest key sealed into an offer of access into the accepting member's grant on that manifest.
+ /// Turn the manifest key encrypted into an offer of access into the accepting member's grant on that manifest.
/// </summary>
/// <param name="context">The database context.</param>
/// <param name="invitation">The invitation being accepted.</param>
@@ -724,7 +724,8 @@ public class GroupsController(IAliasServerDbContextFactory dbContextFactory, Use
}
/// <summary>
- /// Close every open offer of access to a manifest whose sealed key predates the manifest's current one, as accepting it would fail anyway.
+ /// Close every open offer of access to a manifest whose encrypted key predates the manifest's current one, as accepting it
+ /// would fail anyway.
/// </summary>
/// <param name="context">The database context.</param>
/// <param name="manifestId">The shared manifest.</param>
diff --git a/apps/server/AliasVault.Api/Helpers/GrantHelper.cs b/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
index 3d3e82dc0..41b645ca9 100644
--- a/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
+++ b/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
@@ -66,7 +66,7 @@ public static class GrantHelper
/// </summary>
/// <param name="context">The database context.</param>
/// <param name="userIds">The user IDs to look up.</param>
- /// <returns>User ID to the public key a vault key is sealed for them with. Users without a keypair are absent.</returns>
+ /// <returns>User ID to the public key a vault key is encrypted for them with. Users without a keypair are absent.</returns>
public static async Task<Dictionary<string, MemberPublicKey>> GetPrimaryKeysAsync(AliasServerDbContext context, IEnumerable<string> userIds)
{
var ids = userIds.Distinct(StringComparer.Ordinal).ToList();
diff --git a/apps/server/AliasVault.Api/Models/MemberPublicKey.cs b/apps/server/AliasVault.Api/Models/MemberPublicKey.cs
index 00f37817e..09b1c9023 100644
--- a/apps/server/AliasVault.Api/Models/MemberPublicKey.cs
+++ b/apps/server/AliasVault.Api/Models/MemberPublicKey.cs
@@ -8,7 +8,7 @@
namespace AliasVault.Api.Models;
/// <summary>
-/// The public key a shared manifest's key is sealed for when it is handed to somebody.
+/// The public key a shared manifest's key is encrypted for when it is handed to somebody.
/// </summary>
/// <param name="PublicKeyId">The id of the key row.</param>
/// <param name="PublicKey">The public key itself (JWK).</param>
diff --git a/apps/server/AliasVault.Client/Services/StorageKeys.cs b/apps/server/AliasVault.Client/Services/StorageKeys.cs
index 740692f5c..c8a2c0903 100644
--- a/apps/server/AliasVault.Client/Services/StorageKeys.cs
+++ b/apps/server/AliasVault.Client/Services/StorageKeys.cs
@@ -69,7 +69,7 @@ public static class StorageKeys
public const string EncryptedVek = "encryptedVek";
/// <summary>
- /// Key for storing the account public key, used to seal shared vault grants to this account.
+ /// Key for storing the account public key, used to encrypt shared vault grants to this account.
/// </summary>
public const string AccountPublicKey = "accountPublicKey";
diff --git a/apps/server/AliasVault.Client/Services/VaultSync/Models/SharedManifestRecord.cs b/apps/server/AliasVault.Client/Services/VaultSync/Models/SharedManifestRecord.cs
index c93235413..189edd9a3 100644
--- a/apps/server/AliasVault.Client/Services/VaultSync/Models/SharedManifestRecord.cs
+++ b/apps/server/AliasVault.Client/Services/VaultSync/Models/SharedManifestRecord.cs
@@ -11,8 +11,8 @@ namespace AliasVault.Client.Services.VaultSync.Models;
/// A shared manifest this session holds a grant on, as rebuilt from the last pull.
/// </summary>
/// <param name="ManifestId">The manifest id.</param>
-/// <param name="EncryptedVek">The manifest VEK sealed to one of this account's public keys (the grant as the server holds it).</param>
-/// <param name="EncryptionPublicKey">The public key the grant was sealed with.</param>
+/// <param name="EncryptedVek">The manifest VEK encrypted to one of this account's public keys (the grant as the server holds it).</param>
+/// <param name="EncryptionPublicKey">The public key the grant was encrypted with.</param>
/// <param name="Algorithm">The grant algorithm token.</param>
/// <param name="Salt">The manifest's blob-hashing salt.</param>
/// <param name="Name">The manifest display name, or null when unknown.</param>
diff --git a/apps/server/AliasVault.Client/Services/VaultSync/VaultSyncService.cs b/apps/server/AliasVault.Client/Services/VaultSync/VaultSyncService.cs
index f1890eea4..9d3f43925 100644
--- a/apps/server/AliasVault.Client/Services/VaultSync/VaultSyncService.cs
+++ b/apps/server/AliasVault.Client/Services/VaultSync/VaultSyncService.cs
@@ -464,7 +464,7 @@ public sealed class VaultSyncService(HttpClient httpClient, AuthService authServ
/// The grant a shared manifest is remembered by, or null when the snapshot carries none.
/// </summary>
/// <param name="dto">The snapshot manifest.</param>
- /// <returns>Tuple with the sealed VEK, the public key it was sealed with and the algorithm token.</returns>
+ /// <returns>Tuple with the encrypted VEK, the public key it was encrypted with and the algorithm token.</returns>
private static (string EncryptedVek, string EncryptionPublicKey, string Algorithm)? GrantOf(Manifest dto)
{
if (string.IsNullOrEmpty(dto.EncryptedVek) || string.IsNullOrEmpty(dto.EncryptionPublicKey))
@@ -971,7 +971,7 @@ public sealed class VaultSyncService(HttpClient httpClient, AuthService authServ
/// Resolve the private key (JWK) that opens a grant.
/// </summary>
/// <param name="personalManifest">The opened personal manifest.</param>
- /// <param name="encryptionPublicKey">The public key the grant was sealed with.</param>
+ /// <param name="encryptionPublicKey">The public key the grant was encrypted with.</param>
/// <returns>The private key as a JWK JSON string, or null.</returns>
private async Task<string?> ResolvePrivateKeyJwkAsync(ResolvedManifest personalManifest, string encryptionPublicKey)
{
diff --git a/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
index 0c8c2bf4d..067dad9e8 100644
--- a/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
+++ b/apps/server/AliasVault.Client/wwwroot/js/rustCoreInterop.js
@@ -208,7 +208,7 @@ window.rustCoreExtractDomain = async function(url) {
/**
* The Logos.Id to use for a source domain inside a given manifest scope.
*
- * Logo identity is derived, not minted: two clients that fetch the same favicon independently produce
+ * Logo identity is derived, not random: two clients that fetch the same favicon independently produce
* the same row and merge by LWW, instead of two rows that collide on UNIQUE(ManifestId, Source).
* The same domain in two different manifests deliberately yields two different ids, so a shared
* manifest's icon and the user's own icon for that domain never overwrite each other.
diff --git a/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs b/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs
index 7175a7288..c07aa287a 100644
--- a/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs
+++ b/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs
@@ -364,7 +364,7 @@ public class AliasServerDbContext : WorkerStatusDbContext, IDataProtectionKeyCon
builder.Property(e => e.State).HasConversion<string>().HasMaxLength(20);
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
- // Losing the keypair the vault key was sealed to leaves an invitation nobody could ever open.
+ // Losing the keypair the vault key was encrypted to leaves an invitation nobody could ever decrypt.
builder.HasOne(e => e.UserGrantKey)
.WithMany()
.HasForeignKey(e => e.UserGrantKeyId)
@@ -421,7 +421,7 @@ public class AliasServerDbContext : WorkerStatusDbContext, IDataProtectionKeyCon
.OnDelete(DeleteBehavior.Cascade);
// One access path per (holder, type, manifest) per VEK version: a rotation adds a row rather than
- // replacing one, so the retired VEK stays retrievable for the history revisions it sealed.
+ // replacing one, so the retired VEK stays retrievable for the history revisions it encrypted.
builder.HasIndex(e => new { e.UserId, e.Type, e.VaultManifestId, e.KeyVersion }).IsUnique().HasDatabaseName("UX_VaultManifestAccessKeys_UserId_Type_Manifest_Version");
builder.HasIndex(e => e.VaultManifestId).HasDatabaseName("IX_VaultManifestAccessKeys_VaultManifestId");
builder.Property(e => e.Metadata).HasColumnType("jsonb");
diff --git a/apps/server/Databases/AliasServerDb/GroupInvitation.cs b/apps/server/Databases/AliasServerDb/GroupInvitation.cs
index db073fe67..11dd51b07 100644
--- a/apps/server/Databases/AliasServerDb/GroupInvitation.cs
+++ b/apps/server/Databases/AliasServerDb/GroupInvitation.cs
@@ -90,7 +90,7 @@ public class GroupInvitation
public virtual UserGrantKey? UserGrantKey { get; set; }
/// <summary>
- /// Gets or sets the version of the manifest's VEK that this invitation was sealed under. Used to check
+ /// Gets or sets the version of the manifest's VEK that this invitation was encrypted under. Used to check
/// if this invitation is still valid for the manifest upon accepting.
/// </summary>
public int VaultKeyVersion { get; set; }
diff --git a/apps/server/Databases/AliasServerDb/GroupInvitationState.cs b/apps/server/Databases/AliasServerDb/GroupInvitationState.cs
index 98864b504..82bd038d8 100644
--- a/apps/server/Databases/AliasServerDb/GroupInvitationState.cs
+++ b/apps/server/Databases/AliasServerDb/GroupInvitationState.cs
@@ -33,7 +33,7 @@ public enum GroupInvitationState
Revoked = 3,
/// <summary>
- /// The vault's key was rotated after the invitation was made, so the key sealed into it no longer opens the vault and
+ /// The vault's key was rotated after the invitation was made, so the key encrypted into it no longer decrypts the vault and
/// accepting it would hand the invitee a grant they cannot use. The inviter has to make a fresh invitation.
/// </summary>
Stale = 4,
diff --git a/apps/server/Databases/AliasServerDb/Legacy/LegacyVaultRollback.cs b/apps/server/Databases/AliasServerDb/Legacy/LegacyVaultRollback.cs
index 7086f70f0..129c1c7f1 100644
--- a/apps/server/Databases/AliasServerDb/Legacy/LegacyVaultRollback.cs
+++ b/apps/server/Databases/AliasServerDb/Legacy/LegacyVaultRollback.cs
@@ -45,7 +45,7 @@ public static class LegacyVaultRollback
context.VaultManifestsHistory.Remove(legacyRevision);
await context.SaveChangesAsync();
- // Every manifest-v1 revision is sealed with the VEK removed below, so none of them can ever be opened
+ // Every manifest-v1 revision is encrypted with the VEK removed below, so none of them can ever be decrypted
// again. They are dropped rather than left as restorable rows that would brick the account.
await context.VaultManifestsHistory.Where(x => x.ManifestId == manifestId && x.StorageFormat == VaultManifestBase.ManifestStorageFormat).ExecuteDeleteAsync();
diff --git a/apps/server/Databases/AliasServerDb/Migrations/20260810093922_ManifestStorageAndGroupOwnership.cs b/apps/server/Databases/AliasServerDb/Migrations/20260810093922_ManifestStorageAndGroupOwnership.cs
index 35b1ec873..00d673d10 100644
--- a/apps/server/Databases/AliasServerDb/Migrations/20260810093922_ManifestStorageAndGroupOwnership.cs
+++ b/apps/server/Databases/AliasServerDb/Migrations/20260810093922_ManifestStorageAndGroupOwnership.cs
@@ -11,7 +11,7 @@ namespace AliasServerDb.Migrations
/// Existing rows are carried over in place:
/// - every user gains a Personal group that takes over their vault, aliases, quotas and rate limit overrides,
/// - the append-only "Vaults" revision log becomes one "VaultManifests" head row per user plus a
- /// "VaultManifestsHistory" tail, keyed by a newly minted manifest id,
+ /// "VaultManifestsHistory" tail, keyed by a newly generated manifest id,
/// - per-user email encryption keys become per-manifest delivery keys.
///
/// The tables that only the manifest-v1 write path uses (buckets, blobs, access and unlock keys) start empty. Every
diff --git a/apps/server/Shared/AliasVault.Shared/Models/Enums/ApiErrorCode.cs b/apps/server/Shared/AliasVault.Shared/Models/Enums/ApiErrorCode.cs
index 0484769ef..cbcefcb87 100644
--- a/apps/server/Shared/AliasVault.Shared/Models/Enums/ApiErrorCode.cs
+++ b/apps/server/Shared/AliasVault.Shared/Models/Enums/ApiErrorCode.cs
@@ -185,7 +185,7 @@ public enum ApiErrorCode
MANIFEST_ID_INVALID,
/// <summary>
- /// The supplied manifest id is already in use by a different manifest. The client must mint a fresh id and retry.
+ /// The supplied manifest id is already in use by a different manifest. The client must generate a fresh id and retry.
/// </summary>
MANIFEST_ID_TAKEN,
@@ -238,8 +238,8 @@ public enum ApiErrorCode
INVITE_RECIPIENT_NOT_READY,
/// <summary>
- /// The shared manifest's key was rotated after the offer of access was made, so the key sealed into the offer no
- /// longer opens the manifest. The offer is closed and the inviter has to make a fresh one.
+ /// The shared manifest's key was rotated after the offer of access was made, so the key encrypted into the offer no
+ /// longer decrypts the manifest. The offer is closed and the inviter has to make a fresh one.
/// </summary>
INVITATION_KEY_OUTDATED,
diff --git a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/CreateSharedManifestRequest.cs b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/CreateSharedManifestRequest.cs
index fe553ccb0..2050d2962 100644
--- a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/CreateSharedManifestRequest.cs
+++ b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/CreateSharedManifestRequest.cs
@@ -12,7 +12,7 @@ namespace AliasVault.Shared.Models.WebApi.V2.Groups;
/// </summary>
public class CreateSharedManifestRequest
{
- /// <summary>Gets or sets the client-minted id of the new manifest.</summary>
+ /// <summary>Gets or sets the client-generated id of the new manifest.</summary>
public required Guid ManifestId { get; set; }
/// <summary>Gets or sets the manifest VEK encrypted with the user's own public key (base64), decryptable only by the user.</summary>
diff --git a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ManifestGrant.cs b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ManifestGrant.cs
index 7f94ec26c..06e63accc 100644
--- a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ManifestGrant.cs
+++ b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ManifestGrant.cs
@@ -21,6 +21,6 @@ public class ManifestGrant
/// <summary>Gets or sets the manifest VEK encrypted with that public key (base64), decryptable only by the recipient.</summary>
public required string EncryptedVek { get; set; }
- /// <summary>Gets or sets the vault's name encrypted with the same public key, null when the client sealed none.</summary>
+ /// <summary>Gets or sets the vault's name encrypted with the same public key, null when the client encrypted none.</summary>
public string? EncryptedName { get; set; }
}
diff --git a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ReceivedManifestInvitation.cs b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ReceivedManifestInvitation.cs
index 0eccb9b72..0637ea5ed 100644
--- a/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ReceivedManifestInvitation.cs
+++ b/apps/server/Shared/AliasVault.Shared/Models/WebApi/V2/Groups/ReceivedManifestInvitation.cs
@@ -30,6 +30,6 @@ public class ReceivedManifestInvitation
/// <summary>Gets or sets the encrypted name of the vault.</summary>
public string? EncryptedName { get; set; }
- /// <summary>Gets or sets the public half of the recipient's keypair the offer was sealed to.</summary>
+ /// <summary>Gets or sets the public half of the recipient's keypair the offer was encrypted to.</summary>
public string? RecipientPublicKey { get; set; }
}
diff --git a/core/client/src/database/repositories/LogoRepository.ts b/core/client/src/database/repositories/LogoRepository.ts
index 9affe805e..9d6f433cd 100644
--- a/core/client/src/database/repositories/LogoRepository.ts
+++ b/core/client/src/database/repositories/LogoRepository.ts
@@ -19,7 +19,7 @@ export type CustomLogoEntry = ItemLogo & {
* Every logo an item can have lives in one table, keyed by (Kind, Source): a fetched favicon under its
* domain, a built-in logo under its catalog key, an uploaded image under its content hash. Ids are
* derived from that key by the Rust core rather than randomly generated, so every device and platform
- * produces the same row for the same logo instead of minting duplicates that collide on
+ * produces the same row for the same logo instead of creating duplicates that collide on
* UNIQUE(ManifestId, Kind, Source).
*/
export class LogoRepository extends BaseRepository {
@@ -123,7 +123,7 @@ export class LogoRepository extends BaseRepository {
* Get or create the logo for a kind and key inside one manifest, refreshing its image data.
*
* The row's stamp and the id derived for it come from the same `manifestId`, so a logo can never be
- * stored under a scope other than the one its id was minted for.
+ * stored under a scope other than the one its id was derived for.
* @param manifestId The manifest to write the logo into
* @param kind The logo kind
* @param source The natural key within that kind
diff --git a/core/client/src/sharing/SharingService.ts b/core/client/src/sharing/SharingService.ts
index 9861b7a07..4c609c3e6 100644
--- a/core/client/src/sharing/SharingService.ts
+++ b/core/client/src/sharing/SharingService.ts
@@ -67,7 +67,7 @@ export class SharingService {
* Create a shared group's manifest.
* @param webApi - API client to reuse.
* @param group - the group to create the manifest for, with this client's own public key to encrypt its VEK for.
- * @param manifestId - the client-minted id of the new manifest.
+ * @param manifestId - the client-generated id of the new manifest.
*/
public static async createSharedManifest(webApi: WebApiService, group: ShareTarget, manifestId: string): Promise<SharedManifestMapping> {
const manifestVek = EncryptionUtility.generateVaultEncryptionKey();
@@ -110,7 +110,7 @@ export class SharingService {
}
/**
- * Open the vault names sealed into the invitations addressed to this account.
+ * Decrypt the vault names encrypted into the invitations addressed to this account.
* @param sqliteClient - the open local vault, which holds this account's superseded private keys.
* @param invitations - the invitations as served by the API.
* @returns The name of each invitation's vault, keyed by invitation id; invitations whose name will not open are left out.
@@ -125,14 +125,14 @@ export class SharingService {
const privateKey = await this.resolveGrantPrivateKey(sqliteClient, invitation.recipientPublicKey);
if (!privateKey) {
- devWarn(`[Sharing] No account key in this vault opens the name sealed into invitation ${invitation.id}.`);
+ devWarn(`[Sharing] No account key in this vault decrypts the name encrypted into invitation ${invitation.id}.`);
continue;
}
try {
names[invitation.id] = new TextDecoder().decode(await EncryptionUtility.decryptWithPrivateKey(invitation.encryptedName, privateKey));
} catch (error) {
- devWarn(`[Sharing] Failed to open the name sealed into invitation ${invitation.id}.`, error);
+ devWarn(`[Sharing] Failed to decrypt the name encrypted into invitation ${invitation.id}.`, error);
}
}
@@ -205,7 +205,7 @@ export class SharingService {
}
/**
- * Mint a fresh active keypair for a shared manifest.
+ * Generate a fresh active keypair for a shared manifest.
* @param sqliteClient - the open local vault DB (caller must run this inside a vault mutation so it is saved)
* @param manifestId - the shared manifest's id (the stamp its key rows carry)
*/
@@ -243,7 +243,7 @@ export class SharingService {
/**
* Persist the shared-manifest key records.
* @param manifests - the full record map; replaces whatever is stored.
- * @param encryptionKey - the vault encryption key the map is sealed with, passed explicitly because both writers already hold it.
+ * @param encryptionKey - the vault encryption key the map is encrypted with, passed explicitly because both writers already hold it.
*/
public static async setSharedManifestRecords(manifests: Record<string, SharedManifestRecord>, encryptionKey: string): Promise<void> {
await getPlatform().storage.set(StorageKeys.SHARED_MANIFESTS, await EncryptionUtility.symmetricEncrypt(JSON.stringify(manifests), encryptionKey));
@@ -252,7 +252,7 @@ export class SharingService {
/**
* Add (or replace) one shared-manifest key record.
* @param record - the record to add.
- * @param encryptionKey - the vault encryption key the map is sealed with.
+ * @param encryptionKey - the vault encryption key the map is encrypted with.
*/
public static async addSharedManifestRecord(record: SharedManifestRecord, encryptionKey: string): Promise<void> {
const manifests = await this.getSharedManifestRecords();
diff --git a/core/client/src/sync/LegacyStorageModelMigration.ts b/core/client/src/sync/LegacyStorageModelMigration.ts
index 592dacd8d..7940539bf 100644
--- a/core/client/src/sync/LegacyStorageModelMigration.ts
+++ b/core/client/src/sync/LegacyStorageModelMigration.ts
@@ -168,7 +168,7 @@ export function legacyUnstampedRowAdoption(personalManifestId: string): { adoptU
*/
/**
- * The freshly minted key hierarchy for one migration push. Held across the push so
+ * The freshly generated key hierarchy for one migration push. Held across the push so
* {@link completeLegacyAccountKeyMigration} can cache exactly what the server committed.
*/
export type LegacyAccountKeyMigration = {
@@ -189,7 +189,7 @@ export async function requiresLegacyAccountKeyMigration(): Promise<boolean> {
}
/**
- * Mint the account key hierarchy for a migration push.
+ * Generate the account key hierarchy for a migration push.
* @param kek - the password-derived key this vault is currently encrypted with, which becomes the KEK
*/
export async function prepareLegacyAccountKeyMigration(kek: string): Promise<LegacyAccountKeyMigration> {
diff --git a/core/client/src/sync/VaultManifestMigration.ts b/core/client/src/sync/VaultManifestMigration.ts
index b81c5502a..22bc2911a 100644
--- a/core/client/src/sync/VaultManifestMigration.ts
+++ b/core/client/src/sync/VaultManifestMigration.ts
@@ -22,7 +22,10 @@ export async function vaultRequiresManifestMigration(sqliteClient: SqliteClient)
* What a pending migration will actually do, which decides whether it may run on its own.
*/
export enum VaultMigrationKind {
- /** No migration pending. */
+ /**
+ * Nothing to migrate, or nothing that may be migrated yet: a vault still on the frozen sqlite-blob chain
+ * classifies as None because that chain has to bring it to 2.0.0 before either kind below can apply.
+ */
None = 'none',
/**
@@ -36,14 +39,3 @@ export enum VaultMigrationKind {
StorageFormatUpgrade = 'storage-format-upgrade',
}
-/**
- * A pending migration, classified.
- */
-export type VaultMigrationStatus = {
- kind: VaultMigrationKind;
-
- /**
- * Whether the classification could be confirmed against the server. False when the vault key probe could not reach the server.
- */
- serverConfirmed: boolean;
-};
diff --git a/core/client/src/sync/VaultSyncEngine.ts b/core/client/src/sync/VaultSyncEngine.ts
index 58497f9ac..c612cb9de 100644
--- a/core/client/src/sync/VaultSyncEngine.ts
+++ b/core/client/src/sync/VaultSyncEngine.ts
@@ -83,7 +83,6 @@ export type VaultSyncEngineResult = EngineResultBase & {
/** Outcome of the migration classification. */
export type VaultSyncMigrationStatusResult = EngineResultBase & {
kind: 'none' | 'schema-rebuild' | 'storage-format-upgrade';
- serverConfirmed: boolean;
};
/** Outcome of the manifest migration. */
diff --git a/core/models/src/vault/VaultTableRegistry.ts b/core/models/src/vault/VaultTableRegistry.ts
index 70bd6b09c..c262c5ee5 100644
--- a/core/models/src/vault/VaultTableRegistry.ts
+++ b/core/models/src/vault/VaultTableRegistry.ts
@@ -65,14 +65,14 @@ export const VAULT_TABLES: VaultTableDefinition[] = [
{ Name: 'Items', ManifestScoped: true, PrimaryKey: ['Id'], ItemChild: false },
/*
* ItemStats is keyed by the item it describes: Id IS the item's id, so recording a use is an
- * upsert and two devices never mint competing rows. Listed after Items so a merge inserts the
+ * upsert and two devices never create competing rows. Listed after Items so a merge inserts the
* item first.
*/
{ Name: 'ItemStats', ManifestScoped: true, PrimaryKey: ['Id'], ItemChild: true, BucketCategory: 'Stats' },
/*
* FieldValues legacy statement merge: a field value matches on the field it belongs to (FieldKey
* for system fields, FieldDefinitionId for custom ones; exactly one is set), so independently
- * minted rows of the same field converge. Canonical merge: both sides are normalized first,
+ * created rows of the same field converge. Canonical merge: both sides are normalized first,
* which strips the derived id of every single-value row, so adding Id to the key makes a
* single-value row match by its field (id part empty on both sides) while a multi-value row
* matches by its OWNED id: two devices each adding a login.url are two different rows that must
diff --git a/core/rust/src/vault_codec/materialize.rs b/core/rust/src/vault_codec/materialize.rs
index 47b2c42fb..7443afb55 100644
--- a/core/rust/src/vault_codec/materialize.rs
+++ b/core/rust/src/vault_codec/materialize.rs
@@ -46,9 +46,9 @@ pub fn materialize_as_sqlite(input: MaterializeInput) -> VaultResult<Materialize
let base_manifest_id = base.manifest_id.clone();
let mut combined = super::sharing::combine_manifest_tables(base.tables, &base_manifest_id, others);
- // The wire omits derived row ids (single-value FieldValues, FieldHistories); mint them back so the
+ // The wire omits derived row ids (single-value FieldValues, FieldHistories); derive them back so the
// SQLite projection has the primary keys it expects back, identical on every device.
- super::normalize::mint_missing_derived_ids(&mut combined);
+ super::normalize::derive_missing_ids(&mut combined);
// Normalize all id columns.
super::normalize::normalize_id_spelling(&mut combined);
diff --git a/core/rust/src/vault_codec/normalize.rs b/core/rust/src/vault_codec/normalize.rs
index db11a8f57..e5f83e346 100644
--- a/core/rust/src/vault_codec/normalize.rs
+++ b/core/rust/src/vault_codec/normalize.rs
@@ -72,9 +72,9 @@ pub(crate) fn normalize_row_shapes(tables: &mut HashMap<String, Vec<CodecRecord>
}
/// The materialize direction: a FieldValues or FieldHistories row without an `Id` is a row whose
-/// derived id the wire omits; mint it from the row's own natural key so every device materializes
+/// derived id the wire omits; derive it from the row's own natural key so every device materializes
/// the same SQLite row.
-pub(crate) fn mint_missing_derived_ids(tables: &mut HashMap<String, Vec<CodecRecord>>) {
+pub(crate) fn derive_missing_ids(tables: &mut HashMap<String, Vec<CodecRecord>>) {
if let Some(rows) = tables.get_mut(FIELD_VALUES_TABLE) {
for row in rows.iter_mut().filter(|row| !has_id(row)) {
let id = derive_row_id(row, value_index_of(row).unwrap_or(0));
@@ -269,7 +269,7 @@ mod tests {
#[test]
fn derivation_ignores_guid_casing() {
- // iOS and the extension mint uppercase GUIDs; the natural key must not fork on casing.
+ // iOS and the extension generate uppercase GUIDs; the natural key must not fork on casing.
let lower = field_value_id_for("aaaa-bbbb", "item-x", "", "def-1", 2);
let upper = field_value_id_for("AAAA-BBBB", "ITEM-X", "", "DEF-1", 2);
assert_eq!(lower, upper);
diff --git a/core/rust/src/vault_codec/scoped_assets.rs b/core/rust/src/vault_codec/scoped_assets.rs
index 7edf113b3..c2825a34a 100644
--- a/core/rust/src/vault_codec/scoped_assets.rs
+++ b/core/rust/src/vault_codec/scoped_assets.rs
@@ -8,7 +8,7 @@
//!
//! A logo is scoped to the manifest that owns it:
//! - `ManifestId` is that manifest's id, personal or shared alike (no NULL convention);
-//! - `Id` is derived from `(manifest id, Kind, Source)` (see [`logo_id_for`]), so every writer mints
+//! - `Id` is derived from `(manifest id, Kind, Source)` (see [`logo_id_for`]), so every writer derives
//! the same id for the same logo in the same manifest and the uniqueness invariant is
//! self-enforcing rather than repaired after the fact.
//!
@@ -34,8 +34,8 @@ pub use crate::vault_model::names::LOGO_KIND_BUILTIN as KIND_BUILTIN;
pub use crate::vault_model::names::LOGO_KIND_CUSTOM as KIND_CUSTOM;
/// Domain-separation prefix for favicon ids. It predates the `Kind` column and is kept verbatim so
-/// every favicon row that already exists keeps its id: changing it would re-mint the logo of every
-/// item in every vault on the next push.
+/// every favicon row that already exists keeps its id: changing it would re-derive the logo id of
+/// every item in every vault on the next push.
const FAVICON_ID_NAMESPACE: &str = "aliasvault:logo:v1";
/// The `Id` of the logo `(manifest id, kind, source)`: a UUIDv8 (RFC 9562 custom-format) whose bytes
@@ -88,7 +88,7 @@ fn natural_key(row: &CodecRecord) -> Option<(String, String)> {
}
/// Normalize one table set's logo rows to `scope` (the owning manifest's id): stamp `ManifestId`,
-/// re-mint `Id` from `(scope, Kind, Source)`, collapse rows that now share a natural key (keeping
+/// re-derive `Id` from `(scope, Kind, Source)`, collapse rows that now share a natural key (keeping
/// the better row, see [`is_better_logo`]), and repoint every `Items.LogoId` at the surviving row.
///
/// It runs once per manifest, each with its own id, so a personal logo is never merged with a shared
diff --git a/core/rust/src/vault_codec/sharing.rs b/core/rust/src/vault_codec/sharing.rs
index 4cb390790..c1c546d51 100644
--- a/core/rust/src/vault_codec/sharing.rs
+++ b/core/rust/src/vault_codec/sharing.rs
@@ -19,14 +19,14 @@
//! below) and drops what nothing references any more (see [`prune_unreferenced_logos`]).
//!
//! **combine** (materialize side) stamps every manifest's rows with the manifest they arrived in,
-//! re-minting the ids that derive from the scope, drops the `EncryptionKeys` rows it may not publish
+//! recomputing the ids that derive from the scope, drops the `EncryptionKeys` rows it may not publish
//! plus the bucketed, personal and bookkeeping tables no manifest may carry, folds in its data buckets,
//! then repairs the references a namespace boundary leaves dangling.
//!
//! **Referenced content** is copied, never moved. A foreign key is composite, so a row in another
//! namespace is as absent as a deleted one, and the manifest referencing it gets its own stamped copy:
//! two members editing "the same" tag or logo then never overwrite each other. A row with an opaque id
-//! keeps it ([`clone_referenced_rows`]); a `Logos` id derives from the scope, so the copy re-mints it
+//! keeps it ([`clone_referenced_rows`]); a `Logos` id derives from the scope, so the copy recomputes it
//! (see [`scoped_assets`](super::scoped_assets)).
use std::collections::{HashMap, HashSet};
@@ -227,7 +227,7 @@ pub(super) fn partition_by_manifest(
/*
* 3. Logos are scoped, not copied: a row moves to the partition its ManifestId names. The stamp
- * value itself is re-minted to the owning manifest below.
+ * value itself is rewritten to the owning manifest below.
*/
if let Some(logo_rows) = tables.remove(LOGOS_TABLE) {
let mut base_rows: Vec<CodecRecord> = Vec::with_capacity(logo_rows.len());
@@ -329,7 +329,7 @@ pub(super) fn partition_by_manifest(
/*
* 6. Each manifest ends up self-contained: every row it references but does not hold is copied out
* of the vault-wide snapshot and stamped for this manifest, keeping its id where the id is opaque
- * and re-minting it where it derives from the scope.
+ * and recomputing it where it derives from the scope.
*/
let no_logos: Vec<CodecRecord> = Vec::new();
let all_logos = snapshots.get(LOGOS_TABLE).unwrap_or(&no_logos);
@@ -473,7 +473,7 @@ pub(super) fn combine_manifest_tables(
/// let one manifest inject rows into another's namespace through a table the registry cannot police).
///
/// Two tables are held out of the blanket stamp. `Logos` are stamped by [`normalize_logo_scope`], which
-/// re-mints their derived ids and repoints `Items.LogoId` in the same pass. `EncryptionKeys` are not
+/// re-derives their ids and repoints `Items.LogoId` in the same pass. `EncryptionKeys` are not
/// stamped at all: there the stamp is a *claim* that [`retain_own_encryption_keys`] checks, and stamping
/// first would make every claim true.
fn claim_manifest_scope(tables: &mut HashMap<String, Vec<CodecRecord>>, manifest_id: &str) {
diff --git a/core/rust/src/vault_codec/sharing_tests.rs b/core/rust/src/vault_codec/sharing_tests.rs
index 1adeac2ba..8067de90b 100644
--- a/core/rust/src/vault_codec/sharing_tests.rs
+++ b/core/rust/src/vault_codec/sharing_tests.rs
@@ -89,7 +89,7 @@ fn tag_links(records: &[CodecRecord]) -> Vec<(String, String)> {
}
/// The scoped logo id the codec derives for `(manifest id, source)`, what tests assert against, since
-/// a logo's identity is a function of its manifest and domain rather than whatever id the writer minted.
+/// a logo's identity is a function of its manifest and domain rather than whatever id the writer generated.
fn logo_id(scope: &str, source: &str) -> String {
scoped_assets::logo_id_for(scope, scoped_assets::KIND_FAVICON, source)
}
@@ -1109,7 +1109,7 @@ fn item_moved_into_shared_manifest_adopts_its_existing_logo() {
#[test]
fn combine_scopes_a_legacy_shared_manifest_before_it_can_collide() {
- // A shared manifest whose ROWS predate manifest-id scoping: its logos were minted at random and
+ // A shared manifest whose ROWS predate manifest-id scoping: its logos were generated at random and
// carry no scope stamp. Materializing it next to the recipient's own rows must not collide on
// UNIQUE(ManifestId, Kind, Source) — combine normalizes every row to the manifest's own id.
let (recipient_manifest, buckets) = recipient_personal_manifest();
@@ -1145,7 +1145,7 @@ fn combine_scopes_a_legacy_shared_manifest_before_it_can_collide() {
#[test]
fn combine_keeps_both_rows_when_two_manifests_share_a_primary_key() {
- // Ids are client-minted, so a shared manifest may legitimately carry a row whose Id equals one of
+ // Ids are client-generated, so a shared manifest may legitimately carry a row whose Id equals one of
// the reader's own. Because rows are keyed by (ManifestId, Id) — the primary key the local schema
// declares — both survive in their own namespace and neither shadows the other.
let mut personal = canonicalize_from_sqlite(input_with_shares(
@@ -1644,7 +1644,7 @@ fn logo_kinds_key_independently_so_a_domain_and_a_catalog_key_never_collide() {
#[test]
fn icon_row_without_a_kind_is_a_favicon_and_keeps_its_legacy_id() {
- // Rows written before the Kind column exists must not be re-minted: their id has to stay exactly
+ // Rows written before the Kind column exists must not be re-derived: their id has to stay exactly
// what `logo_id_for_source` produces, or every item in every older vault loses its logo once.
let tables = vec![
table("Items", vec![row(&[("Id", json!("i-1")), ("FolderId", serde_json::Value::Null), ("LogoId", json!("random-guid"))])]),
diff --git a/core/rust/src/vault_codec/tests.rs b/core/rust/src/vault_codec/tests.rs
index a4f2d680e..3a5380623 100644
--- a/core/rust/src/vault_codec/tests.rs
+++ b/core/rust/src/vault_codec/tests.rs
@@ -316,10 +316,10 @@ fn forward_compat_unknown_manifest_fields_preserved() {
}
#[test]
-fn canonicalize_remints_legacy_logo_ids_and_collapses_duplicate_sources() {
- // Two clients minted distinct random Ids for the same domain; Items point at each. Canonicalize
- // re-mints the row against its scope's derived id, which is what stops the two from ever being
- // minted apart again and repoints both Items at it.
+fn canonicalize_rederives_legacy_logo_ids_and_collapses_duplicate_sources() {
+ // Two clients generated distinct random Ids for the same domain; Items point at each. Canonicalize
+ // re-derives the row's id against its scope, which is what stops the two from ever drifting apart
+ // again and repoints both Items at it.
let favicon = vec![0x01, 0x02, 0x03];
let out = canonicalize_from_sqlite(basic_input(vec![
CodecTableData {
@@ -404,7 +404,7 @@ fn canonicalize_nulls_dangling_logo_reference() {
let items = &out.first().manifest.tables["Items"];
let i1 = items.iter().find(|r| r["Id"] == json!("i1")).unwrap();
let i2 = items.iter().find(|r| r["Id"] == json!("i2")).unwrap();
- assert_eq!(i1["LogoId"], json!(scoped_assets::logo_id_for(PERSONAL_MANIFEST, scoped_assets::KIND_FAVICON, "github.com")), "valid reference follows the re-mint");
+ assert_eq!(i1["LogoId"], json!(scoped_assets::logo_id_for(PERSONAL_MANIFEST, scoped_assets::KIND_FAVICON, "github.com")), "valid reference follows the re-derive");
assert_eq!(i2["LogoId"], serde_json::Value::Null, "dangling reference nulled");
}
@@ -932,7 +932,7 @@ fn canonicalize_collapses_duplicate_single_value_rows_to_the_newest() {
}
#[test]
-fn materialize_mints_missing_field_value_ids() {
+fn materialize_derives_missing_field_value_ids() {
let manifest = Manifest {
schema_version: SCHEMA_VERSION,
manifest_salt: "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff".to_string(),
@@ -944,7 +944,7 @@ fn materialize_mints_missing_field_value_ids() {
(
"FieldValues".to_string(),
vec![
- // Single-value wire shape: no id, explicit position; the id is minted here.
+ // Single-value wire shape: no id, explicit position; the id is derived here.
row(&[("ManifestId", json!(PERSONAL_MANIFEST)), ("ItemId", json!("i-1")), ("FieldKey", json!("login.username")), ("ValueIndex", json!(0)), ("Value", json!("me"))]),
// Multi-value: the owned id rides along untouched.
row(&[("ManifestId", json!(PERSONAL_MANIFEST)), ("Id", json!("u-1")), ("ItemId", json!("i-1")), ("FieldKey", json!("login.url")), ("ValueIndex", json!(0)), ("Value", json!("https://a.example"))]),
@@ -975,14 +975,14 @@ fn materialize_mints_missing_field_value_ids() {
let fv: HashMap<&str, &CodecRecord> = tables["FieldValues"].iter().map(|r| (r["Value"].as_str().unwrap(), r)).collect();
let expected_username_id = super::normalize::field_value_id_for(PERSONAL_MANIFEST, "i-1", "login.username", "", 0);
- assert_eq!(fv["me"]["Id"], json!(expected_username_id), "materialize mints the derived id");
+ assert_eq!(fv["me"]["Id"], json!(expected_username_id), "materialize derives the id");
assert_eq!(fv["https://a.example"]["Id"], json!("u-1"), "an owned multi-value id is kept verbatim");
assert_eq!(tables["ItemTags"].len(), 1, "the id-less join row inserts as-is");
let history = &tables["FieldHistories"][0];
let expected_history_id = super::normalize::field_history_id_for(PERSONAL_MANIFEST, "i-1", "login.password", "", "2026-01-01 10:00:00.000");
- assert_eq!(history["Id"], json!(expected_history_id), "materialize mints the derived history id");
+ assert_eq!(history["Id"], json!(expected_history_id), "materialize derives the history id");
assert!(out.overflow.is_empty());
}
diff --git a/core/rust/src/vault_pruner/mod.rs b/core/rust/src/vault_pruner/mod.rs
index a39c391c1..9c3ae16be 100644
--- a/core/rust/src/vault_pruner/mod.rs
+++ b/core/rust/src/vault_pruner/mod.rs
@@ -178,7 +178,7 @@ pub fn prune_vault(input: PruneInput) -> VaultResult<PruneOutput> {
.ok_or_else(|| crate::error::VaultError::General(
format!("Invalid current_time format: {}", input.current_time)
))?;
- let now_str = now.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+ let now_str = crate::timestamp::iso_utc(&now);
// Calculate cutoff date for trash retention
let cutoff_date = now - Duration::days(input.retention_days as i64);