@gmickel/gno 1.27.1 → 1.28.0

package/src/core/context-capsule-schema.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 import { buildUri, deriveDocid, parseUri } from "../app/constants";
 import { isValidIndexName } from "../app/index-name";
+import { RECORD_METADATA_LIMITS } from "../converters/types";
 import { contextCapsuleIndexSnapshotSchema } from "./context-capsule-index-schema";
 import { contextCapsuleRetrievalSchema } from "./context-capsule-retrieval-schema";
 import {
@@ -232,6 +233,91 @@ const guidanceSchema = z
   })
   .strict();
 
+const recordAnchorSchema = z
+  .object({
+    kind: z.enum(["line", "cue", "timestamp", "message", "event", "record"]),
+    value: nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxAnchorChars),
+    endValue: nonEmptyTextSchema
+      .max(RECORD_METADATA_LIMITS.maxAnchorChars)
+      .optional(),
+  })
+  .strict();
+
+const recordAttachmentSchema = z
+  .object({
+    name: nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxAttachmentNameChars),
+    mime: nonEmptyTextSchema
+      .max(RECORD_METADATA_LIMITS.maxAttachmentMimeChars)
+      .optional(),
+    bytes: nonNegativeIntegerSchema.optional(),
+    disposition: z.enum(["inline", "attachment"]).optional(),
+    sha256: sha256Schema.optional(),
+  })
+  .strict();
+
+const recordEvidenceMetadataSchema = z
+  .object({
+    recordKey: sha256Schema,
+    sourceLocator: nonEmptyTextSchema.max(
+      RECORD_METADATA_LIMITS.maxAnchorChars
+    ),
+    anchors: z.array(recordAnchorSchema).max(RECORD_METADATA_LIMITS.maxItems),
+    adapter: z
+      .object({
+        id: nonEmptyTextSchema.max(128),
+        version: nonEmptyTextSchema.max(64),
+        fingerprint: sha256Schema,
+      })
+      .strict(),
+    author: textSchema.max(RECORD_METADATA_LIMITS.maxPersonChars).optional(),
+    participants: z
+      .array(nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxPersonChars))
+      .max(RECORD_METADATA_LIMITS.maxItems)
+      .optional(),
+    categories: z
+      .array(nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxCategoryChars))
+      .max(RECORD_METADATA_LIMITS.maxItems)
+      .optional(),
+    dateFields: z
+      .record(
+        z.string().max(RECORD_METADATA_LIMITS.maxDateFieldKeyChars),
+        nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxDateFieldValueChars)
+      )
+      .superRefine((value, context) => {
+        if (Object.keys(value).length > RECORD_METADATA_LIMITS.maxItems) {
+          context.addIssue({
+            code: "custom",
+            message: "too many record date fields",
+          });
+        }
+      })
+      .optional(),
+    messageId: textSchema
+      .max(RECORD_METADATA_LIMITS.maxIdentifierChars)
+      .optional(),
+    inReplyTo: textSchema
+      .max(RECORD_METADATA_LIMITS.maxIdentifierChars)
+      .optional(),
+    references: z
+      .array(nonEmptyTextSchema.max(RECORD_METADATA_LIMITS.maxIdentifierChars))
+      .max(RECORD_METADATA_LIMITS.maxItems)
+      .optional(),
+    threadId: textSchema
+      .max(RECORD_METADATA_LIMITS.maxIdentifierChars)
+      .optional(),
+    eventId: textSchema
+      .max(RECORD_METADATA_LIMITS.maxIdentifierChars)
+      .optional(),
+    sessionId: textSchema
+      .max(RECORD_METADATA_LIMITS.maxIdentifierChars)
+      .optional(),
+    attachments: z
+      .array(recordAttachmentSchema)
+      .max(RECORD_METADATA_LIMITS.maxItems)
+      .optional(),
+  })
+  .strict();
+
 export const contextCapsuleEvidenceSchema = z
   .object({
     evidenceId: sha256Schema,
@@ -270,6 +356,7 @@ export const contextCapsuleEvidenceSchema = z
       "unclassified",
       "unavailable",
     ]),
+    record: recordEvidenceMetadataSchema.optional(),
   })
   .strict()
   .superRefine((value, context) => {

package/src/core/context-capsule.ts

@@ -129,6 +129,26 @@ const normalizePayload = (
           ),
         }),
     facets: normalizeSet(item.facets),
