@remnic/core 9.54.3 → 9.54.5

package/dist/{chunk-APPFNGX6.js → chunk-BSXGTDVJ.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-3JLPGJ43.js";
+} from "./chunk-NGT35IGQ.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -282,4 +282,4 @@ export {
   computeServiceCorpusWatermarks,
   computeServiceCorpusCensus
 };
-//# sourceMappingURL=chunk-APPFNGX6.js.map
+//# sourceMappingURL=chunk-BSXGTDVJ.js.map

package/dist/{chunk-4IIFL7GC.js → chunk-CLKBV3Z3.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-RZ4XGKOJ.js";
+} from "./chunk-VYQ4URQB.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-2GFK22OZ.js";
+} from "./chunk-DOOWFDWN.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -38,23 +38,23 @@ import {
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-47P3RYZP.js";
+} from "./chunk-2INWPC6E.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-CGVHPCP2.js";
+} from "./chunk-7Q7JWLQ4.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-6LAPLZOS.js";
+} from "./chunk-2DD6ZHOM.js";
 import {
   listNamespaces
-} from "./chunk-3JLPGJ43.js";
+} from "./chunk-NGT35IGQ.js";
 import {
   analyzeGraphHealth
 } from "./chunk-BIJAWZYW.js";
 import {
   StorageManager
-} from "./chunk-6R4G7N4S.js";
+} from "./chunk-QQXWFDRD.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -63,7 +63,7 @@ import {
 } from "./chunk-3SG4FGDV.js";
 import {
   probeProjectionHealth
-} from "./chunk-3CSX3ETE.js";
+} from "./chunk-2LWQSV6A.js";
 import {
   resolveAccessSetupCapabilities,
   resolveCapabilities,
@@ -1109,7 +1109,7 @@ async function summarizeGraphEdgeDecayStatus(config) {
 }
 async function summarizeTierDistribution(storage) {
   try {
-    const { summarizeTiers } = await import("./tier-stats-2JCZYEF7.js");
+    const { summarizeTiers } = await import("./tier-stats-JDN6HRNT.js");
     const summary = await summarizeTiers(storage);
     const storageDir = storage.dir ?? "";
     const journalPath = storageDir.length > 0 ? path.join(storageDir, "state", "tier-migration-journal.jsonl") : null;
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-4IIFL7GC.js.map
+//# sourceMappingURL=chunk-CLKBV3Z3.js.map

package/dist/{chunk-ZYLC7NFO.js → chunk-CSY44OKU.js}

@@ -1,16 +1,16 @@
 import {
   externalWikiSearchOperation
-} from "./chunk-ZPJ4QSGP.js";
+} from "./chunk-VTU5IEKY.js";
 import {
   memoryStoreRequestSchema
-} from "./chunk-NIS256NW.js";
+} from "./chunk-JKW663ZN.js";
 import {
   CorrectionContractError,
   DECISION_SUBCOMMANDS,
   DELTA_SUBCOMMANDS,
   defineOperation,
   isCodegraphToolName
-} from "./chunk-T2JHZWH6.js";
+} from "./chunk-3WGI7F4V.js";
 import {
   serializeMutations,
   withHeldFileLock
@@ -1818,4 +1818,4 @@ export {
   codegraphIngestTracesOperation,
   REGISTERED_OPERATIONS
 };
-//# sourceMappingURL=chunk-ZYLC7NFO.js.map
+//# sourceMappingURL=chunk-CSY44OKU.js.map

package/dist/{chunk-HLYR2TQL.js → chunk-CUTFSLSD.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-2AD5SXO4.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-ZMYDYNI4.js";
+} from "./chunk-N7CXQ5TA.js";
 import {
   resolvePrincipal
 } from "./chunk-3GD2HFR6.js";
@@ -792,4 +792,4 @@ var SmartBuffer = class {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-HLYR2TQL.js.map
+//# sourceMappingURL=chunk-CUTFSLSD.js.map

package/dist/{chunk-RDJRFDJY.js → chunk-DBY26JJJ.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-6R4G7N4S.js";
+} from "./chunk-QQXWFDRD.js";
 import {
   composeMemoryEnvelope
 } from "./chunk-NSVDUN76.js";
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-RDJRFDJY.js.map
+//# sourceMappingURL=chunk-DBY26JJJ.js.map

package/dist/{chunk-QWGE2PUH.js → chunk-DDA55IVB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-V7IZKJI3.js";
 import {
   AdapterRegistry
-} from "./chunk-JBPKEARU.js";
+} from "./chunk-AU7Q3LSC.js";
 import {
   WriteRateLimiter
 } from "./chunk-MKQBXQKU.js";
@@ -21,13 +21,13 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-PX2LSHYM.js";
+} from "./chunk-3SXLD5T3.js";
 import {
   RelayMissionStoreError
-} from "./chunk-ZYLC7NFO.js";
+} from "./chunk-CSY44OKU.js";
 import {
   validateRequest
-} from "./chunk-NIS256NW.js";
+} from "./chunk-JKW663ZN.js";
 import {
   executeResolution,
   isValidResolutionVerb
@@ -50,12 +50,12 @@ import {
 import {
   authorizationProbeNamespaces,
   probeOperationAuthorization
-} from "./chunk-UES4BHA2.js";
+} from "./chunk-QTO6BMQZ.js";
 import {
   CorrectionContractError,
   getOperation,
   resolveQueryNamespaceWritablePreflight
-} from "./chunk-T2JHZWH6.js";
+} from "./chunk-3WGI7F4V.js";
 import {
   isTrustZoneName
 } from "./chunk-KQS72GCR.js";
