@gmickel/gno 2.13.0 → 2.14.0

package/src/core/egress-provenance.ts

@@ -33,10 +33,16 @@ const POLICY_RESTRICTIVENESS: Readonly<Record<EgressPolicy, number>> = {
 };
 
 export class EgressProvenanceError extends Error {
-  readonly code: "EMPTY_EGRESS_LINEAGE" | "INVALID_EGRESS_LINEAGE";
+  readonly code:
+    | "EMPTY_EGRESS_LINEAGE"
+    | "INVALID_EGRESS_LINEAGE"
+    | "EGRESS_SCOPE_LIMIT_EXCEEDED";
 
   constructor(
-    code: "EMPTY_EGRESS_LINEAGE" | "INVALID_EGRESS_LINEAGE",
+    code:
+      | "EMPTY_EGRESS_LINEAGE"
+      | "INVALID_EGRESS_LINEAGE"
+      | "EGRESS_SCOPE_LIMIT_EXCEEDED",
     message: string
   ) {
     super(message);
@@ -71,13 +77,24 @@ const invalidLineageInput = (): EgressProvenanceError =>
     `Source policy lineage must be a readable dense array with at most ${MAX_EGRESS_LINEAGE_SOURCES} entries`
   );
 
+const scopeLimitExceeded = (): EgressProvenanceError =>
+  new EgressProvenanceError(
+    "EGRESS_SCOPE_LIMIT_EXCEEDED",
+    `Collection policy scope exceeds ${MAX_EGRESS_LINEAGE_SOURCES} collections`
+  );
+
+/**
+ * `maxSources` bounds a lineage. Configured sources a scope is resolved from
+ * are unbounded: only the resolved scope must fit (resolveEgressLineage).
+ */
 const snapshotInputs = (
-  inputs: readonly EgressLineageInput[]
+  inputs: readonly EgressLineageInput[],
+  maxSources: number
 ): readonly EgressLineageInput[] => {
   try {
     if (!Array.isArray(inputs)) throw invalidLineageInput();
     const { length } = inputs;
-    if (!Number.isSafeInteger(length) || length > MAX_EGRESS_LINEAGE_SOURCES) {
+    if (!Number.isSafeInteger(length) || length > maxSources) {
       throw invalidLineageInput();
     }
     if (length === 0) {
@@ -109,9 +126,10 @@ const snapshotInputs = (
 };
 
 const canonicalSources = (
-  inputs: readonly EgressLineageInput[]
+  inputs: readonly EgressLineageInput[],
+  maxSources = MAX_EGRESS_LINEAGE_SOURCES
 ): readonly EgressLineageSource[] => {
-  const snapshots = snapshotInputs(inputs);
+  const snapshots = snapshotInputs(inputs, maxSources);
   const byCollection = new Map<string, EgressLineageSource>();
   for (const input of snapshots) {
     const collectionInput = input.collection;
@@ -225,15 +243,19 @@ export const resolveEgressLineage = (
   inputs: readonly EgressLineageInput[],
   requestedNames?: readonly string[]
 ): EgressLineage => {
-  const canonical = canonicalSources(inputs);
-  if (requestedNames === undefined) return createEgressLineage(canonical);
+  const canonical = canonicalSources(inputs, Number.MAX_SAFE_INTEGER);
+  if (requestedNames === undefined) {
+    if (canonical.length > MAX_EGRESS_LINEAGE_SOURCES) {
+      throw scopeLimitExceeded();
+    }
+    return createEgressLineage(canonical);
+  }
   let requested: string[];
   try {
     if (!Array.isArray(requestedNames)) throw invalidLineageInput();
     const { length } = requestedNames;
-    if (!Number.isSafeInteger(length) || length > MAX_EGRESS_LINEAGE_SOURCES) {
-      throw invalidLineageInput();
-    }
+    if (!Number.isSafeInteger(length)) throw invalidLineageInput();
+    if (length > MAX_EGRESS_LINEAGE_SOURCES) throw scopeLimitExceeded();
     const names: string[] = [];
     for (let index = 0; index < length; index += 1) {
       if (!(index in requestedNames)) throw invalidLineageInput();

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

@@ -71,31 +71,22 @@ export function applyProjectProfileDesiredState(
   const existing =
     existingIndex >= 0 ? config.collections[existingIndex] : undefined;
   const models = collectionModels(config, desired.collection.modelPreset);
+  // Start from the existing entry so settings the profile does not own
+  // (egress, workspace, availability, memory, audit, update command) survive.
   const nextCollection: Config["collections"][number] = {
+    ...existing,
     name: desired.collection.name,
     path: collectionRoot,
     pattern: projectProfileIncludePattern(desired.collection.include),
     include: [],
     exclude: desired.collection.exclude,
-    ...(existing?.updateCmd ? { updateCmd: existing.updateCmd } : {}),
-    ...(existing?.updateCmdTimeoutMs
-      ? { updateCmdTimeoutMs: existing.updateCmdTimeoutMs }
-      : {}),
     ...(desired.collection.languageHint
       ? { languageHint: desired.collection.languageHint }
-      : existing?.languageHint
-        ? { languageHint: existing.languageHint }
-        : {}),
-    ...(models
-      ? { models }
-      : existing?.models
-        ? { models: existing.models }
-        : {}),
+      : {}),
+    ...(models ? { 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-apply.ts

@@ -28,6 +28,10 @@ import {
   canonicalOperationalPath,
   getConfigWriteLockPath,
 } from "./config-write-lock";
+import {
+  validateWorkspaceRootSetting,
+  workspaceRootSettingMessage,
+} from "./link-workspace";
 import { compileProjectProfileYaml } from "./project-profile";
 import {
   applyProjectProfileDesiredState,
@@ -64,7 +68,8 @@ export type ProjectProfileApplyErrorCode =
   | "PROFILE_INVALID"
   | "RECEIPT_WRITE_FAILED"
   | "RUNTIME_PATH_OVERLAP"
-  | "STORE_SYNC_FAILED";
+  | "STORE_SYNC_FAILED"
+  | "WORKSPACE_ROOT_CONFLICT";
 
 export interface ProjectProfileApplyError {
   code: ProjectProfileApplyErrorCode;
@@ -159,6 +164,14 @@ const mutationFailure = (
         "Repair the local index store and rerun apply; the saved config is resumable.",
     };
   }
+  if (code === "WORKSPACE_ROOT_CONFLICT") {
+    return {
+      code: "WORKSPACE_ROOT_CONFLICT",
+      message,
+      remediation:
+        "Point workspaceRoot at a directory that contains the profile root, or remove it, then rerun apply.",
+    };
+  }
   if (code === "LOAD_ERROR") {
     return {
       code: "CONFIG_LOAD_FAILED",
@@ -304,6 +317,24 @@ export async function applyProjectProfile(
           compiled.value.resolvedPaths.collectionRoot,
           profileBinding
         );
+        // A kept explicit workspaceRoot must still contain a moved root, or
+        // the saved config would fail to load.
+        const applied = nextConfig.collections.find(
+          ({ name }) => name === compiled.value.desiredState.collection.name
+        );
+        if (typeof applied?.workspaceRoot === "string") {
+          const invalid = validateWorkspaceRootSetting(
+            applied.path,
+            applied.workspaceRoot
+          );
+          if (invalid) {
+            return {
+              ok: false,
+              code: "WORKSPACE_ROOT_CONFLICT",
+              error: workspaceRootSettingMessage(applied.name, invalid),
+            };
+          }
+        }
         projection = {
           collectionName: compiled.value.desiredState.collection.name,
           contexts: compiled.value.desiredState.contexts.map((context) => ({

package/src/pipeline/filters.ts

@@ -250,13 +250,41 @@ export async function typedMetadataWarnings(
     excludeSuperseded: options.memoryFilter?.excludeSuperseded,
   });
   if (!result.ok) return unknown;
-  const { pending, invalid } = result.value;
+  return metadataCoverageWarnings(result.value, "query");
+}
+
+/** The coverage warning for documents a typed metadata filter had to skip. */
+export function metadataCoverageWarnings(
+  coverage: { pending: number; invalid: number },
+  scope: "query" | "listing"
+): { code: string; message: string }[] | undefined {
+  const { pending, invalid } = coverage;
   return pending || invalid
     ? [
         {
           code: "METADATA_COVERAGE_INCOMPLETE",
-          message: `Typed metadata coverage is incomplete: ${pending} documents need re-ingestion and ${invalid} have invalid metadata within the query scope.`,
+          message: `Typed metadata coverage is incomplete: ${pending} documents need re-ingestion and ${invalid} have invalid metadata within the ${scope} scope.`,
         },
       ]
     : undefined;
 }
+
+/**
+ * Keep the documents a typed metadata predicate matches, counting the ones it
+ * could not judge (pending re-ingestion or invalid metadata) for the warning.
+ */
+export function filterDocumentsByMetadata<T extends DocumentRow>(
+  docs: readonly T[],
+  filter: MetadataPredicate
+): { matches: T[]; pending: number; invalid: number } {
+  const matches: T[] = [];
+  let pending = 0;
+  let invalid = 0;
+  for (const doc of docs) {
+    const reason = typedMetadataFilterReason(doc, filter);
+    if (reason === undefined) matches.push(doc);
+    else if (reason === "metadata_backfill") pending += 1;
+    else if (reason === "metadata_invalid") invalid += 1;
+  }
+  return { matches, pending, invalid };
+}

package/src/sdk/client.ts

@@ -1524,7 +1524,12 @@ class GnoClientImpl implements GnoClient {
 
   async list(options: GnoListOptions = {}) {
     this.assertOpen();
-    const result = await listDocuments(this.store, options);
+    const result = await listDocuments(
+      this.store,
+      options.filter === undefined
+        ? options
+        : { ...options, filter: normalizeSdkMetadataFilter(options.filter) }
+    );
     return {
       ...result,
       documents: result.documents.map((doc) => ({

package/src/sdk/documents.ts

@@ -30,6 +30,10 @@ import {
   evidenceFromExactDocument,
   RetrievalTraceSession,
 } from "../core/retrieval-trace-session";
+import {
+  filterDocumentsByMetadata,
+  metadataCoverageWarnings,
+} from "../pipeline/filters";
 import { supersedingUri } from "../pipeline/result-context";
 import { sdkError } from "./errors";
 
@@ -388,11 +392,19 @@ export async function listDocuments(
     });
   }
 
-  const allActive = docsResult.value
+  const inScope = docsResult.value
     .filter((d) => d.active)
     .filter((d) =>
       !scope?.startsWith("gno://") ? true : d.uri.startsWith(scope)
-    )
+    );
+  const filtered = options.filter
+    ? filterDocumentsByMetadata(inScope, options.filter)
+    : undefined;
+  const warnings = filtered
+    ? metadataCoverageWarnings(filtered, "listing")
+    : undefined;
+
+  const allActive = (filtered?.matches ?? inScope)
     .map((d) => ({
       docid: d.docid,
       uri: d.uri,
@@ -415,6 +427,7 @@ export async function listDocuments(
       total: allActive.length,
       returned: paged.length,
       offset,
+      ...(warnings ? { warnings } : {}),
     },
   };
 }

package/src/sdk/types.ts

@@ -89,6 +89,7 @@ import type {
   SectionTargetResolveResult,
   SectionTargetV1,
 } from "../core/sections";
+import type { MetadataPredicate } from "../core/typed-metadata";
 import type { SyncResult } from "../ingestion";
 import type { CollectionRootError } from "../ingestion/source-availability/root";
 import type { DownloadPolicy } from "../llm/policy";
@@ -223,6 +224,8 @@ export interface GnoListOptions {
   scope?: string;
   limit?: number;
   offset?: number;
+  /** Typed metadata predicate, as for search `filter`. */
+  filter?: MetadataPredicate;
 }
 
 export interface GnoUpdateOptions {

package/browser-extension/artifacts/gno-browser-clipper-v2.13.0.zip.sha256

@@ -1 +0,0 @@
-477bb4440a241369687ec7c27d3720e4ce46b8f7139dfec842c5eee10d09e0ea  gno-browser-clipper-v2.13.0.zip