@pyxmate/memory 1.17.15 → 1.17.17

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { StoreInput as StoreInput$1, MemoryEntry as MemoryEntry$1, MemorySearchParams as MemorySearchParams$1, MemorySearchResult as MemorySearchResult$1, MemoryType as MemoryType$1, PrincipalContext as PrincipalContext$1, SensitivityLevel as SensitivityLevel$1, MemoryStats as MemoryStats$1, LineageParams as LineageParams$1, LineageResult as LineageResult$1, ReinforceParams as ReinforceParams$1, ReinforceResult as ReinforceResult$1, WikiLintReport as WikiLintReport$1, GraphRepairResult as GraphRepairResult$1, ExtractedImageMeta as ExtractedImageMeta$1, IngestEntity as IngestEntity$1, IngestRelationship as IngestRelationship$1, EntityExtractionResult as EntityExtractionResult$1, Topology as Topology$1, IngestEvent as IngestEvent$1, GraphNode as GraphNode$1, GraphTraversalResult as GraphTraversalResult$1, CorrectionRecord as CorrectionRecord$1 } from '@pyx-memory/shared';
+import { StoreInput as StoreInput$1, MemoryEntry as MemoryEntry$1, MemorySearchParams as MemorySearchParams$1, MemorySearchResult as MemorySearchResult$1, MemoryType as MemoryType$1, PrincipalContext as PrincipalContext$1, SensitivityLevel as SensitivityLevel$1, MemoryStats as MemoryStats$1, LineageParams as LineageParams$1, LineageResult as LineageResult$1, ReinforceParams as ReinforceParams$1, ReinforceResult as ReinforceResult$1, WikiLintReport as WikiLintReport$1, GraphRepairResult as GraphRepairResult$1, ExtractedImageMeta as ExtractedImageMeta$1, IngestEntity as IngestEntity$1, IngestRelationship as IngestRelationship$1, EntityExtractionResult as EntityExtractionResult$1, Topology as Topology$1, IngestEvent as IngestEvent$1, GraphEnrichEvent as GraphEnrichEvent$1, GraphNode as GraphNode$1, GraphTraversalResult as GraphTraversalResult$1, CorrectionRecord as CorrectionRecord$1 } from '@pyx-memory/shared';
+export { documentContentSource, documentGraphSource, documentImageSource } from '@pyx-memory/shared';
+export { e as encodeListCursorToken, p as parseListCursorToken } from './data-plane-contract-fDvTm9bF.js';
 
 /** Parameters for paginated entry listing. */
 interface MemoryListParams {
@@ -61,6 +63,17 @@ interface TemporalQueryFilters {
     agentId?: string;
     source?: string;
     limit?: number;
+    /**
+     * Number of matching rows to skip. Offset pages can shift under concurrent
+     * deletion; use cursor for a deletion-stable queryAsOf walk.
+     */
+    offset?: number;
+    /**
+     * Opaque keyset token for a deletion-stable queryAsOf walk. Derive it from
+     * the last returned entry with `encodeListCursorToken`; mutually exclusive
+     * with offset.
+     */
+    cursor?: string;
     /** Maximum sensitivity level to include. Omitted preserves legacy behavior. */
     maxSensitivity?: SensitivityLevel$1;
 }
@@ -79,6 +92,8 @@ interface MemoryLogFilters {
 /** Options for scoping operations to a specific tenant. */
 interface TenantScopeOptions {
     tenantId?: string;
+    /** Optional strict namespace coordinate for exact get/delete operations. */
+    namespaceId?: string;
     /**
      * Graph count mode for stats(). Use raw on admin-health paths
      * that should avoid the visible graph projection.
@@ -107,7 +122,7 @@ interface MemoryInterface {
     clearSession(sessionId: string, options?: TenantScopeOptions): Promise<number>;
     stats(options?: TenantScopeOptions): Promise<MemoryStats$1>;
     /** Query entries as they existed at a point in time (by ingest time). */
-    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
+    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters, options?: TenantScopeOptions): Promise<MemoryEntry$1[]>;
     /** Read the time-ordered lineage of a graph fact or superseded entry chain. */
     lineage(params: LineageParams$1): Promise<LineageResult$1>;
     /** Reinforce memories that were actually used by the caller. */
@@ -144,7 +159,7 @@ interface ExtendedMemoryInterface extends MemoryInterface {
     /** Reindex the FTS5 full-text search index. */
     reindex(): Promise<void>;
     /** Delete all entries matching a source, cleaning up all stores. */
-    deleteBySource(source: string): Promise<number>;
+    deleteBySource(source: string, options?: TenantScopeOptions): Promise<number>;
     /** Repair stale graph references left by older delete paths or crashed cleanup. */
     repairGraph(): Promise<GraphRepairResult$1>;
     /**
@@ -246,6 +261,49 @@ interface IngestFileOptions {
     enrichment?: EnrichmentCallbacks;
     signal?: AbortSignal;
     namespaceId?: string;
+    /**
+     * Stable logical document identity used for replaceable content, image,
+     * and graph projections. Requires `enrichment.extractEntitiesV2` so the
+     * client can negotiate text windows and complete the stable replacement.
+     */
+    documentKey?: string;
+    /**
+     * Migration-only pinned file-ingestion catalog for this document's first
+     * stable replacement. The server validates its exact scope and uses its
+     * bounded provenance to detach legacy graph references. Omit this after the
+     * stable anchor is established: the first pass may retire catalog-owned
+     * projections, so later revisions should use `documentKey` alone.
+     */
+    catalogEntryId?: string;
+}
+/**
+ * Options for {@link MemoryClient.graphEnrichFileEvents}. `documentKey` is the
+ * caller's stable logical identity for the document whose graph is being
+ * rebuilt — the server derives the graph anchor id from
+ * (tenant, namespace, documentKey), so repeating the same key replaces the
+ * document's graph references instead of multiplying them.
+ *
+ * `enrichment.extractEntitiesV2` is required: graph-only re-enrichment is
+ * caller-extraction by definition (there is no server-side fallback).
+ */
+interface GraphEnrichFileOptions {
+    documentKey: string;
+    /**
+     * Migration-only pinned file-ingestion catalog for the first stable graph
+     * replacement. The server resolves it in the current tenant/namespace and
+     * detaches its bounded graph references. Omit it on later revisions once
+     * the `documentKey` anchor exists.
+     */
+    catalogEntryId?: string;
+    namespaceId?: string;
+    signal?: AbortSignal;
+    enrichment: EnrichmentCallbacks;
+}
+interface FileDownloadOptions {
+    /** Stable logical document identity used by documentKey-aware ingest. */
+    documentKey?: string;
+    /** Exact namespace containing the uploaded document. */
+    namespaceId?: string;
 }
 /**
  * Caller-supplied enrichment for the per-call store path. Mirrors
@@ -288,7 +346,13 @@ interface RequestAuthorityOptions {
 /** Error thrown by MemoryClient when the server returns a non-success response. */
 declare class MemoryServerError extends Error {
     readonly status: number;
-    constructor(message: string, status: number);
+    /** Stable machine-readable discriminator returned by the memory server. */
+    readonly code?: string;
+    /** Exact HTTP Retry-After value returned by the memory server. */
+    readonly retryAfter?: string;
+    /** Retry delay normalized to seconds when Retry-After is parseable. */
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, status: number, code?: string, retryAfter?: string);
     /** True when the server returned HTTP 404 (not found). */
     get isNotFound(): boolean;
 }
@@ -360,13 +424,50 @@ declare class MemoryClient implements ExtendedMemoryInterface {
      */
     ingestFileEvents(file: File, options?: IngestFileOptions): AsyncIterable<IngestEvent$1>;
     /**
-     * Run the SDK-side enrichment phase (image-describe → entity-extract →
-     * `/enrich` POST) for a server result, emitting progress + heartbeat
-     * events around the slow steps and yielding the single terminal
-     * {@link IngestResultEvent} at the end. Skips work cleanly when the
-     * server emitted no enrichment block or the caller wired no callbacks.
+     * Graph-only re-enrichment for a document whose chunks are already stored
+     * and searchable but whose graph build failed. Uploads the original to
+     * `/api/memory/graph/enrich/file` (prepare-only — the server performs zero
+     * store/delete before the final graph write), runs the SAME enrichment
+     * callback engine as {@link ingestFileEvents}, then finalizes into one
+     * stable graph anchor keyed by `documentKey`. Repeating the same key
+     * replaces the document's graph references idempotently.
+     *
+     * The terminal `result` is a {@link GraphEnrichResult} event carrying the
+     * ACTUAL persisted graph counts; abort and failures yield a terminal
+     * `error` event instead (the server retains the pending session for retry).
+     */
+    graphEnrichFileEvents(file: File, options: GraphEnrichFileOptions): AsyncIterable<GraphEnrichEvent$1>;
+    /**
+     * POST a multipart body to an NDJSON streaming endpoint and relay its
+     * progress/heartbeat events. Returns the raw terminal `result` record, or
+     * null after yielding a terminal error (transport failure, server error
+     * event, non-NDJSON response, stream ending without a result). One
+     * implementation for both streaming surfaces so the wire protocol cannot
+     * fork.
+     */
+    private streamNdjsonUpload;
+    /**
+     * Run the SDK-side enrichment phase for an ingest result and yield the
+     * single terminal {@link IngestResultEvent} at the end. Skips work cleanly
+     * when the server emitted no enrichment block or the caller wired no
+     * callbacks. The callback work itself lives in
+     * {@link runEnrichmentCallbacks} — shared with the graph-only surface.
      */
     private completeIngestFileEvents;
+    /**
+     * The ONE enrichment callback engine, shared by {@link ingestFileEvents}
+     * and {@link graphEnrichFileEvents}: fetches extracted images, invokes
+     * `describeImage` with bounded concurrency, invokes `extractEntitiesV2`
+     * exactly once, and POSTs `/files/{fileId}/enrich` — emitting progress and
+     * heartbeat events around each slow step. Throws on any failure; the
+     * purpose-specific wrappers translate that into their terminal error.
+     *
+     * Legacy ingest keeps its existing partial add-on behavior. Graph-only and
+     * documentKey-aware full ingest may replace a prior graph only from a
+     * complete input set (no truncated text windows or undescribed images). A
+     * complete extractor result containing zero entities remains a valid clear.
+     */
+    private runEnrichmentCallbacks;
     /**
      * Race a Promise against a periodic heartbeat tick. Yields a heartbeat
      * IngestEvent every {@link INGEST_EVENT_HEARTBEAT_MS} until the promise
@@ -382,12 +483,12 @@ declare class MemoryClient implements ExtendedMemoryInterface {
      * Get the download URL for an uploaded file.
      * Returns a URL that serves the original file binary with proper Content-Type.
      */
-    getFileDownloadUrl(filename: string): string;
+    getFileDownloadUrl(filename: string, options?: FileDownloadOptions): string;
     /**
      * Download an uploaded file by filename.
      * Returns the raw Response (caller handles the body — arrayBuffer, blob, stream, etc.).
      */
-    downloadFile(filename: string): Promise<Response>;
+    downloadFile(filename: string, options?: FileDownloadOptions): Promise<Response>;
     /** @deprecated Use {@link list} instead. Kept for backwards compatibility. */
     listEntries(params?: {
         page?: number;
@@ -416,7 +517,7 @@ declare class MemoryClient implements ExtendedMemoryInterface {
     reindex(): Promise<void>;
     clearGraph(): Promise<number>;
     repairGraph(): Promise<GraphRepairResult$1>;
-    deleteBySource(source: string): Promise<number>;
+    deleteBySource(source: string, authority?: TenantScopeOptions): Promise<number>;
     setFolder(from: string, to: string, options?: {
         dryRun?: boolean;
     }): Promise<{
@@ -425,7 +526,7 @@ declare class MemoryClient implements ExtendedMemoryInterface {
         updated: number;
         dryRun: boolean;
     }>;
-    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
+    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters, authority?: TenantScopeOptions): Promise<MemoryEntry$1[]>;
     lineage(params: LineageParams$1, authority?: RequestAuthorityOptions): Promise<LineageResult$1>;
     reinforce(params: ReinforceParams$1, authority?: RequestAuthorityOptions): Promise<ReinforceResult$1>;
     log(filters?: MemoryLogFilters): Promise<MemoryEntry$1[]>;
@@ -943,6 +1044,8 @@ interface ReinforceResult {
 interface SourceEvidence {
     /** Memory entry that produced this graph fact. */
     memoryEntryId: string;
+    /** Data tenant of the source entry. `null` = single-tenant / legacy data. */
+    tenantId?: string | null;
     /** Namespace of the source memory entry. `null` = legacy / tenant-root. */
     namespaceId?: string | null;
     /** Optional source identifier copied from the memory entry or caller. */
@@ -1274,6 +1377,10 @@ interface EntityExtractionResult {
         type: string;
     }>;
 }
+interface GraphExtractionPayload {
+    entities: IngestEntity[];
+    relationships: IngestRelationship[];
+}
 declare function normalizeGraphLabel(value: string, fallback: string): string;
 /**
  * Identity key for a graph node: the normalized name alone. `type` is a node
@@ -1287,6 +1394,16 @@ declare function normalizeGraphLabel(value: string, fallback: string): string;
  * edge resolvability with it — all three MUST agree, so they import this one fn.
  */
 declare function normalizeNameKey(name: string): string;
+/**
+ * Runtime contract for destructive graph replacement payloads. TypeScript
+ * callback types do not protect JavaScript callers or malformed LLM adapter
+ * results; accepting a missing `entities` field as an empty extraction would
+ * erase the prior graph. Both arrays are therefore required, every item is
+ * structurally validated, and every relationship endpoint must resolve to a
+ * declared entity under the graph store's exact name identity normalizer.
+ * A genuinely empty `{ entities: [], relationships: [] }` remains valid.
+ */
+declare function assertGraphExtractionPayload(value: unknown, field?: string): GraphExtractionPayload;
 /**
  * Merge caller-provided entities/relationships with LLM-extracted ones.
  *
@@ -1352,6 +1469,8 @@ interface ApiResponse<T> {
     success: boolean;
     data?: T;
     error?: string;
+    /** Stable machine-readable discriminator for error responses. */
+    code?: string;
 }
 /**
  * Build variant of the running pyx-memory image. Detected from the actual
@@ -1457,11 +1576,21 @@ interface FileIngestResult {
     fileType: string;
     chunks: number;
     entryIds: string[];
+    /**
+     * Stable document graph anchor written during enrichment when the ingest
+     * supplied a documentKey. This anchor is not included in entryIds; that
+     * array remains limited to chunks and image-description rows.
+     */
+    graphAnchorEntryId?: string;
     totalCharacters: number;
     /** Present when images were extracted (v1) OR text windows / images were emitted (v2). */
     enrichment?: EnrichmentPending;
     /** Present only when ≥1 stored chunk was auto-classified secret by credential detection. */
     secretElevation?: SecretElevationAggregate;
+    /** Relationships dropped because an endpoint matched no submitted entity. */
+    relationshipsDropped?: number;
+    /** Up to 20 dropped relationships, retained from the enrichment response. */
+    droppedRelationships?: DroppedGraphRelationship[];
 }
 /** Coarse pipeline stages. Stable vocabulary — finer detail goes in counters/message. */
 type IngestStage = 'parsing' | 'storing' | 'enrichment' | 'complete';
@@ -1508,20 +1637,76 @@ interface IngestErrorEvent {
     message?: string;
     code?: string | number;
     status?: number;
+    /** Exact HTTP Retry-After value when the failure came from an HTTP response. */
+    retryAfter?: string;
+    /** Retry delay normalized to seconds when Retry-After was parseable. */
+    retryAfterSeconds?: number;
     /**
-     * Server's pre-enrichment {@link FileIngestResult}, present when the error
-     * fired during the SDK's enrichment phase (after the server already emitted
-     * a successful result and the file's chunks/entryIds are durably stored).
+     * Durably committed {@link FileIngestResult}, present when either the server
+     * committed a stable replacement but its secondary-projection cleanup is
+     * still pending, or the SDK's later enrichment phase failed.
      *
      * Lets consumers persist the catalog entry id, per-chunk entry ids, and
      * character/chunk counts before surfacing the error — so a 401 storm during
      * entity extraction no longer loses the search-ready chunks. Absent for
-     * errors that happen before the server's terminal result (parsing/storing
-     * stage failures, transport errors, abort).
+     * errors where the attempted revision did not commit (parsing/storing
+     * failures and rollback cleanup debt), transport errors, and aborts.
      */
     partialResult?: FileIngestResult;
 }
 type IngestEvent = IngestProgressEvent | IngestHeartbeatEvent | IngestResultEvent | IngestErrorEvent;
+/** What a pending enrichment session finalizes into. Sessions created before
+ *  graph-only support carry no purpose and behave as `'ingest'`. */
+type EnrichmentPurpose = 'ingest' | 'graph-only';
+/**
+ * Terminal server event for POST /api/memory/graph/enrich/file. Deliberately
+ * NOT an {@link IngestResultEvent}: the prepare phase stores nothing, so there
+ * are no chunk counters to report — fabricating `chunks: 0` would make the
+ * result indistinguishable from a real empty ingest.
+ */
+interface GraphEnrichPreparedEvent {
+    schemaVersion: 1;
+    type: 'result';
+    stage: 'complete';
+    purpose: 'graph-only';
+    filename: string;
+    fileType: string;
+    enrichment: EnrichmentPendingV2;
+    message?: string;
+}
+/**
+ * Terminal result of a graph-only re-enrichment run — also the response body
+ * of POST /files/{fileId}/enrich when the pending session's purpose is
+ * `'graph-only'`. Counts reflect ACTUAL graph persistence (mirrors
+ * {@link EnrichResult}), never the submitted payload sizes.
+ */
+interface GraphEnrichResult {
+    purpose: 'graph-only';
+    filename: string;
+    fileType: string;
+    /** The single persisted graph projection row, including a successful zero-entity replacement. */
+    entryIds: [string];
+    /** Stable logical document identity whose graph projection was replaced. */
+    graphAnchorEntryId: string;
+    entitiesStored: number;
+    relationshipsStored: number;
+    /** Present (and >0) only when edges were dropped — see {@link EnrichResult}. */
+    relationshipsDropped?: number;
+    droppedRelationships?: DroppedGraphRelationship[];
+}
+/** Terminal success of the SDK's graph-only stream — exactly one per run. */
+interface GraphEnrichResultEvent extends GraphEnrichResult {
+    schemaVersion: 1;
+    type: 'result';
+    stage: 'complete';
+    message?: string;
+}
+/**
+ * Typed view of the SDK's `graphEnrichFileEvents()` stream. Progress /
+ * heartbeat / error envelopes are shared with the ingest stream (same wire
+ * protocol); only the terminal result differs.
+ */
+type GraphEnrichEvent = IngestProgressEvent | IngestHeartbeatEvent | GraphEnrichResultEvent | IngestErrorEvent;
 
 /**
  * Namespace topology-isolation modes for v0.17.0.
@@ -1636,4 +1821,4 @@ interface CreatePyxMemoryOptions {
 }
 declare function createPyxMemory(opts?: CreatePyxMemoryOptions): MemoryClient;
 
-export { type AgentId, type ApiResponse, type ConsolidationRunResult, type CorrectionInput, type CorrectionRecord, type CreatePyxMemoryOptions, DEFAULTS, DEPRECATED_RAG_STRATEGIES, DisabledMemory, type DroppedGraphRelationship, type DueScanInput, EmbeddingProviderName, type EnrichmentCallbacks, type EntityExtractionResult, type ExtendedMemoryInterface, type FetchCorrectionsInput, type GraphEnrichment, type GraphEnrichmentStatus, type GraphFailureMode, type GraphNode, type GraphRelationship, type GraphRepairResult, type GraphTelemetrySnapshot, type GraphTraversalResult, type IngestEntity, type IngestErrorEvent, type IngestEvent, type IngestFileOptions, type IngestHeartbeatEvent, type IngestProgressEvent, type IngestRelationship, type IngestResultEvent, type IngestStage, type IngestionResult, type LineageParams, type LineageResult, type LineageVersion, MemoryClient, type MemoryClientOptions, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemoryLogFilters, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, type MoveEntriesFilter, MoveFailureReason, type MoveResult, type MoveTarget, NamespaceIsolation, type PrincipalContext, RAGStrategy, type ReinforceParams, type ReinforceResult, type ReinforceSignal, SINGLE_TENANT_ID, type SecretElevationAggregate, type SecretElevationNotice, SensitivityLevel, type SourceEvidence, type StoreInput, StoreTarget, TAXONOMY_MAX_CATEGORIES, type TemporalQueryFilters, type TenantScopeOptions, type Timestamp, type Topology, type TopologyExtractionProvider, type TopologyServiceVariant, type UsageHygieneSnapshot, VectorProvider, type VectorStatus, type WikiLintReport, createPyxMemory, mergeExtractedEntities, normalizeGraphLabel, normalizeNameKey, projectSearchResponseForMcp, secretElevationAggregate, secretElevationNoticeFor, withSecretElevationNotice };
+export { type AgentId, type ApiResponse, type ConsolidationRunResult, type CorrectionInput, type CorrectionRecord, type CreatePyxMemoryOptions, DEFAULTS, DEPRECATED_RAG_STRATEGIES, DisabledMemory, type DroppedGraphRelationship, type DueScanInput, EmbeddingProviderName, type EnrichmentCallbacks, type EnrichmentPurpose, type EntityExtractionResult, type ExtendedMemoryInterface, type FetchCorrectionsInput, type FileDownloadOptions, type GraphEnrichEvent, type GraphEnrichFileOptions, type GraphEnrichPreparedEvent, type GraphEnrichResult, type GraphEnrichResultEvent, type GraphEnrichment, type GraphEnrichmentStatus, type GraphExtractionPayload, type GraphFailureMode, type GraphNode, type GraphRelationship, type GraphRepairResult, type GraphTelemetrySnapshot, type GraphTraversalResult, type IngestEntity, type IngestErrorEvent, type IngestEvent, type IngestFileOptions, type IngestHeartbeatEvent, type IngestProgressEvent, type IngestRelationship, type IngestResultEvent, type IngestStage, type IngestionResult, type LineageParams, type LineageResult, type LineageVersion, MemoryClient, type MemoryClientOptions, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemoryLogFilters, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, type MoveEntriesFilter, MoveFailureReason, type MoveResult, type MoveTarget, NamespaceIsolation, type PrincipalContext, RAGStrategy, type ReinforceParams, type ReinforceResult, type ReinforceSignal, SINGLE_TENANT_ID, type SecretElevationAggregate, type SecretElevationNotice, SensitivityLevel, type SourceEvidence, type StoreInput, StoreTarget, TAXONOMY_MAX_CATEGORIES, type TemporalQueryFilters, type TenantScopeOptions, type Timestamp, type Topology, type TopologyExtractionProvider, type TopologyServiceVariant, type UsageHygieneSnapshot, VectorProvider, type VectorStatus, type WikiLintReport, assertGraphExtractionPayload, createPyxMemory, mergeExtractedEntities, normalizeGraphLabel, normalizeNameKey, projectSearchResponseForMcp, secretElevationAggregate, secretElevationNoticeFor, withSecretElevationNotice };

package/dist/index.mjs

@@ -14,16 +14,22 @@ import {
   StoreTarget,
   TAXONOMY_MAX_CATEGORIES,
   VectorProvider,
+  documentContentSource,
+  documentGraphSource,
+  documentImageSource,
   projectSearchResponseForMcp,
   secretElevationAggregate,
   secretElevationNoticeFor,
   withSecretElevationNotice
-} from "./chunk-LGNSLDGB.mjs";
+} from "./chunk-JGFDID3B.mjs";
 import {
+  assertGraphExtractionPayload,
+  encodeListCursorToken,
   mergeExtractedEntities,
   normalizeGraphLabel,
-  normalizeNameKey
-} from "./chunk-A3L46P2G.mjs";
+  normalizeNameKey,
+  parseListCursorToken
+} from "./chunk-3OLH3HYR.mjs";
 
 // src/preset.ts
 var DEFAULT_MEMORY_URL = `http://localhost:${DEFAULTS.MEMORY_SERVER_PORT}`;
@@ -54,10 +60,16 @@ export {
   StoreTarget,
   TAXONOMY_MAX_CATEGORIES,
   VectorProvider,
+  assertGraphExtractionPayload,
   createPyxMemory,
+  documentContentSource,
+  documentGraphSource,
+  documentImageSource,
+  encodeListCursorToken,
   mergeExtractedEntities,
   normalizeGraphLabel,
   normalizeNameKey,
+  parseListCursorToken,
   projectSearchResponseForMcp,
   secretElevationAggregate,
   secretElevationNoticeFor,

package/dist/react.mjs

@@ -11,9 +11,9 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-WDF5LAZS.mjs";
-import "./chunk-LGNSLDGB.mjs";
-import "./chunk-A3L46P2G.mjs";
+} from "./chunk-AMKPOPH6.mjs";
+import "./chunk-JGFDID3B.mjs";
+import "./chunk-3OLH3HYR.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts
 import { useCallback as useCallback2, useMemo } from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "1.17.15",
+  "version": "1.17.17",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",

package/dist/chunk-A3L46P2G.mjs

@@ -1,57 +0,0 @@
-// ../shared/src/graph/extraction.ts
-function normalizeGraphLabel(value, fallback) {
-  const normalized = value.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  return normalized.length > 0 ? normalized : fallback;
-}
-function normalizeNameKey(name) {
-  return name.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function relationshipKey(relationship) {
-  return [
-    relationship.source.trim().toLowerCase(),
-    relationship.target.trim().toLowerCase(),
-    normalizeGraphLabel(relationship.type, "RELATED_TO")
-  ].join("\0");
-}
-function mergeExtractedEntities(callerEntities, callerRelationships, extracted) {
-  const entities = [...callerEntities ?? []];
-  const relationships = [...callerRelationships ?? []];
-  const nameByLowercase = /* @__PURE__ */ new Map();
-  for (const entity of entities) {
-    const key = entity.name.toLowerCase();
-    if (!nameByLowercase.has(key)) nameByLowercase.set(key, entity.name);
-  }
-  for (const entity of extracted.entities) {
-    const key = entity.name.toLowerCase();
-    if (nameByLowercase.has(key)) continue;
-    entities.push({ ...entity, type: normalizeGraphLabel(entity.type, "CONCEPT") });
-    nameByLowercase.set(key, entity.name);
-  }
-  for (const relationship of extracted.relations) {
-    const source = nameByLowercase.get(relationship.source.toLowerCase());
-    const target = nameByLowercase.get(relationship.target.toLowerCase());
-    if (source && target) {
-      relationships.push({
-        ...relationship,
-        source,
-        target,
-        type: normalizeGraphLabel(relationship.type, "RELATED_TO")
-      });
-    }
-  }
-  const seenRelationships = /* @__PURE__ */ new Set();
-  const dedupedRelationships = [];
-  for (const relationship of relationships) {
-    const key = relationshipKey(relationship);
-    if (seenRelationships.has(key)) continue;
-    seenRelationships.add(key);
-    dedupedRelationships.push(relationship);
-  }
-  return { entities, relationships: dedupedRelationships };
-}
-
-export {
-  normalizeGraphLabel,
-  normalizeNameKey,
-  mergeExtractedEntities
-};