@gmickel/gno 1.46.0 → 2.0.0

package/src/ingestion/sync.ts

@@ -14,7 +14,6 @@ import type { NormalizedContentTypeRule } from "../config";
 import type { Collection } from "../config/types";
 import type {
   ChunkInput,
-  DocEdgeInput,
   DocLinkInput,
   DocumentInput,
   DocumentRow,
@@ -49,16 +48,12 @@ import { DEFAULT_LIMITS, type RecordAdapter } from "../converters/types";
 import {
   diffDocumentStructure,
   extractDocumentStructure,
-  isRelationMap,
-  normalizeRelationEdgeType,
-  normalizeRelationTarget,
 } from "../core/change-diff";
 import { enforceCollectionEgress } from "../core/egress-enforcement";
 import {
   normalizeMarkdownPath,
   normalizeWikiName,
   parseLinks,
-  parseTargetParts,
 } from "../core/links";
 import { extractMemoryScopes } from "../core/memory-record";
 import { normalizeTag, validateTag } from "../core/tags";
@@ -68,6 +63,7 @@ import {
   parseFrontmatter,
   stripFrontmatter,
 } from "./frontmatter";
+import { projectGraph } from "./graph-reconciliation";
 import { buildLineOffsets } from "./position";
 import { processRecordContainer } from "./record-container";
 import {
@@ -104,8 +100,6 @@ const MAX_CONCURRENCY = 16;
 export const INGEST_VERSION = 6;
 const EMPTY_CONTENT_TYPE_RULES_FINGERPRINT =
   fingerprintContentTypeMetadataRules([]);
-const RELATION_EDGE_TYPE_PATTERN = /^[a-z][a-z0-9_]*$/;
-const PROJECTION_YIELD_INTERVAL = 25;
 const NON_RETRYABLE_CONVERSION_ERROR_CODES = new Set([
   "CORRUPT",
   "PERMISSION",
@@ -113,98 +107,6 @@ const NON_RETRYABLE_CONVERSION_ERROR_CODES = new Set([
   "UNSUPPORTED",
 ]);
 
-function findDocByWikiRef(
-  docs: DocumentRow[],
-  targetRef: string,
-  collection?: string
-): DocumentRow | undefined {
-  const normalized = normalizeWikiName(targetRef);
-  const candidates = collection
-    ? docs.filter((doc) => doc.collection === collection)
-    : docs;
-
-  return candidates.find((doc) => {
-    const title = doc.title ?? doc.relPath.split("/").pop() ?? doc.relPath;
-    const relStem = doc.relPath.replace(/\.[^/.]+$/, "");
-    return (
-      normalizeWikiName(title) === normalized ||
-      normalizeWikiName(doc.relPath) === normalized ||
-      normalizeWikiName(relStem) === normalized
-    );
-  });
-}
-
-function resolveRelationTarget(
-  docs: DocumentRow[],
-  sourceDoc: DocumentRow,
-  rawTarget: string
-): DocumentRow | undefined {
-  const target = normalizeRelationTarget(rawTarget);
-  if (!target) {
-    return undefined;
-  }
-
-  if (target.startsWith("#")) {
-    return docs.find((doc) => doc.docid === target);
-  }
-
-  if (target.startsWith("gno://")) {
-    return docs.find((doc) => doc.uri === target);
-  }
-
-  const parts = parseTargetParts(target);
-  const targetCollection = parts.collection;
-  const targetRef = parts.ref;
-  if (!targetRef) {
-    return undefined;
-  }
-
-  if (targetCollection) {
-    const exact = docs.find(
-      (doc) => doc.collection === targetCollection && doc.relPath === targetRef
-    );
-    return exact ?? findDocByWikiRef(docs, targetRef, targetCollection);
-  }
-
-  const sameCollectionPath = normalizeMarkdownPath(
-    targetRef,
-    sourceDoc.relPath
-  );
-  if (sameCollectionPath) {
-    const exact = docs.find(
-      (doc) =>
-        doc.collection === sourceDoc.collection &&
-        doc.relPath === sameCollectionPath
-    );
-    if (exact) {
-      return exact;
-    }
-  }
-
-  const explicitCollPath = docs.find(
-    (doc) => `${doc.collection}/${doc.relPath}` === targetRef
-  );
-  if (explicitCollPath) {
-    return explicitCollPath;
-  }
-
-  return (
-    findDocByWikiRef(docs, targetRef, sourceDoc.collection) ??
-    findDocByWikiRef(docs, targetRef)
-  );
-}
-
-function getPrimaryGraphHint(
-  contentType: string | null | undefined,
-  rules: NormalizedContentTypeRule[]
-): string | undefined {
-  if (!contentType) {
-    return undefined;
-  }
-  const rule = rules.find((candidate) => candidate.id === contentType);
-  return rule?.graphHints?.[0];
-}
-
 /**
  * Decide whether to process a file or skip it.
  * Handles repair cases where sourceHash matches but content is incomplete.
@@ -219,6 +121,11 @@ function decideAction(
   if (!existing) {
     return { kind: "process", reason: "new file" };
   }
+  // Identical bytes can reappear after deletion; restore through the normal
+  // conversion/upsert path so identity, derived data and journal agree.
+  if (!existing.active) {
+    return { kind: "repair", reason: "source restored" };
+  }
 
   // Source hash changed - must process
   if (existing.sourceHash !== sourceHash) {
@@ -1784,182 +1691,12 @@ export class SyncService {
     return null;
   }
 
-  private async projectTypedEdges(
+  private projectTypedEdges(
     store: StorePort,
     options: SyncOptions,
     sourceDocumentIds?: Set<number>
   ): Promise<Array<{ relPath: string; code: string; message: string }>> {
-    const errors: Array<{ relPath: string; code: string; message: string }> =
-      [];
-
-    const selectedSourceIds = sourceDocumentIds
-      ? [...sourceDocumentIds]
-      : undefined;
-    const backfillResult = await store.backfillDocEdges(selectedSourceIds);
-    if (!backfillResult.ok) {
-      return [
-        {
-          relPath: "(typed edge backfill)",
-          code: backfillResult.error.code,
-          message: backfillResult.error.message,
-        },
-      ];
-    }
-
-    const docsResult = await store.listDocuments();
-    if (!docsResult.ok) {
-      return [
-        {
-          relPath: "(typed edge projection)",
-          code: docsResult.error.code,
-          message: docsResult.error.message,
-        },
-      ];
-    }
-
-    const activeDocs = docsResult.value.filter((doc) => doc.active);
-    const activeIds = new Set(activeDocs.map((doc) => doc.id));
-    if (selectedSourceIds) {
-      for (const documentId of selectedSourceIds) {
-        if (!activeIds.has(documentId)) {
-          // Clear typed edges for inactivated projection sources.
-          const clearResult = await store.setDocEdges(
-            documentId,
-            [],
-            "frontmatter-relation"
-          );
-          if (!clearResult.ok) {
-            errors.push({
-              relPath: `(doc:${documentId})`,
-              code: clearResult.error.code,
-              message: clearResult.error.message,
-            });
-          }
-        }
-      }
-    }
-    const projectedDocs = sourceDocumentIds
-      ? activeDocs.filter((doc) => sourceDocumentIds.has(doc.id))
-      : activeDocs;
-
-    for (const [docIndex, doc] of projectedDocs.entries()) {
-      if (docIndex > 0 && docIndex % PROJECTION_YIELD_INTERVAL === 0) {
-        await Bun.sleep(0);
-      }
-      if (!doc.mirrorHash) {
-        continue;
-      }
-
-      const contentResult = await store.getContent(doc.mirrorHash);
-      if (!contentResult.ok || contentResult.value === null) {
-        continue;
-      }
-
-      const relationsValue = parseFrontmatter(contentResult.value).metadata
-        .relations;
-      const relationEdges: DocEdgeInput[] = [];
-
-      if (isRelationMap(relationsValue)) {
-        for (const [rawEdgeType, targets] of Object.entries(relationsValue)) {
-          const edgeType = normalizeRelationEdgeType(rawEdgeType);
-          if (!RELATION_EDGE_TYPE_PATTERN.test(edgeType)) {
-            continue;
-          }
-          for (const target of targets) {
-            const targetDoc = resolveRelationTarget(activeDocs, doc, target);
-            if (targetDoc) {
-              relationEdges.push({
-                targetDocId: targetDoc.id,
-                edgeType,
-                confidence: "manual",
-              });
-            }
-          }
-        }
-      }
-      const relationTargetIds = new Set(
-        relationEdges.map((edge) => edge.targetDocId)
-      );
-
-      const relationsResult = await store.setDocEdges(
-        doc.id,
-        relationEdges,
-        "frontmatter-relation"
-      );
-      if (!relationsResult.ok) {
-        errors.push({
-          relPath: doc.relPath,
-          code: relationsResult.error.code,
-          message: relationsResult.error.message,
-        });
-      }
-
-      const primaryHint = getPrimaryGraphHint(
-        doc.contentType,
-        options.contentTypeRules ?? []
-      );
-      if (!primaryHint || !RELATION_EDGE_TYPE_PATTERN.test(primaryHint)) {
-        continue;
-      }
-
-      const linksResult = await store.getLinksForDoc(doc.id);
-      if (!linksResult.ok) {
-        errors.push({
-          relPath: doc.relPath,
-          code: linksResult.error.code,
-          message: linksResult.error.message,
-        });
-        continue;
-      }
-
-      const wikiEdges: DocEdgeInput[] = [];
-      const markdownEdges: DocEdgeInput[] = [];
-      for (const link of linksResult.value) {
-        const targetRef =
-          link.linkType === "markdown"
-            ? `${doc.collection}/${link.targetRefNorm}`
-            : link.targetCollection
-              ? `${link.targetCollection}:${link.targetRef}`
-              : link.targetRefNorm;
-        const targetDoc = resolveRelationTarget(activeDocs, doc, targetRef);
-        if (!targetDoc || relationTargetIds.has(targetDoc.id)) {
-          continue;
-        }
-        const edge = {
-          targetDocId: targetDoc.id,
-          edgeType: primaryHint,
-          confidence: "configured" as const,
-        };
-        if (link.linkType === "wiki") {
-          wikiEdges.push(edge);
-        } else {
-          markdownEdges.push(edge);
-        }
-      }
-
-      const wikiResult = await store.setDocEdges(doc.id, wikiEdges, "wikilink");
-      if (!wikiResult.ok) {
-        errors.push({
-          relPath: doc.relPath,
-          code: wikiResult.error.code,
-          message: wikiResult.error.message,
-        });
-      }
-      const markdownResult = await store.setDocEdges(
-        doc.id,
-        markdownEdges,
-        "markdown-link"
-      );
-      if (!markdownResult.ok) {
-        errors.push({
-          relPath: doc.relPath,
-          code: markdownResult.error.code,
-          message: markdownResult.error.message,
-        });
-      }
-    }
-
-    return errors;
+    return projectGraph(store, options, sourceDocumentIds);
   }
 
   /** Run an exact global typed-edge reconciliation with cooperative yields. */
@@ -1967,7 +1704,7 @@ export class SyncService {
     store: StorePort,
     options: SyncOptions = {}
   ): Promise<Array<{ relPath: string; code: string; message: string }>> {
-    return this.projectTypedEdges(store, options);
+    return projectGraph(store, options, undefined, true);
   }
 
   /**

package/src/llm/http-inference.ts

@@ -21,6 +21,8 @@ import { classifyHttpDestination, prepareHttpDestination } from "./http-policy";
 const REDIRECT_STATUSES = new Set([301, 302, 307, 308]);
 
 export interface HttpInferenceOptions {
+  /** Resolved models.inferenceTimeout; measured across the complete HTTP call. */
+  inferenceTimeout?: number;
   collections: readonly Collection[];
   collectionNames: readonly string[];
   authenticated?: boolean;
@@ -64,6 +66,7 @@ export const requestHttpInference = async (
   init: BunFetchRequestInit,
   options: HttpInferenceOptions
 ): Promise<Response> => {
+  init.signal?.throwIfAborted();
   const states = scopedStates(options);
   if (states.length === 0) {
     enforce(states, "remote", options);
@@ -118,6 +121,7 @@ export const requestHttpInference = async (
 
   let currentUrl = url;
   for (;;) {
+    init.signal?.throwIfAborted();
     enforce(states, prepared.value.classification.zone, options);
     const connection = await prepared.value.acquireConnection();
     if (!connection.ok) {
@@ -134,7 +138,9 @@ export const requestHttpInference = async (
         })
       );
     }
+    init.signal?.throwIfAborted();
     const response = await connection.value.request(init, options.fetchFn);
+    init.signal?.throwIfAborted();
     if (!REDIRECT_STATUSES.has(response.status)) return response;
 
     const location = response.headers.get("location");

package/src/llm/httpEmbedding.ts

@@ -1,16 +1,17 @@
+import type { HttpInferenceOptions } from "./http-inference";
+import type { InferenceOptions } from "./types";
 /**
  * HTTP-based embedding port implementation.
  * Calls OpenAI-compatible embedding endpoints.
  *
  * @module src/llm/httpEmbedding
  */
-
-import type { HttpInferenceOptions } from "./http-inference";
 import type { EmbeddingPort, LlmResult } from "./types";
 
 import { EgressDeniedError } from "../core/egress-enforcement";
 import { egressDeniedInferenceError, inferenceFailedError } from "./errors";
 import { requestHttpInference } from "./http-inference";
+import { runHttpInference } from "./inference-scope";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -58,20 +59,35 @@ export class HttpEmbedding implements EmbeddingPort {
     }
   }
 
-  async init(): Promise<LlmResult<void>> {
+  async init(options?: InferenceOptions): Promise<LlmResult<void>> {
     // Test connection with a simple embedding
-    const result = await this.embed("test");
+    const result = await this.embed("test", options);
     if (!result.ok) {
       return result;
     }
     return { ok: true, value: undefined };
   }
 
-  async embed(text: string): Promise<LlmResult<number[]>> {
+  async embed(
+    text: string,
+    options?: InferenceOptions
+  ): Promise<LlmResult<number[]>> {
+    return runHttpInference(
+      options,
+      (operational) => this.embedRequest(text, operational),
+      this.requestOptions.inferenceTimeout
+    );
+  }
+
+  private async embedRequest(
+    text: string,
+    options: InferenceOptions
+  ): Promise<LlmResult<number[]>> {
     try {
       const response = await requestHttpInference(
         this.apiUrl,
         {
+          signal: options.signal,
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -128,11 +144,26 @@ export class HttpEmbedding implements EmbeddingPort {
     }
   }
 
-  async embedBatch(texts: string[]): Promise<LlmResult<number[][]>> {
+  async embedBatch(
+    texts: string[],
+    options?: InferenceOptions
+  ): Promise<LlmResult<number[][]>> {
+    return runHttpInference(
+      options,
+      (operational) => this.embedBatchRequest(texts, operational),
+      this.requestOptions.inferenceTimeout
+    );
+  }
+
+  private async embedBatchRequest(
+    texts: string[],
+    options: InferenceOptions
+  ): Promise<LlmResult<number[][]>> {
     try {
       const response = await requestHttpInference(
         this.apiUrl,
         {
+          signal: options.signal,
           method: "POST",
           headers: {
             "Content-Type": "application/json",

package/src/llm/httpGeneration.ts

@@ -1,11 +1,11 @@
+import type { HttpInferenceOptions } from "./http-inference";
+import type { InferenceOptions } from "./types";
 /**
  * HTTP-based generation port implementation.
  * Calls OpenAI-compatible chat completion endpoints.
  *
  * @module src/llm/httpGeneration
  */
-
-import type { HttpInferenceOptions } from "./http-inference";
 import type { GenerationPort, GenParams, LlmResult } from "./types";
 
 import { EgressDeniedError } from "../core/egress-enforcement";
@@ -15,6 +15,7 @@ import {
   structuredOutputUnavailableError,
 } from "./errors";
 import { requestHttpInference } from "./http-inference";
+import { runHttpInference } from "./inference-scope";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -71,7 +72,20 @@ export class HttpGeneration implements GenerationPort {
 
   async generate(
     prompt: string,
-    params?: GenParams
+    params?: GenParams,
+    options?: InferenceOptions
+  ): Promise<LlmResult<string>> {
+    return runHttpInference(
+      options,
+      (operational) => this.generateRequest(prompt, params, operational),
+      this.requestOptions.inferenceTimeout
+    );
+  }
+
+  private async generateRequest(
+    prompt: string,
+    params: GenParams | undefined,
+    options: InferenceOptions
   ): Promise<LlmResult<string>> {
     if (params?.jsonSchema) {
       return {
@@ -83,6 +97,7 @@ export class HttpGeneration implements GenerationPort {
       const response = await requestHttpInference(
         this.apiUrl,
         {
+          signal: options.signal,
           method: "POST",
           headers: {
             "Content-Type": "application/json",

package/src/llm/httpRerank.ts

@@ -1,16 +1,17 @@
+import type { HttpInferenceOptions } from "./http-inference";
+import type { InferenceOptions } from "./types";
 /**
  * HTTP-based rerank port implementation.
  * Calls OpenAI-compatible completions endpoints for reranking.
  *
  * @module src/llm/httpRerank
  */
-
-import type { HttpInferenceOptions } from "./http-inference";
 import type { LlmResult, RerankPort, RerankScore } from "./types";
 
 import { EgressDeniedError } from "../core/egress-enforcement";
 import { egressDeniedInferenceError, inferenceFailedError } from "./errors";
 import { requestHttpInference } from "./http-inference";
+import { runHttpInference } from "./inference-scope";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -63,7 +64,20 @@ export class HttpRerank implements RerankPort {
 
   async rerank(
     query: string,
-    documents: string[]
+    documents: string[],
+    options?: InferenceOptions
+  ): Promise<LlmResult<RerankScore[]>> {
+    return runHttpInference(
+      options,
+      (operational) => this.rerankRequest(query, documents, operational),
+      this.requestOptions.inferenceTimeout
+    );
+  }
+
+  private async rerankRequest(
+    query: string,
+    documents: string[],
+    options: InferenceOptions
   ): Promise<LlmResult<RerankScore[]>> {
     if (documents.length === 0) {
       return { ok: true, value: [] };
@@ -74,7 +88,7 @@ export class HttpRerank implements RerankPort {
       const prompts = documents.map((doc) => this.buildPrompt(query, doc));
 
       // Score all documents in a single batch request
-      const scoresResult = await this.scoreBatch(prompts);
+      const scoresResult = await this.scoreBatch(prompts, options);
 
       if (!scoresResult.ok) {
         return { ok: false, error: scoresResult.error };
@@ -112,11 +126,15 @@ export class HttpRerank implements RerankPort {
     return `<Instruct>: ${this.instruction}\n<Query>: ${query}\n<Document>: ${document}\n<Score>:`;
   }
 
-  private async scoreBatch(prompts: string[]): Promise<LlmResult<number[]>> {
+  private async scoreBatch(
+    prompts: string[],
+    options: InferenceOptions
+  ): Promise<LlmResult<number[]>> {
     try {
       const response = await requestHttpInference(
         this.apiUrl,
         {
+          signal: options.signal,
           method: "POST",
           headers: {
             "Content-Type": "application/json",