+    ...(item.record === undefined
+      ? {}
+      : {
+          record: {
+            ...item.record,
+            anchors: item.record.anchors.map((anchor) => ({
+              ...anchor,
+              value: normalizeText(anchor.value),
+              ...(anchor.endValue === undefined
+                ? {}
+                : { endValue: normalizeText(anchor.endValue) }),
+            })),
+            ...(item.record.participants === undefined
+              ? {}
+              : { participants: normalizeSet(item.record.participants) }),
+            ...(item.record.categories === undefined
+              ? {}
+              : { categories: normalizeSet(item.record.categories) }),
+          },
+        }),
   })),
   guidance: {
     ...value.guidance,

package/src/core/context-evidence.ts

@@ -21,6 +21,7 @@ import type {
   ContextRetrievalCandidate,
   ContextRetrievalRequest,
 } from "./context-compiler";
+import type { RecordEvidenceMetadata } from "./record-metadata";
 
 import { decorateUriForIndex, deriveDocid, parseUri } from "../app/constants";
 import { canonicalizeIndexName } from "../app/index-name";
@@ -35,6 +36,7 @@ import {
 } from "./context-capsule-validation";
 import { planContextEvidence } from "./context-compiler";
 import { projectContextEvidenceMetadata } from "./context-evidence-metadata";
+import { projectRecordEvidenceMetadata } from "./record-metadata";
 import {
   extractInclusiveLines,
   extractSections,
@@ -104,6 +106,7 @@ export interface ContextEvidenceValue {
   contextIds: string[];
   trust: "untrusted";
   egress: "unavailable";
+  record?: RecordEvidenceMetadata;
 }
 
 export type ContextEvidenceCompilerInput = Omit<
@@ -283,7 +286,7 @@ const referenceDocument = (
     !document.active ||
     !document.mirrorHash ||
     parsedUri?.collection !== document.collection ||
-    result.source.relPath !== document.relPath ||
+    result.source.relPath !== (document.recordSourcePath ?? document.relPath) ||
     sourceHash !== document.sourceHash ||
     mirrorHash !== document.mirrorHash ||
     deriveDocid(document.sourceHash) !== document.docid
@@ -416,6 +419,9 @@ export const materializeContextEvidenceCandidates = async (
           contextIds: [...candidate.contextIds],
           trust: "untrusted",
           egress: "unavailable",
+          ...(projectRecordEvidenceMetadata(document)
+            ? { record: projectRecordEvidenceMetadata(document) }
+            : {}),
         },
       },
     };

package/src/core/document-capabilities.ts

@@ -28,8 +28,20 @@ export function getDocumentCapabilities(input: {
   sourceExt: string;
   sourceMime: string;
   contentAvailable: boolean;
+  recordKey?: string | null;
 }): DocumentCapabilities {
   const ext = input.sourceExt.toLowerCase();
+  if (input.recordKey) {
+    return {
+      editable: false,
+      tagsEditable: true,
+      tagsWriteback: false,
+      canCreateEditableCopy: input.contentAvailable,
+      mode: "read_only",
+      reason:
+        "This document is a logical record derived from a file/export container and cannot be written back in place.",
+    };
+  }
   const editable =
     EDITABLE_EXTENSIONS.has(ext) || isTextLikeMime(input.sourceMime);
   const tagsWriteback = ext === ".md" || ext === ".markdown" || ext === ".mdx";

package/src/core/project-profile-apply-state.ts

@@ -88,6 +88,11 @@ export function applyProjectProfileDesiredState(
       : existing?.models
         ? { models: existing.models }
         : {}),
+    ...(desired.collection.recordAdapters
+      ? { recordAdapters: desired.collection.recordAdapters }
+      : existing?.recordAdapters
+        ? { recordAdapters: existing.recordAdapters }
+        : {}),
   };
   const collections = [...config.collections];
   if (existingIndex >= 0) collections[existingIndex] = nextCollection;

package/src/core/project-profile.ts

@@ -77,6 +77,7 @@ export interface ProjectProfileDesiredState {
     exclude: string[];
     languageHint?: string;
     modelPreset?: string;
+    recordAdapters?: Config["collections"][number]["recordAdapters"];
   };
   contexts: ProjectProfileContextState[];
   contentTypes: Array<{
@@ -456,6 +457,9 @@ export async function compileProjectProfileYaml(
       ...(profile.collection.modelPreset
         ? { modelPreset: profile.collection.modelPreset }
         : {}),
+      ...(profile.collection.recordAdapters
+        ? { recordAdapters: profile.collection.recordAdapters }
+        : {}),
     },
     contexts: contexts.sort((left, right) =>
       compareCodeUnits(

package/src/core/record-metadata.ts

@@ -0,0 +1,49 @@
+import type { RecordAnchor, RecordMetadata } from "../converters/types";
+
+export interface RecordEvidenceMetadata extends RecordMetadata {
+  recordKey: string;
+  sourceLocator: string;
+  anchors: RecordAnchor[];
+  adapter: {
+    id: string;
+    version: string;
+    fingerprint: string;
+  };
+}
+
+interface RecordMetadataSource {
+  recordKey?: string | null;
+  recordSourceLocator?: string | null;
+  recordMetadata?: RecordMetadata | null;
+  recordAnchors?: RecordAnchor[] | null;
+  converterId?: string | null;
+  converterVersion?: string | null;
+  recordAdapterFingerprint?: string | null;
+}
+
+/** Project only bounded, collection-relative logical-record provenance. */
+export const projectRecordEvidenceMetadata = (
+  source: RecordMetadataSource
+): RecordEvidenceMetadata | undefined => {
+  if (
+    !(
+      source.recordKey &&
+      source.recordSourceLocator &&
+      source.converterId &&
+      source.converterVersion &&
+      source.recordAdapterFingerprint
+    )
+  )
+    return undefined;
+  return {
+    recordKey: source.recordKey,
+    sourceLocator: source.recordSourceLocator,
+    anchors: source.recordAnchors ?? [],
+    adapter: {
+      id: source.converterId,
+      version: source.converterVersion,
+      fingerprint: source.recordAdapterFingerprint,
+    },
+    ...source.recordMetadata,
+  };
+};