@@ -64,12 +64,12 @@ import {
 } from "./chunk-DEUNUKTD.js";
 import {
   isRecallDisclosure
-} from "./chunk-UU3G6GUP.js";
+} from "./chunk-BIF4SHMD.js";
 import {
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
   OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES
-} from "./chunk-GYPQL6XN.js";
+} from "./chunk-Z4N7SVVF.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -2255,7 +2255,7 @@ var EngramAccessHttpServer = class {
     if (req.method === "POST" && pathname === "/engram/v1/contradiction-scan") {
       this.enforceTokenOp("contradiction_scan_run");
       const body = await this.readJsonBody(req);
-      const { runContradictionScan } = await import("./contradiction-scan-HYLIRMJ2.js");
+      const { runContradictionScan } = await import("./contradiction-scan-KCADHXPE.js");
       const principal = this.resolveRequestPrincipal(req);
       const result = await runContradictionScan({
         storage: this.service.storageRef,
@@ -3263,4 +3263,4 @@ export {
   MeetingsInputError,
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-QWGE2PUH.js.map
+//# sourceMappingURL=chunk-DDA55IVB.js.map

package/dist/{chunk-VMMQDEN5.js → chunk-DN2IDKI5.js}

@@ -1,6 +1,6 @@
 import {
   createSearchBackend
-} from "./chunk-AZM4CCAC.js";
+} from "./chunk-UWJNKGBA.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
@@ -470,4 +470,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-VMMQDEN5.js.map
+//# sourceMappingURL=chunk-DN2IDKI5.js.map

package/dist/{chunk-2GFK22OZ.js → chunk-DOOWFDWN.js}

@@ -4,7 +4,7 @@ import {
 import {
   computeCorpusWatermarks,
   resolveCorpusNamespaceRoots
-} from "./chunk-APPFNGX6.js";
+} from "./chunk-BSXGTDVJ.js";
 
 // src/operator-doctor-corpus.ts
 var DIGEST_PREFIX_LENGTH = 12;
@@ -78,4 +78,4 @@ export {
   corpusWatermarksFromCheck,
   summarizeCorpusAndReplica
 };
-//# sourceMappingURL=chunk-2GFK22OZ.js.map
+//# sourceMappingURL=chunk-DOOWFDWN.js.map

package/dist/{chunk-7FGL6CGA.js → chunk-DVYRD4HY.js}

@@ -20,7 +20,7 @@ import {
   readProjectedEntityMentions,
   readProjectedGovernanceRecord,
   readProjectedNativeKnowledgeChunks
-} from "./chunk-3CSX3ETE.js";
+} from "./chunk-2LWQSV6A.js";
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
@@ -724,4 +724,4 @@ export {
   drainPendingLifecycleLedgerForSync,
   drainPendingLifecycleForSyncOrThrow
 };
-//# sourceMappingURL=chunk-7FGL6CGA.js.map
+//# sourceMappingURL=chunk-DVYRD4HY.js.map

package/dist/{chunk-YGLY6QFV.js → chunk-F2Y6I74C.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-SUPEYLH2.js";
 import {
   StorageManager
-} from "./chunk-6R4G7N4S.js";
+} from "./chunk-QQXWFDRD.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1283,4 +1283,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-YGLY6QFV.js.map
+//# sourceMappingURL=chunk-F2Y6I74C.js.map

package/dist/{chunk-UU7TRFNE.js → chunk-FFEBSFVT.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-NOB2T2FC.js";
 import {
   parseConfig
-} from "./chunk-47P3RYZP.js";
+} from "./chunk-2INWPC6E.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-UU7TRFNE.js.map
+//# sourceMappingURL=chunk-FFEBSFVT.js.map

package/dist/chunk-HNDIND7P.js

@@ -0,0 +1,331 @@
+import {
+  normalizeNamespaceIdentity
+} from "./chunk-EGGE52UU.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-JDSVLVCG.js";
+import {
+  parseIsoOffsetTimestamp
+} from "./chunk-P7FMDTKL.js";
+
+// src/support-passport/contracts.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+var SUPPORT_PASSPORT_CARD_CATEGORIES = [
+  "communication",
+  "environment",
+  "transitions",
+  "sensory",
+  "regulation",
+  "interests",
+  "other"
+];
+var SUPPORT_PASSPORT_CARD_STATUSES = [
+  "pending_review",
+  "active",
+  "rejected",
+  "superseded",
+  "archived"
+];
+var SupportPassportCardCategorySchema = z.enum(SUPPORT_PASSPORT_CARD_CATEGORIES);
+var SupportPassportCardStatusSchema = z.enum(SUPPORT_PASSPORT_CARD_STATUSES);
+var SupportPassportCardTitleSchema = z.string().trim().min(1).max(80).refine((title) => !title.includes("]") && !title.includes("\n") && !title.includes("\r"), {
+  message: "card titles cannot contain closing brackets or line breaks"
+});
+var IsoTimestampSchema = z.string().datetime({ offset: true }).refine((value) => parseIsoOffsetTimestamp(value) !== null, {
+  message: "timestamps must be valid ISO 8601 values"
+});
+var SupportPassportNamespaceSchema = z.string().min(1).refine((namespace) => namespace === normalizeNamespaceIdentity(namespace), {
+  message: "namespaces must be canonical"
+});
+var SupportPassportMemoryIdSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/);
+var SupportPassportCardSchema = z.object({
+  cardId: SupportPassportMemoryIdSchema,
+  title: SupportPassportCardTitleSchema,
+  statement: z.string().trim().min(1).max(500),
+  category: SupportPassportCardCategorySchema,
+  status: SupportPassportCardStatusSchema,
+  updatedAt: IsoTimestampSchema,
+  reviewBy: IsoTimestampSchema,
+  revision: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var SupportPassportCardListSchema = z.array(SupportPassportCardSchema).max(100).superRefine((cards, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, card] of cards.entries()) {
+    if (seen.has(card.cardId)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "card IDs must be unique",
+        path: [index, "cardId"]
+      });
+    }
+    seen.add(card.cardId);
+  }
+});
+var SupportPassportListCardsInputSchema = z.object({
+  principal: z.string().trim().min(1).max(512)
+}).strict();
+var SupportPassportManualDraftInputSchema = z.object({
+  principal: z.string().trim().min(1).max(512),
+  title: SupportPassportCardTitleSchema,
+  statement: z.string().trim().min(1).max(500),
+  category: SupportPassportCardCategorySchema,
+  reviewBy: IsoTimestampSchema
+}).strict();
+var SupportPassportCardMutationInputSchema = z.object({
+  principal: z.string().trim().min(1).max(512),
+  cardId: SupportPassportMemoryIdSchema,
+  expectedRevision: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var SupportPassportReplaceCardInputSchema = SupportPassportCardMutationInputSchema.extend({
+  title: SupportPassportCardTitleSchema,
+  statement: z.string().trim().min(1).max(500),
+  category: SupportPassportCardCategorySchema,
+  reviewBy: IsoTimestampSchema
+}).strict();
+function computeSupportPassportCardRevision(fields) {
+  const canonicalFields = {
+    cardId: fields.cardId,
+    category: fields.category,
+    reviewBy: fields.reviewBy,
+    statement: fields.statement,
+    status: fields.status,
+    title: fields.title,
+    updatedAt: fields.updatedAt
+  };
+  return createHash("sha256").update(JSON.stringify(canonicalFields)).digest("hex");
+}
+
+// src/support-passport/card-projection.ts
+import { createHash as createHash2 } from "crypto";
+import { lstat } from "fs/promises";
+var SUPPORT_PASSPORT_CARD_TAG = "support-passport-card";
+var SUPPORT_PASSPORT_AUDIT_TAG = "support-passport-audit";
+function isSupportPassportPrivateMemory(memory) {
+  const tags = memory.frontmatter.tags;
+  if (tags?.includes(SUPPORT_PASSPORT_CARD_TAG) === true || tags?.includes(SUPPORT_PASSPORT_AUDIT_TAG) === true) {
+    return true;
+  }
+  return Object.keys(memory.frontmatter.structuredAttributes ?? {}).some((key) => key.startsWith("support-passport-"));
+}
+function excludeSupportPassportPrivateMemories(memories) {
+  return memories.filter((memory) => !isSupportPassportPrivateMemory(memory));
+}
+function createSupportPassportPrivateFileExclusion(storage) {
+  const classifications = /* @__PURE__ */ new Map();
+  return async ({ filePath }) => {
+    let file;
+    try {
+      file = await lstat(filePath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        classifications.delete(filePath);
+        return false;
+      }
+      throw error;
+    }
+    const identity = `${file.dev}:${file.ino}:${file.size}:${file.mtimeMs}:${file.ctimeMs}`;
+    const cached = classifications.get(filePath);
+    if (cached?.identity === identity) return await cached.excluded;
+    const excluded = storage.readMemoryByPath(filePath).then((memory) => memory ? isSupportPassportPrivateMemory(memory) : false);
+    classifications.set(filePath, { identity, excluded });
+    try {
+      return await excluded;
+    } catch (error) {
+      if (classifications.get(filePath)?.excluded === excluded) classifications.delete(filePath);
+      throw error;
+    }
+  };
+}
+var SUPPORT_PASSPORT_ATTRIBUTE_KEYS = Object.freeze({
+  namespace: "support-passport-namespace",
+  namespaceEncoding: "support-passport-namespace-encoding",
+  owner: "support-passport-owner",
+  title: "support-passport-title",
+  category: "support-passport-category",
+  order: "support-passport-order",
+  reviewBy: "support-passport-review-by",
+  sourceMemoryIds: "support-passport-source-ids",
+  replacesDraftId: "support-passport-replaces-draft-id",
+  replacedRevision: "support-passport-replaced-revision",
+  draftReplacementPrepared: "support-passport-draft-replacement-prepared",
+  replacementComplete: "support-passport-replacement-complete"
+});
+var SUPPORT_PASSPORT_NAMESPACE_ENCODING = "base64url-v1";
+var SUPPORT_PASSPORT_NAMESPACE_CHUNK_PREFIX = "support-passport-namespace-";
+var SUPPORT_PASSPORT_NAMESPACE_CHUNK_SIZE = 1024;
+var LegacySupportPassportNamespaceSchema = SupportPassportNamespaceSchema.refine(
+  (namespace) => !namespace.includes("/") && !namespace.includes("\\") && !namespace.includes("..") && !namespace.includes("]") && !namespace.includes("\0") && !namespace.includes("\n") && !namespace.includes("\r")
+);
+function encodeSupportPassportNamespaceAttributes(namespace) {
+  const canonical = SupportPassportNamespaceSchema.parse(namespace);
+  const encoded = Buffer.from(canonical, "utf8").toString("base64url");
+  const chunks = encoded.match(new RegExp(`.{1,${SUPPORT_PASSPORT_NAMESPACE_CHUNK_SIZE}}`, "g")) ?? [];
+  const digest = createHash2("sha256").update(encoded).digest("hex");
+  return Object.fromEntries([
+    [SUPPORT_PASSPORT_ATTRIBUTE_KEYS.namespace, chunks[0] ?? ""],
+    [
+      SUPPORT_PASSPORT_ATTRIBUTE_KEYS.namespaceEncoding,
+      `${SUPPORT_PASSPORT_NAMESPACE_ENCODING}:${chunks.length}:${digest}`
+    ],
+    ...chunks.slice(1).map((chunk, index) => [`${SUPPORT_PASSPORT_NAMESPACE_CHUNK_PREFIX}${index + 1}`, chunk])
+  ]);
+}
+function decodeSupportPassportNamespaceAttributes(attributes) {
+  const firstChunk = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.namespace];
+  const encoding = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.namespaceEncoding];
+  if (encoding === void 0) {
+    const legacy = LegacySupportPassportNamespaceSchema.safeParse(firstChunk);
+    return legacy.success ? legacy.data : null;
+  }
+  const match = /^base64url-v1:([1-9]\d*):([a-f0-9]{64})$/.exec(encoding);
+  if (!match || typeof firstChunk !== "string") return null;
+  const chunkCount = Number(match[1]);
+  if (!Number.isSafeInteger(chunkCount)) return null;
+  const chunkIndexes = Object.keys(attributes).flatMap((key) => {
+    const chunkMatch = /^support-passport-namespace-(\d+)$/.exec(key);
+    return chunkMatch ? [Number(chunkMatch[1])] : [];
+  });
+  if (chunkIndexes.length !== chunkCount - 1 || chunkIndexes.some((index) => !Number.isSafeInteger(index) || index < 1 || index >= chunkCount))
+    return null;
+  const chunks = [firstChunk];
+  for (let index = 1; index < chunkCount; index += 1) {
+    const chunk = attributes[`${SUPPORT_PASSPORT_NAMESPACE_CHUNK_PREFIX}${index}`];
+    if (typeof chunk !== "string" || chunk.length === 0) return null;
+    chunks.push(chunk);
+  }
+  const encoded = chunks.join("");
+  if (createHash2("sha256").update(encoded).digest("hex") !== match[2]) return null;
+  const decoded = Buffer.from(encoded, "base64url").toString("utf8");
+  if (Buffer.from(decoded, "utf8").toString("base64url") !== encoded) return null;
+  const namespace = SupportPassportNamespaceSchema.safeParse(decoded);
+  return namespace.success ? namespace.data : null;
+}
+function computeSupportPassportOwnerKey(principal) {
+  return createHash2("sha256").update(principal).digest("hex");
+}
+function parseSourceMemoryIds(value) {
+  if (value === void 0) return null;
+  if (value === "") return [];
+  const rawIds = value.split(",");
+  if (rawIds.length > 5) return null;
+  const normalized = [];
+  for (const rawId of rawIds) {
+    const parsed = SupportPassportMemoryIdSchema.safeParse(rawId);
+    if (!parsed.success) return null;
+    normalized.push(parsed.data);
+  }
+  if (new Set(normalized).size !== normalized.length) return null;
+  return normalized;
+}
+function parseSupportPassportCardMetadata(memory) {
+  const frontmatter = memory.frontmatter;
+  const attributes = frontmatter.structuredAttributes;
+  if (frontmatter.category !== "preference") return null;
+  if (!frontmatter.tags?.includes(SUPPORT_PASSPORT_CARD_TAG)) return null;
+  if (!attributes || frontmatter.blockedBy || frontmatter.archivedAt || frontmatter.supersededBy) return null;
+  const category = SupportPassportCardCategorySchema.safeParse(attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.category]);
+  const status = SupportPassportCardStatusSchema.safeParse(frontmatter.status);
+  const rawOrder = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.order];
+  const order = Number(rawOrder);
+  const sourceMemoryIds = parseSourceMemoryIds(attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.sourceMemoryIds]);
+  const namespace = decodeSupportPassportNamespaceAttributes(attributes);
+  const owner = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.owner];
+  let replacesDraftId;
+  const rawReplacesDraftId = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.replacesDraftId];
+  if (rawReplacesDraftId !== void 0) {
+    const parsedReplacesDraftId = SupportPassportMemoryIdSchema.safeParse(rawReplacesDraftId);
+    if (!parsedReplacesDraftId.success) return null;
+    replacesDraftId = parsedReplacesDraftId.data;
+  }
+  let replacedRevision;
+  const rawReplacedRevision = attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.replacedRevision];
+  if (rawReplacedRevision !== void 0) {
+    if (!/^[a-f0-9]{64}$/.test(rawReplacedRevision)) return null;
+    replacedRevision = rawReplacedRevision;
+  }
+  if (!category.success || !status.success || status.data === "superseded" || typeof rawOrder !== "string" || !/^(?:0|[1-9]\d*)$/.test(rawOrder) || !Number.isSafeInteger(order) || namespace === null || typeof owner !== "string" || !/^[a-f0-9]{64}$/.test(owner) || !sourceMemoryIds)
+    return null;
+  const fields = SupportPassportCardSchema.omit({ revision: true, statement: true }).safeParse({
+    cardId: frontmatter.id,
+    title: attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.title],
+    category: category.data,
+    status: status.data,
+    updatedAt: frontmatter.updated,
+    reviewBy: attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.reviewBy]
+  });
+  if (!fields.success) return null;
+  return {
+    fields: fields.data,
+    order,
+    sourceMemoryIds,
+    namespace,
+    owner,
+    replacesDraftId,
+    replacedRevision,
+    draftReplacementPrepared: attributes[SUPPORT_PASSPORT_ATTRIBUTE_KEYS.draftReplacementPrepared] === "true"
+  };
+}
+function hasLiveSupportPassportCard(memory) {
+  const metadata = parseSupportPassportCardMetadata(memory);
+  if (metadata?.fields.status !== "active" && metadata?.fields.status !== "pending_review") return false;
+  return SupportPassportCardSchema.omit({ revision: true }).safeParse({
+    ...metadata.fields,
+    statement: stripAttributesSuffix(memory.content)
+  }).success;
+}
+function projectSupportPassportCard(memory) {
+  const metadata = parseSupportPassportCardMetadata(memory);
+  if (!metadata) return null;
+  const fields = {
+    ...metadata.fields,
+    statement: stripAttributesSuffix(memory.content)
+  };
+  const normalized = SupportPassportCardSchema.omit({ revision: true }).safeParse(fields);
+  if (!normalized.success) return null;
+  const parsed = SupportPassportCardSchema.safeParse({
+    ...normalized.data,
+    revision: computeSupportPassportCardRevision(normalized.data)
+  });
+  if (!parsed.success) return null;
+  return {
+    card: parsed.data,
+    memory,
+    order: metadata.order,
+    sourceMemoryIds: metadata.sourceMemoryIds,
+    namespace: metadata.namespace,
+    owner: metadata.owner,
+    replacesDraftId: metadata.replacesDraftId,
+    replacedRevision: metadata.replacedRevision,
+    draftReplacementPrepared: metadata.draftReplacementPrepared
+  };
+}
+
+export {
+  SUPPORT_PASSPORT_CARD_CATEGORIES,
+  SUPPORT_PASSPORT_CARD_STATUSES,
+  SupportPassportCardCategorySchema,
+  SupportPassportCardStatusSchema,
+  SupportPassportCardTitleSchema,
+  SupportPassportNamespaceSchema,
+  SupportPassportMemoryIdSchema,
+  SupportPassportCardSchema,
+  SupportPassportCardListSchema,
+  SupportPassportListCardsInputSchema,
+  SupportPassportManualDraftInputSchema,
+  SupportPassportCardMutationInputSchema,
+  SupportPassportReplaceCardInputSchema,
+  computeSupportPassportCardRevision,
+  SUPPORT_PASSPORT_CARD_TAG,
+  SUPPORT_PASSPORT_AUDIT_TAG,
+  isSupportPassportPrivateMemory,
+  excludeSupportPassportPrivateMemories,
+  createSupportPassportPrivateFileExclusion,
+  SUPPORT_PASSPORT_ATTRIBUTE_KEYS,
+  encodeSupportPassportNamespaceAttributes,
+  decodeSupportPassportNamespaceAttributes,
+  computeSupportPassportOwnerKey,
+  hasLiveSupportPassportCard,
+  projectSupportPassportCard
+};
+//# sourceMappingURL=chunk-HNDIND7P.js.map