@remnic/core 9.69.56 → 9.69.58

package/dist/orchestration/persistence-index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Persistence-index coordinator — extracted from the orchestrator
+ * (issue #1526, seam 23).
+ *
+ * Owns the post-persist bookkeeping that extraction-persist and
+ * consolidation delegate back through the orchestrator:
+ *   - content-hash dedup index add/has/remove/save
+ *   - temporal-bounds backfill on dedup hits (bitemporal, #1578)
+ *   - temporal tag index updates and persisted-memory indexing
+ *   - recognition-index write-path maintenance when recallRecognitionTier is on
+ *   - graph edge construction for newly persisted memories
+ *   - semantic dedup candidate lookup
+ *
+ * Behavior-preserving move from orchestrator.ts (late-binding deps rule,
+ * seams 18–22).
+ */
+import { type GraphConstructionCapabilitySet } from "../capabilities.js";
+import type { SemanticDedupHit } from "../dedup/semantic.js";
+import { EmbeddingFallback } from "../embedding-fallback.js";
+import { GraphIndex, type GraphEdge } from "../graph.js";
+import { ContentHashIndex, StorageManager } from "../index.js";
+import type { MemoryFile, PluginConfig } from "../types.js";
+export interface PersistenceIndexDeps {
+    readonly config: PluginConfig;
+    readonly contentHashIndex: ContentHashIndex | null;
+    contentHashIndexForStorage(targetStorage: StorageManager): Promise<ContentHashIndex | null>;
+    readonly contentHashIndexesByStorageDir: Map<string, ContentHashIndex>;
+    readonly embeddingFallback: EmbeddingFallback;
+    graphIndexFor(storage: StorageManager): GraphIndex;
+    readAllMemoriesForNamespaces(namespaces: string[]): Promise<MemoryFile[]>;
+    semanticDedupScopeFor(targetStorage: StorageManager): {
+        pathPrefix?: string;
+        pathExcludePrefixes?: readonly string[];
+    };
+}
+export declare class PersistenceIndexCoordinator {
+    private readonly deps;
+    constructor(deps: PersistenceIndexDeps);
+    hasContentHashDedup(targetStorage: StorageManager, content: string): Promise<boolean>;
+    addContentHashDedup(targetStorage: StorageManager, content: string): Promise<void>;
+    removeContentHashForMemory(targetStorage: StorageManager, memory: MemoryFile, context: string): Promise<void>;
+    /**
+     * Issue #1671 — backfill bi-temporal bounds onto an existing promoted/deduped
+     * copy that was written BEFORE the source fact carried a resolved
+     * `invalid_at`/`observedAt`/`eventTimeSource`.
+     *
+     * On re-extraction/backfill, a fact may now carry a resolved end bound (e.g.
+     * "until June 2025") that the existing copy lacks because it was promoted
+     * before bi-temporal wiring existed. Without this backfill, recall keeps
+     * surfacing an expired fact even though the source copy now expires correctly.
+     *
+     * Finds the active fact in `targetStorage` matching `dedupContent`, then
+     * patches the temporal frontmatter the existing copy is missing. Best-effort
+     * / fail-open — any I/O error is logged and swallowed so the dedup
+     * short-circuit is never blocked by a backfill failure.
+     *
+     * Matching: the stored `frontmatter.contentHash` is compared against
+     * `ContentHashIndex.computeHash(dedupContent)` first (the exact hash the
+     * content-hash index uses), then falls back to stripping citations and
+     * comparing normalized bodies. This handles inline-attribution deployments
+     * where the persisted body carries a citation marker the dedup key does not.
+     *
+     * I/O gate: only triggers when `invalidAt` is present (the end bound that
+     * actually changes recall behavior by expiring the fact). `observedAt` and
+     * `eventTimeSource` alone don'\''t expire a fact, so backfilling them without
+     * an end bound would cause a full readAllMemories scan on every dedup hit
+     * under biTemporal for no recall benefit.
+     *
+     * Only patches fields the existing copy LACKS — never overwrites a bound the
+     * copy already carries.
+     */
+    backfillTemporalBoundsOnDedupHit(targetStorage: StorageManager, dedupContent: string, bounds: {
+        invalidAt?: string;
+        validFrom?: string;
+        observedAt?: string;
+        eventTimeSource?: "extracted" | "assumed";
+    }, entityRef?: string, sourceConnector?: string): Promise<void>;
+    /**
+     * Persist the touched content-hash indexes via the removal-aware, lock-held
+     * RECONCILING save (issue #1909 review round 8 thread 3). Both append batches
+     * (extraction persist) and removal batches (archival / semantic consolidation)
+     * go through the SAME operation so they serialize against each other on the
+     * per-file lock: each reconciles `(on-disk \ removed) ∪ additions`, so a
+     * removal never resurrects a hash (a plain union would) and never clobbers a
+     * concurrent extraction's appended hash (a blind overwrite would). Untouched
+     * indexes dirty-short-circuit and are skipped entirely (finding 3).
+     */
+    saveContentHashIndexes(): Promise<void>;
+    /**
+     * Drive any deferred lock-timeout reconcile-save retries to completion at a
+     * lifecycle boundary (PR #2016 finding 3). Each per-index background retry is
+     * `unref`'d so it never keeps a long-lived host alive; a short-lived writer (a
+     * one-shot CLI) can exit before it fires, leaving a durable fact `.md` whose
+     * hash never reached disk for peers. `orchestrator.destroy()` calls this so the
+     * addition publishes before the process exits. Long-lived hosts only reach it
+     * at their own shutdown, so their in-flight retries keep running in the
+     * background until then. Best-effort: `flushReconcileRetry` is a no-op on a
+     * clean index and a permanently contended lock falls back to the
+     * corpus-rebuild-on-restart safety net.
+     */
+    drainContentHashReconcileRetries(): Promise<void>;
+    indexPersistedMemory(storage: StorageManager, memoryId: string): Promise<void>;
+    /**
+     * Build a graph edge for a persisted memory (v8.2).
+     * Shared helper used by both the chunked and non-chunked write paths to avoid duplication.
+     * Fail-open: caller wraps in try/catch.
+     */
+    buildGraphEdge(storage: StorageManager, memoryRelPath: string, entityRef: string | undefined, memoryId: string, factContent: string, allMemsForGraph: import("../types.js").MemoryFile[] | null | undefined, memoryPathById: Map<string, string>, threadIdForEdge: string | undefined, threadEpisodeIdsForGraph: string[] | undefined, fallbackCausalPredecessor: string | undefined, graphCaps?: GraphConstructionCapabilitySet): Promise<GraphEdge[]>;
+    /**
+     * Batch-update temporal and tag indexes after extraction (v8.1).
+     * Reads each persisted memory's path + frontmatter and adds them to
+     * state/index_time.json and state/index_tags.json.
+     * Fail-open: any error is logged but does not abort extraction.
+     */
+    updateTemporalTagIndexes(storage: StorageManager, persistedIds: string[]): Promise<void>;
+    /**
+     * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
+     * guard. Returns the top-K embedding hits against the currently indexed
+     * memories, or an empty array when the embedding backend is unavailable.
+     * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
+     * and "error" outcomes as fail-open (keep the candidate).
+     *
+     * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
+     * to the SAME namespace as the fact being written. Otherwise a
+     * high-similarity memory from another namespace can suppress a write in
+     * the target namespace — cross-tenant data loss. Callers pass the target
+     * storage so we can translate its root directory into the correct index
+     * path prefix (and, for the legacy default-namespace layout at
+     * `memoryDir` root, an exclusion list for `namespaces/*`).
+     */
+    semanticDedupLookup(content: string, limit: number, targetStorage: StorageManager): Promise<SemanticDedupHit[]>;
+    /**
+     * Upsert persisted memories into the namespace recognition index.
+     * `recallRecognitionTier !== true` returns before any index I/O.
+     * A missing index is bootstrapped from the active corpus so the first
+     * post-enable write cannot publish a partial index that recall would
+     * treat as the full working set.
+     */
+    private maintainRecognitionIndex;
+}
+//# sourceMappingURL=persistence-index.d.ts.map

package/dist/orchestration/persistence-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-index.d.ts","sourceRoot":"","sources":["../../src/orchestration/persistence-index.ts"],"names":[],"mappings":"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"}

package/dist/orchestration/projection-rebuild-schedule.d.ts

@@ -0,0 +1,21 @@
+import type { PluginConfig } from "../types.js";
+import { type RebuildMemoryProjectionOptions } from "../maintenance/rebuild-memory-projection.js";
+type InjectedStorage = NonNullable<RebuildMemoryProjectionOptions["storage"]>;
+export interface ProjectionRebuildScheduleState {
+    inFlight: boolean;
+    lastRebuildAtMs: number;
+    /** Timestamp of the most recent FAILURE; gates a short retry backoff that is
+     * separate from the success interval so a transient cause (e.g. a locked
+     * secure store) retries promptly once cleared instead of waiting a full
+     * interval. */
+    lastFailureAtMs: number;
+}
+export declare function createProjectionRebuildScheduleState(): ProjectionRebuildScheduleState;
+export declare function maybeRebuildMemoryProjectionScheduled(opts: {
+    config: PluginConfig;
+    /** The daemon's live root storage, when available (secure-store unlock). */
+    getStorage?: () => InjectedStorage | undefined;
+    state: ProjectionRebuildScheduleState;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=projection-rebuild-schedule.d.ts.map

package/dist/orchestration/projection-rebuild-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-rebuild-schedule.d.ts","sourceRoot":"","sources":["../../src/orchestration/projection-rebuild-schedule.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,6CAA6C,CAAC;AAGrD,KAAK,eAAe,GAAG,WAAW,CAAC,8BAA8B,CAAC,SAAS,CAAC,CAAC,CAAC;AAE9E,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB;;;mBAGe;IACf,eAAe,EAAE,MAAM,CAAC;CACzB;AAOD,wBAAgB,oCAAoC,IAAI,8BAA8B,CAErF;AAED,wBAAsB,qCAAqC,CAAC,IAAI,EAAE;IAChE,MAAM,EAAE,YAAY,CAAC;IACrB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,eAAe,GAAG,SAAS,CAAC;IAC/C,KAAK,EAAE,8BAA8B,CAAC;CACvC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqDhB"}

package/dist/orchestration/qmd-result-resolver.d.ts

@@ -0,0 +1,75 @@
+/**
+ * QMD result resolver — extracted from the orchestrator (issue #1526 seam 11).
+ *
+ * Owns the subsystem that resolves a QMD search-result path back to the
+ * concrete `MemoryFile` (and its owning namespace/storage). Three concerns
+ * live here:
+ *
+ *   - `readQmdResultMemory` — resolve a result path to a `MemoryFile`,
+ *     handling cold-tier collections, namespace-prefixed collections, and
+ *     absolute vs relative paths.
+ *   - `resolveColdQmdResultForRecall` — wrap a result with its owner
+ *     namespace so the recall pipeline can scope-filter candidates.
+ *   - `storageForAbsoluteQmdResultPath` — find the `StorageManager` whose
+ *     directory tree contains an absolute result path.
+ *
+ * Behavior-preserving move from orchestrator.ts — no logic changes. The
+ * orchestrator constructs one instance and keeps thin delegating methods so
+ * existing call sites (recallInternal, applyColdFallbackPipeline,
+ * loadSearchResultMemoryMap, suggestLinksForMemory, and the
+ * RecallRerankCoordinator callback) continue to work.
+ *
+ * Config, the storage router, and the orchestrator's namespace-resolution
+ * helpers are accessed through getter callbacks (not captured at
+ * construction) so that post-construction reassignment of the
+ * orchestrator's live fields is honored. This mirrors the
+ * RecallRerankCoordinator / ConversationIndexCoordinator accessor pattern.
+ */
+import type { StorageManager } from "../index.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "../types.js";
+/**
+ * Split a relative QMD result path into its collection prefix and the
+ * remainder. Returns `null` for absolute paths, date-only prefixes, or
+ * paths with no collection separator.
+ */
+export declare function qmdCollectionPathParts(resultPath: string): {
+    collection: string;
+    relativePath: string;
+} | null;
+/**
+ * Build the set of on-disk candidate paths to probe for a QMD result,
+ * constrained to the storage root so a result path can never escape the
+ * namespace directory.
+ */
+export declare function qmdResultPathCandidates(storageDir: string, resultPath: string): string[];
+/**
+ * Coordinator for resolving QMD search-result paths to concrete memory
+ * files and their owning namespace/storage.
+ */
+export declare class QmdResultResolver {
+    private readonly getConfig;
+    private readonly storageFor;
+    private readonly storageDirNamespace;
+    private readonly qmdCollectionNamespaceFromPrefix;
+    private readonly namespaceFromPath;
+    constructor(options: {
+        getConfig: () => PluginConfig;
+        storageFor: (namespace: string) => Promise<StorageManager>;
+        storageDirNamespace: (storageDir: string) => string;
+        qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
+        namespaceFromPath: (p: string) => string;
+    });
+    readQmdResultMemory(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[], preferredNamespace?: string): Promise<MemoryFile | null>;
+    filterPrivateSearchResults(results: QmdSearchResult[], fallbackStorage: StorageManager, namespaces?: readonly string[], preserveUnresolved?: boolean, visibilityCache?: Map<string, boolean>): Promise<QmdSearchResult[]>;
+    private isVisibleSearchResult;
+    resolveColdQmdResultForRecall(result: QmdSearchResult, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
+        namespace: string;
+        result: QmdSearchResult;
+    } | null>;
+    storageForAbsoluteQmdResultPath(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
+        storage: StorageManager;
+        dir: string;
+        namespace: string;
+    } | null>;
+}
+//# sourceMappingURL=qmd-result-resolver.d.ts.map

package/dist/orchestration/qmd-result-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qmd-result-resolver.d.ts","sourceRoot":"","sources":["../../src/orchestration/qmd-result-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAOlD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAyB7E;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAuBP;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAoCxF;AAcD;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiD;IAC5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAiC;IACrE,OAAO,CAAC,QAAQ,CAAC,gCAAgC,CAA8C;IAC/F,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;gBAE9C,OAAO,EAAE;QACnB,SAAS,EAAE,MAAM,YAAY,CAAC;QAC9B,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;QAC3D,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;QACpD,gCAAgC,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;QAC9E,iBAAiB,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;KAC1C;IAQK,mBAAmB,CACvB,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,cAAc,EAC/B,gBAAgB,GAAE,SAAS,MAAM,EAAO,EACxC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA0IvB,0BAA0B,CAC9B,OAAO,EAAE,eAAe,EAAE,EAC1B,eAAe,EAAE,cAAc,EAC/B,UAAU,GAAE,SAAS,MAAM,EAAO,EAClC,kBAAkB,UAAQ,EAC1B,eAAe,uBAA6B,GAC3C,OAAO,CAAC,eAAe,EAAE,CAAC;YA0Bf,qBAAqB;IAsC7B,6BAA6B,CACjC,MAAM,EAAE,eAAe,EACvB,eAAe,EAAE,cAAc,EAC/B,gBAAgB,GAAE,SAAS,MAAM,EAAO,GACvC,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,GAAG,IAAI,CAAC;IA2B3D,+BAA+B,CACnC,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,cAAc,EAC/B,gBAAgB,GAAE,SAAS,MAAM,EAAO,GACvC,OAAO,CAAC;QAAE,OAAO,EAAE,cAAc,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAqD/E"}

package/dist/orchestration/recall-background-writes.d.ts

@@ -0,0 +1,3 @@
+export declare function trackRecallWrite(owner: object, promise: Promise<void>, label: string): void;
+export declare function drainRecallWrites(owner: object): Promise<void>;
+//# sourceMappingURL=recall-background-writes.d.ts.map

package/dist/orchestration/recall-background-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall-background-writes.d.ts","sourceRoot":"","sources":["../../src/orchestration/recall-background-writes.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAW3F;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMpE"}

package/dist/orchestration/recall-entry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Recall-entry coordinator — extracted from the orchestrator
+ * (issue #1526, seam 28).
+ *
+ * Owns the public recall() entry surface: the init gate + timeout
+ * fallback around recallInternal, recall failure logging/suppression,
+ * recall result publication, and eval shadow-recall queueing.
+ *
+ * Behavior-preserving move (late-binding selfDeps wiring, seams 18–27).
+ */
+import { type CapabilitySet, type GraphConstructionCapabilitySet, type MemoryLifecycleCapabilitySet } from "../capabilities.js";
+import { type EvalShadowRecallRecord } from "../evals.js";
+import { StorageManager } from "../index.js";
+import { type RecallSectionAppendOptions, type RecallSectionBuckets } from "./recall-section-coordinator.js";
+import { type RecallInvocationOptions } from "./orchestrator-helpers.js";
+import { ProfilingCollector } from "../profiling.js";
+import { type TrustStageResultItem } from "../trust-score-stage.js";
+import type { RecallResultFormatter } from "./recall-result-formatter.js";
+import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../types.js";
+export interface RecallEntryDeps {
+    appendRecallSection(sectionBuckets: RecallSectionBuckets, sectionId: string, content: string, options?: RecallSectionAppendOptions): boolean;
+    readonly config: PluginConfig;
+    enqueueDirectAnswerObservation(prompt: string, sessionKey: string, namespaceOverride: string | undefined, principalOverride: string | undefined, caps: CapabilitySet, namespacesEnabled: boolean): void;
+    evalShadowWriteChain: Promise<void>;
+    extractMemoryIdsFromResults(results: QmdSearchResult[]): string[];
+    recallResultFormatter: RecallResultFormatter;
+    readonly initPromise: Promise<void> | null;
+    lastRecallFailureAtMs: number;
+    lastRecallFailureLogAtMs: number;
+    logRecallFailure(err: unknown): void;
+    readonly profiler: ProfilingCollector;
+    recallInternal(prompt: string, sessionKey?: string, options?: RecallInvocationOptions, caps?: CapabilitySet, graphCaps?: GraphConstructionCapabilitySet, lifecycleCaps?: MemoryLifecycleCapabilitySet): Promise<string>;
+    readonly storage: StorageManager;
+    suppressedRecallFailures: number;
+    trackRecallBackgroundWrite(promise: Promise<void>, label: string): void;
+}
+export declare class RecallEntryCoordinator {
+    private readonly deps;
+    constructor(deps: RecallEntryDeps);
+    recall(prompt: string, sessionKey?: string, options?: RecallInvocationOptions): Promise<string>;
+    logRecallFailure(err: unknown): void;
+    queueEvalShadowRecall(record: Omit<EvalShadowRecallRecord, "schemaVersion">): void;
+    publishRecallResults(options: {
+        title: string;
+        results: QmdSearchResult[];
+        sectionBuckets: RecallSectionBuckets;
+        retrievalQuery: string;
+        sessionKey: string | undefined;
+        identityInjection?: {
+            mode: IdentityInjectionMode | "none";
+            injectedChars: number;
+            truncated: boolean;
+        };
+        /**
+         * Issue #1577 — per-recall trust map. When present, quarantined items
+         * are filtered from injection on EVERY recall path (hot QMD, embedding
+         * fallback, cold archive, recent) so a faithfulness-contradicted memory
+         * cannot sneak in via a branch that bypasses trust scoring. The map is
+         * also threaded to formatQmdResultEntries for the epistemic hedge.
+         */
+        trustByPath?: Map<string, TrustStageResultItem> | null;
+        /**
+         * #1952 — per-request effective state-view flag (per-call `stateView`
+         * OR `recallStateViews` config, gated on change intent), computed once
+         * in recallInternal and threaded here. The inject seam uses this flag
+         * instead of rereading live config so a per-call `stateView: true`
+         * still labels/widens when the global flag is false.
+         */
+        stateViewActive?: boolean;
+        /**
+         * #1952 — historical recall pin (epoch ms) for this call. Under a
+         * pin, annotation must not discard a predecessor whose successor is
+         * absent due to the asOf validity filter; see applyRecallStateViews.
+         */
+        asOfMs?: number;
+    }): void;
+}
+//# sourceMappingURL=recall-entry.d.ts.map

package/dist/orchestration/recall-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall-entry.d.ts","sourceRoot":"","sources":["../../src/orchestration/recall-entry.ts"],"names":[],"mappings":"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"}