@remnic/core 9.54.5 → 9.54.7

package/src/support-passport/grant-service.ts

@@ -2,11 +2,16 @@ import type { StorageManager } from "../index.js";
 import type { MemoryFile } from "../types.js";
 import {
   type StoredSupportPassportCard,
+  activeSupportPassportReplacementPredecessorIds,
   computeSupportPassportOwnerKey,
   projectSupportPassportCard,
 } from "./card-projection.js";
-import { SupportPassportListCardsInputSchema, SupportPassportNamespaceSchema } from "./contracts.js";
+import {
+  SupportPassportListCardsInputSchema,
+  SupportPassportNamespaceSchema,
+} from "./contracts.js";
 import { SupportPassportError } from "./errors.js";
+import { type GeneratedBatchMarker, isCommittedGeneratedCard } from "./generated-batch.js";
 import {
   type SupportPassportCreateGrantInput,
   SupportPassportCreateGrantInputSchema,
@@ -27,20 +32,37 @@ import { requireSupportPassportOwnerLock, withSupportPassportOwnerLock } from ".
 
 export interface SupportPassportGrantServiceDependencies {
   grantStore: SupportPassportGrantStore;
-  resolveOwner(principal: string): Promise<{ principal: string; namespace: string; storage: StorageManager }>;
+  resolveOwner(
+    principal: string,
+  ): Promise<{ principal: string; namespace: string; storage: StorageManager }>;
   resolveNamespace(namespace: string): Promise<StorageManager>;
   now?: () => Date;
 }
 
-type SupportPassportGrantOwnerScope = Awaited<ReturnType<SupportPassportGrantServiceDependencies["resolveOwner"]>>;
+type SupportPassportGrantOwnerScope = Awaited<
+  ReturnType<SupportPassportGrantServiceDependencies["resolveOwner"]>
+>;
 
 interface SupportPassportCardSnapshot {
   version: string;
   cardsById: ReadonlyMap<string, StoredSupportPassportCard>;
+  activeReplacementPredecessors: ReadonlySet<string>;
 }
 
+interface CachedOwnerCards {
+  version: string;
+  expiresAt: number;
+  cards: readonly StoredSupportPassportCard[];
+}
+
+const MAX_OWNER_CARD_CACHE_ENTRIES = 256;
+
 function invalidInput(): SupportPassportError {
-  return new SupportPassportError("invalid_input", "The share link request is invalid.", 400);
+  return new SupportPassportError(
+    "invalid_input",
+    "The share link request is invalid.",
+    400,
+  );
 }
 
 export class SupportPassportGrantService {
@@ -48,6 +70,7 @@ export class SupportPassportGrantService {
   private readonly resolveOwner: SupportPassportGrantServiceDependencies["resolveOwner"];
   private readonly resolveNamespace: SupportPassportGrantServiceDependencies["resolveNamespace"];
   private readonly now: () => Date;
+  private readonly ownerCardCache = new Map<string, CachedOwnerCards>();
 
   constructor(dependencies: SupportPassportGrantServiceDependencies) {
     this.grantStore = dependencies.grantStore;
@@ -58,40 +81,52 @@ export class SupportPassportGrantService {
 
   async createGrant(
     input: SupportPassportCreateGrantInput,
-    options: { signal?: AbortSignal; onCommitted?: () => void | Promise<void> } = {}
+    options: { signal?: AbortSignal; onCommitted?: () => void | Promise<void> } = {},
   ): Promise<SupportPassportCreatedGrant> {
     const requestedAt = this.now();
     const parsed = SupportPassportCreateGrantInputSchema.safeParse(input);
     if (!parsed.success) throw invalidInput();
+    const expiresAt = parsed.data.expiresAt ?? this.expiryFromDuration(requestedAt, parsed.data.durationMs);
     const owner = await this.resolveOwnerScope(parsed.data.principal);
     return await withSupportPassportOwnerLock(
       owner.storage,
       { namespace: owner.namespace, principal: owner.principal },
       async (ownerLock) => {
         options.signal?.throwIfAborted();
-        const ownerHash = computeSupportPassportOwnerKey(owner.principal);
-        const cardsById = new Map(
-          this.projectOwnedCards(
-            await owner.storage.readAllMemories(),
-            owner.namespace,
-            ownerHash
-          ).map((card) => [card.card.cardId, card])
+        const ownerKey = computeSupportPassportOwnerKey(owner.principal);
+        const snapshot = await this.readStoredCardSnapshot(
+          owner.storage,
+          owner.namespace,
+          ownerKey,
         );
         for (const cardRef of parsed.data.cards) {
-          const stored = cardsById.get(cardRef.cardId);
+          const stored = snapshot.cardsById.get(cardRef.cardId);
           if (
             !stored ||
             stored.namespace !== owner.namespace ||
-            stored.owner !== ownerHash ||
-            stored.card.status !== "active"
+            stored.owner !== ownerKey ||
+            stored.card.status !== "active" ||
+            snapshot.activeReplacementPredecessors.has(cardRef.cardId)
           ) {
-            throw new SupportPassportError("invalid_card_status", "Only approved support cards can be shared.", 409);
+            throw new SupportPassportError(
+              "invalid_card_status",
+              "Only approved support cards can be shared.",
+              409,
+            );
           }
           if (stored.card.revision !== cardRef.revision) {
-            throw new SupportPassportError("revision_conflict", "A support card changed after it was selected.", 409);
+            throw new SupportPassportError(
+              "revision_conflict",
+              "A support card changed after it was selected.",
+              409,
+            );
           }
           if (!this.publicCard(stored.card).success) {
-            throw new SupportPassportError("card_data_invalid", "The support card data is invalid.", 500);
+            throw new SupportPassportError(
+              "card_data_invalid",
+              "The support card data is invalid.",
+              500,
+            );
           }
         }
         const created = await this.grantStore.create(
@@ -99,7 +134,7 @@ export class SupportPassportGrantService {
             namespace: owner.namespace,
             principal: owner.principal,
             cards: parsed.data.cards,
-            expiresAt: parsed.data.expiresAt,
+            expiresAt,
             requestedAt,
           },
           {
@@ -107,7 +142,7 @@ export class SupportPassportGrantService {
               options.signal?.throwIfAborted();
               await requireSupportPassportOwnerLock(ownerLock);
             },
-          }
+          },
         );
         try {
           await requireSupportPassportOwnerLock(ownerLock);
@@ -125,22 +160,24 @@ export class SupportPassportGrantService {
         });
         notifySupportPassportCommitted(options.onCommitted);
         return output;
-      }
+      },
     );
   }
 
-  async listGrants(input: { principal: string }): Promise<SupportPassportOwnerGrant[]> {
+  async listGrants(input: {
+    principal: string;
+  }): Promise<SupportPassportOwnerGrant[]> {
     const parsed = SupportPassportListGrantsInputSchema.safeParse(input);
     if (!parsed.success) throw invalidInput();
     const owner = await this.resolveOwnerScope(parsed.data.principal);
-    return (await this.grantStore.listForOwner(owner.namespace, owner.principal)).map((state) =>
-      this.ownerGrant(state)
-    );
+    return (
+      await this.grantStore.listForOwner(owner.namespace, owner.principal)
+    ).map((state) => this.ownerGrant(state));
   }
 
   async revokeGrant(
     input: SupportPassportRevokeGrantInput,
-    options: { signal?: AbortSignal; onCommitted?: () => void | Promise<void> } = {}
+    options: { signal?: AbortSignal; onCommitted?: () => void | Promise<void> } = {},
   ): Promise<SupportPassportOwnerGrant> {
     const parsed = SupportPassportRevokeGrantInputSchema.safeParse(input);
     if (!parsed.success) throw invalidInput();
@@ -171,26 +208,50 @@ export class SupportPassportGrantService {
     );
   }
 
-  async readGrant(input: { grantId: string; secret: string }): Promise<SupportPassportPublicGuide> {
-    if (!input || typeof input.grantId !== "string" || typeof input.secret !== "string") {
-      throw new SupportPassportError("grant_not_found", "The share link was not found.", 404);
+  async readGrant(input: {
+    grantId: string;
+    secret: string;
+  }): Promise<SupportPassportPublicGuide> {
+    if (
+      !input ||
+      typeof input.grantId !== "string" ||
+      typeof input.secret !== "string"
+    ) {
+      throw new SupportPassportError(
+        "grant_not_found",
+        "The share link was not found.",
+        404,
+      );
     }
     return await this.readGrantAttempt(input);
   }
 
-  private async readGrantAttempt(input: { grantId: string; secret: string }): Promise<SupportPassportPublicGuide> {
-    const initialState = await this.grantStore.authenticate(input.grantId, input.secret);
+  private async readGrantAttempt(input: {
+    grantId: string;
+    secret: string;
+  }): Promise<SupportPassportPublicGuide> {
+    const initialState = await this.grantStore.authenticate(
+      input.grantId,
+      input.secret,
+    );
     const storage = await this.resolveNamespace(initialState.namespace);
     const initialSnapshot = await this.readStoredCardSnapshot(
       storage,
       initialState.namespace,
-      initialState.principalHash
+      initialState.principalHash,
     );
     const cards = this.readGrantCards(initialSnapshot, initialState);
     const firstCard = cards[0];
-    if (!firstCard) throw new SupportPassportError("grant_stale", "The shared support guide has changed.", 410);
+    if (!firstCard)
+      throw new SupportPassportError(
+        "grant_stale",
+        "The shared support guide has changed.",
+        410,
+      );
     const updatedAt = cards.reduce((latest, card) => {
-      return Date.parse(card.updatedAt) > Date.parse(latest) ? card.updatedAt : latest;
+      return Date.parse(card.updatedAt) > Date.parse(latest)
+        ? card.updatedAt
+        : latest;
     }, firstCard.updatedAt);
     return await withSupportPassportOwnerLock(
       storage,
@@ -201,18 +262,29 @@ export class SupportPassportGrantService {
           input.secret,
           async (finalState) => {
             if (finalState.namespace !== initialState.namespace) {
-              throw new SupportPassportError("grant_stale", "The shared support guide has changed.", 410);
+              throw new SupportPassportError(
+                "grant_stale",
+                "The shared support guide has changed.",
+                410,
+              );
             }
             await requireSupportPassportOwnerLock(ownerLock);
             const currentSnapshot = await this.readStoredCardSnapshot(
               storage,
               finalState.namespace,
-              finalState.principalHash
+              finalState.principalHash,
+            );
+            const currentCards = this.readGrantCards(
+              currentSnapshot,
+              finalState,
             );
-            const currentCards = this.readGrantCards(currentSnapshot, finalState);
             await requireSupportPassportOwnerLock(ownerLock);
             if (JSON.stringify(currentCards) !== JSON.stringify(cards)) {
-              throw new SupportPassportError("grant_stale", "The shared support guide has changed.", 410);
+              throw new SupportPassportError(
+                "grant_stale",
+                "The shared support guide has changed.",
+                410,
+              );
             }
             return SupportPassportPublicGuideSchema.parse({
               schemaVersion: 1,
@@ -222,13 +294,16 @@ export class SupportPassportGrantService {
               cards,
             });
           },
-          async () => await requireSupportPassportOwnerLock(ownerLock)
+          async () => await requireSupportPassportOwnerLock(ownerLock),
         );
-      }
+      },
     );
   }
 
-  private readGrantCards(snapshot: SupportPassportCardSnapshot, state: SupportPassportGrantState) {
+  private readGrantCards(
+    snapshot: SupportPassportCardSnapshot,
+    state: SupportPassportGrantState,
+  ) {
     return state.cards.map((cardRef) => {
       const stored = snapshot.cardsById.get(cardRef.cardId);
       if (
@@ -236,13 +311,22 @@ export class SupportPassportGrantService {
         stored.namespace !== state.namespace ||
         stored.owner !== state.principalHash ||
         stored.card.status !== "active" ||
-        stored.card.revision !== cardRef.revision
+        stored.card.revision !== cardRef.revision ||
+        snapshot.activeReplacementPredecessors.has(cardRef.cardId)
       ) {
-        throw new SupportPassportError("grant_stale", "The shared support guide has changed.", 410);
+        throw new SupportPassportError(
+          "grant_stale",
+          "The shared support guide has changed.",
+          410,
+        );
       }
       const publicCard = this.publicCard(stored.card);
       if (!publicCard.success) {
-        throw new SupportPassportError("grant_stale", "The shared support guide has changed.", 410);
+        throw new SupportPassportError(
+          "grant_stale",
+          "The shared support guide has changed.",
+          410,
+        );
       }
       return publicCard.data;
     });
@@ -251,17 +335,37 @@ export class SupportPassportGrantService {
   private async readStoredCardSnapshot(
     storage: StorageManager,
     namespace: string,
-    owner: string
+    ownerKey: string,
   ): Promise<SupportPassportCardSnapshot> {
     for (let attempt = 0; attempt < 3; attempt += 1) {
+      const markerCache = new Map<string, GeneratedBatchMarker | null>();
       const before = this.cardSnapshotVersion(storage);
-      const memories = await storage.readAllMemories();
+      const cacheKey = JSON.stringify([storage.dir, namespace, ownerKey]);
+      const nowMs = this.now().getTime();
+      const cached = this.ownerCardCache.get(cacheKey);
+      let ownerCards: readonly StoredSupportPassportCard[];
+      if (cached && cached.version === before && cached.expiresAt >= nowMs) {
+        this.ownerCardCache.delete(cacheKey);
+        this.ownerCardCache.set(cacheKey, cached);
+        ownerCards = cached.cards;
+      } else {
+        this.ownerCardCache.delete(cacheKey);
+        ownerCards = this.projectOwnedCards(await storage.readAllMemories(), namespace, ownerKey);
+      }
       const after = this.cardSnapshotVersion(storage);
       if (before !== after) continue;
-      const cards = this.projectOwnedCards(memories, namespace, owner);
+      if (!cached || cached.version !== before || cached.expiresAt < nowMs) {
+        this.cacheOwnerCards(storage, cacheKey, after, ownerCards, nowMs);
+      }
+      const cards: StoredSupportPassportCard[] = [];
+      for (const card of ownerCards) {
+        if (await isCommittedGeneratedCard(storage, card, markerCache)) cards.push(card);
+      }
       const snapshot = {
         version: after,
         cardsById: new Map(cards.map((card) => [card.card.cardId, card])),
+        activeReplacementPredecessors:
+          activeSupportPassportReplacementPredecessorIds(cards),
       };
       return snapshot;
     }
@@ -271,13 +375,13 @@ export class SupportPassportGrantService {
   private projectOwnedCards(
     memories: MemoryFile[],
     namespace: string,
-    owner: string
+    ownerKey: string,
   ): StoredSupportPassportCard[] {
     const cards = memories
       .map((memory) => projectSupportPassportCard(memory))
       .filter(
         (card): card is StoredSupportPassportCard =>
-          card !== null && card.namespace === namespace && card.owner === owner
+          card !== null && card.namespace === namespace && card.owner === ownerKey
       );
     const cardIds = new Set<string>();
     for (const card of cards) {
@@ -289,13 +393,31 @@ export class SupportPassportGrantService {
     return cards;
   }
 
+  private cacheOwnerCards(
+    storage: StorageManager,
+    cacheKey: string,
+    version: string,
+    cards: readonly StoredSupportPassportCard[],
+    nowMs: number,
+  ): void {
+    if (!storage.isHotCacheEnabled()) return;
+    const ttlMs = storage.hotCacheTtlMs();
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) return;
+    this.ownerCardCache.set(cacheKey, { version, cards, expiresAt: nowMs + ttlMs });
+    while (this.ownerCardCache.size > MAX_OWNER_CARD_CACHE_ENTRIES) {
+      const oldestKey = this.ownerCardCache.keys().next().value as string | undefined;
+      if (oldestKey === undefined) break;
+      this.ownerCardCache.delete(oldestKey);
+    }
+  }
+
   private cardSnapshotVersion(storage: StorageManager): string {
     return `${storage.getCorpusScanVersion()}:${storage.hotCacheKeyId()}`;
   }
 
   private async revokeCommittedGrant(
     created: { state: SupportPassportGrantState; secret: string },
-    owner: SupportPassportGrantOwnerScope
+    owner: SupportPassportGrantOwnerScope,
   ): Promise<void> {
     try {
       await this.grantStore.revoke({
@@ -308,7 +430,7 @@ export class SupportPassportGrantService {
       throw new SupportPassportError(
         "storage_conflict",
         "A share link could not be stopped after owner access changed. Review the active share list.",
-        500
+        500,
       );
     }
   }
@@ -329,23 +451,50 @@ export class SupportPassportGrantService {
     });
   }
 
-  private async resolveOwnerScope(principal: string): Promise<SupportPassportGrantOwnerScope> {
-    const requestedPrincipal = SupportPassportListCardsInputSchema.safeParse({ principal });
+  private expiryFromDuration(requestedAt: Date, durationMs: number | undefined): string {
+    if (durationMs === undefined) throw invalidInput();
+    const expiresAtMs = requestedAt.getTime() + durationMs;
+    if (!Number.isFinite(expiresAtMs)) throw invalidInput();
+    try {
+      return new Date(expiresAtMs).toISOString();
+    } catch {
+      throw invalidInput();
+    }
+  }
+
+  private async resolveOwnerScope(
+    principal: string,
+  ): Promise<SupportPassportGrantOwnerScope> {
+    const requestedPrincipal = SupportPassportListCardsInputSchema.safeParse({
+      principal,
+    });
     const owner = await this.resolveOwner(principal);
     const namespace = SupportPassportNamespaceSchema.safeParse(owner.namespace);
-    const ownerPrincipal = SupportPassportListCardsInputSchema.safeParse({ principal: owner.principal });
+    const ownerPrincipal = SupportPassportListCardsInputSchema.safeParse({
+      principal: owner.principal,
+    });
     if (
       !requestedPrincipal.success ||
       !namespace.success ||
       !ownerPrincipal.success ||
       ownerPrincipal.data.principal !== requestedPrincipal.data.principal
     ) {
-      throw new SupportPassportError("card_data_invalid", "The support passport owner scope is invalid.", 500);
+      throw new SupportPassportError(
+        "card_data_invalid",
+        "The support passport owner scope is invalid.",
+        500,
+      );
     }
-    return { ...owner, principal: ownerPrincipal.data.principal, namespace: namespace.data };
+    return {
+      ...owner,
+      principal: ownerPrincipal.data.principal,
+      namespace: namespace.data,
+    };
   }
 
-  private ownerGrant(state: SupportPassportGrantState): SupportPassportOwnerGrant {
+  private ownerGrant(
+    state: SupportPassportGrantState,
+  ): SupportPassportOwnerGrant {
     const status = state.revokedAt
       ? "revoked"
       : Date.parse(state.expiresAt) <= this.now().getTime()

package/src/support-passport/grant-store.ts

@@ -183,8 +183,12 @@ export class SupportPassportGrantStore {
     if (!parsed.success) {
       throw new SupportPassportError("invalid_input", "The share link request is invalid.", 400);
     }
+    const expiresAt = parsed.data.expiresAt;
+    if (expiresAt === undefined) {
+      throw new SupportPassportError("invalid_input", "The share link request is invalid.", 400);
+    }
     const requestedAt = input.requestedAt ?? this.now();
-    const durationMs = Date.parse(parsed.data.expiresAt) - requestedAt.getTime();
+    const durationMs = Date.parse(expiresAt) - requestedAt.getTime();
     if (
       !Number.isFinite(requestedAt.getTime()) ||
       !Number.isFinite(durationMs) ||
@@ -214,7 +218,7 @@ export class SupportPassportGrantStore {
             const secret = secretBytes.toString("base64url");
             const createdAt = this.now();
             const createdAtMs = createdAt.getTime();
-            const expiresAtMs = Date.parse(parsed.data.expiresAt);
+            const expiresAtMs = Date.parse(expiresAt);
             if (
               !Number.isFinite(createdAtMs) ||
               requestedAt.getTime() > createdAtMs ||
@@ -233,7 +237,7 @@ export class SupportPassportGrantStore {
               secretHash: sha256("support-passport-secret:v1", secret),
               cards: parsed.data.cards,
               createdAt: createdAt.toISOString(),
-              expiresAt: parsed.data.expiresAt,
+              expiresAt,
             });
             await this.requireMutationLock(mutationLock);
             await mutationHooks.beforeCommit?.();

package/src/support-passport/index.ts

@@ -1,7 +1,17 @@
+import "./access-operations.js";
+
 export * from "./card-projection.js";
+export * from "./access-surface.js";
 export * from "./card-service.js";
+export * from "./config.js";
 export * from "./contracts.js";
 export * from "./errors.js";
 export * from "./grant-contracts.js";
 export * from "./grant-service.js";
 export * from "./grant-store.js";
+export * from "./model-adapter.js";
+export * from "./model-bridge.js";
+export * from "./model-contracts.js";
+export * from "./model-audit.js";
+export * from "./model-service.js";
+export * from "./public-http.js";