@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli/commands/list.d.ts

@@ -1,3 +1,7 @@
+import { type ItemTypeRegistry } from "../../core/item/type-registry.js";
+import { type MissingMetadataFilters } from "../../core/governance/metadata-coverage.js";
+import { type ContentFieldFilters } from "../../core/governance/content-fields.js";
+import { type RuntimeStatusRegistry } from "../../core/schema/runtime-schema.js";
 import type { GlobalOptions } from "../../core/shared/command-types.js";
 import type { ItemFrontMatter, ItemStatus } from "../../types/index.js";
 export interface ListOptions {
@@ -19,6 +23,7 @@ export interface ListOptions {
     release?: string;
     limit?: string;
     offset?: string;
+    noTruncate?: boolean;
     includeBody?: boolean;
     compact?: boolean;
     brief?: boolean;
@@ -29,12 +34,62 @@ export interface ListOptions {
     tree?: boolean;
     treeDepth?: string;
     excludeTerminal?: boolean;
+    filterAcMissing?: boolean;
+    filterEstimatesMissing?: boolean;
+    filterResolutionMissing?: boolean;
+    filterMetadataMissing?: boolean;
+    filterReviewerMissing?: boolean;
+    filterRiskMissing?: boolean;
+    filterConfidenceMissing?: boolean;
+    filterSprintMissing?: boolean;
+    filterReleaseMissing?: boolean;
+    hasNotes?: boolean;
+    hasLearnings?: boolean;
+    hasFiles?: boolean;
+    hasDocs?: boolean;
+    hasTests?: boolean;
+    hasComments?: boolean;
+    hasDeps?: boolean;
+    hasBody?: boolean;
+    hasLinkedCommand?: boolean;
+    noNotes?: boolean;
+    noLearnings?: boolean;
+    noFiles?: boolean;
+    noDocs?: boolean;
+    noTests?: boolean;
+    noComments?: boolean;
+    noDeps?: boolean;
+    emptyBody?: boolean;
+    noLinkedCommand?: boolean;
     [key: string]: unknown;
 }
+/** Extract the missing-metadata selection filters from list/update-many options. */
+export declare function resolveMissingMetadataFilters(options: {
+    filterAcMissing?: boolean;
+    filterEstimatesMissing?: boolean;
+    filterResolutionMissing?: boolean;
+    filterMetadataMissing?: boolean;
+    filterReviewerMissing?: boolean;
+    filterRiskMissing?: boolean;
+    filterConfidenceMissing?: boolean;
+    filterSprintMissing?: boolean;
+    filterReleaseMissing?: boolean;
+}): MissingMetadataFilters;
+/**
+ * Resolve the content-field presence/absence selections from list/search
+ * options. A field requested both present AND absent is a usage error (the two
+ * selections are mutually exclusive). Returns an empty object when no
+ * content-field filter is active.
+ */
+export declare function resolveContentFieldFilters(options: Record<string, unknown>): ContentFieldFilters;
 export type ListedItem = ItemFrontMatter | (ItemFrontMatter & {
     body: string;
 });
 type ListProjectionMode = "full" | "compact" | "fields";
+interface ListProjectionConfig {
+    mode: ListProjectionMode;
+    fields: string[];
+}
 export declare const LIST_SORT_FIELDS: readonly ["priority", "deadline", "updated_at", "created_at", "title", "parent"];
 export type ListSortField = (typeof LIST_SORT_FIELDS)[number];
 export declare const LIST_SORT_ORDER_VALUES: readonly ["asc", "desc"];
@@ -42,6 +97,7 @@ export type ListSortOrder = (typeof LIST_SORT_ORDER_VALUES)[number];
 interface ListResultBase {
     items: ListedItem[];
     count: number;
+    total?: number;
     warnings?: string[];
 }
 export interface ListCompactResult extends ListResultBase {
@@ -63,5 +119,65 @@ export interface ListVerboseResult extends ListResultBase {
     now: string;
 }
 export type ListResult = ListCompactResult | ListVerboseResult;
+export declare function buildContentFilterEcho(options: Record<string, unknown>): Record<string, true>;
+export declare function buildGovernanceMissingFilterEcho(options: Record<string, unknown>): Record<string, true>;
+declare function buildCompactListFilterSummary(params: {
+    filtersStatus: string | string[] | null;
+    options: ListOptions;
+    treeEnabled: boolean;
+    treeDepth: number | undefined;
+    sortField: ListSortField | undefined;
+    sortOrder: ListSortOrder;
+    runtimeFieldFilters: Record<string, unknown>;
+}): Record<string, unknown>;
+declare function compareDefaultSort(left: ListedItem, right: ListedItem, statusRegistry: RuntimeStatusRegistry): number;
+declare function parseIdsFilter(raw: unknown): Set<string> | undefined;
+declare function parseOffset(raw: string | undefined): number | undefined;
+declare function parseFieldSelectors(raw: string | undefined): string[] | undefined;
+declare function parseProjectionConfig(options: ListOptions): ListProjectionConfig;
+declare function normalizeProjectionField(field: string): string;
+declare function parseSortField(raw: string | undefined): ListSortField | undefined;
+declare function parseSortOrder(raw: string | undefined): ListSortOrder | undefined;
+declare function parseAssigneeFilter(raw: string | undefined): "assigned" | "unassigned" | undefined;
+declare function applyFilters(items: ListedItem[], status: ItemStatus[] | undefined, options: ListOptions, typeRegistry: ItemTypeRegistry, statusRegistry: RuntimeStatusRegistry, runtimeFieldFilters: Record<string, unknown>): ListedItem[];
+declare function trimNonEmpty(value: string | undefined): string | undefined;
+declare function withTreeMetadata(item: ListedItem, depth: number, childCount: number): ListedItem;
+declare function orderItemsAsTree(sortedItems: ListedItem[], parentRoot: string | undefined, maxDepth: number | undefined): ListedItem[];
+declare function compareNullableString(left: string | null, right: string | null): number;
+declare function compareNullableTimestamp(left: string | null, right: string | null): number;
+declare function compareBySortField(left: ListedItem, right: ListedItem, field: ListSortField): number;
+declare function sortItems(items: ListedItem[], sortField: ListSortField | undefined, sortOrder: ListSortOrder, statusRegistry: RuntimeStatusRegistry): ListedItem[];
+declare function readListFieldValue(item: ListedItem, field: string, treeMode?: boolean): unknown;
+declare function projectListItems(items: ListedItem[], projection: ListProjectionConfig, treeMode?: boolean): ListedItem[];
+declare function runtimeMetadataKeysForProjection(definitions: Array<{
+    metadata_key: string;
+}>): string[];
 export declare function runList(status: ItemStatus | undefined, options: ListOptions, global: GlobalOptions): Promise<ListResult>;
+export declare const _testOnly: {
+    applyFilters: typeof applyFilters;
+    buildCompactListFilterSummary: typeof buildCompactListFilterSummary;
+    buildContentFilterEcho: typeof buildContentFilterEcho;
+    buildGovernanceMissingFilterEcho: typeof buildGovernanceMissingFilterEcho;
+    resolveContentFieldFilters: typeof resolveContentFieldFilters;
+    resolveMissingMetadataFilters: typeof resolveMissingMetadataFilters;
+    compareBySortField: typeof compareBySortField;
+    compareDefaultSort: typeof compareDefaultSort;
+    compareNullableString: typeof compareNullableString;
+    compareNullableTimestamp: typeof compareNullableTimestamp;
+    normalizeProjectionField: typeof normalizeProjectionField;
+    parseAssigneeFilter: typeof parseAssigneeFilter;
+    parseFieldSelectors: typeof parseFieldSelectors;
+    parseIdsFilter: typeof parseIdsFilter;
+    parseOffset: typeof parseOffset;
+    parseProjectionConfig: typeof parseProjectionConfig;
+    parseSortField: typeof parseSortField;
+    parseSortOrder: typeof parseSortOrder;
+    orderItemsAsTree: typeof orderItemsAsTree;
+    projectListItems: typeof projectListItems;
+    readListFieldValue: typeof readListFieldValue;
+    runtimeMetadataKeysForProjection: typeof runtimeMetadataKeysForProjection;
+    sortItems: typeof sortItems;
+    trimNonEmpty: typeof trimNonEmpty;
+    withTreeMetadata: typeof withTreeMetadata;
+};
 export {};

package/dist/cli/commands/list.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="380accc4-3226-5273-bad1-679bc6595543")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1ca90421-424f-5c56-a603-210edd1a5377")}catch(e){}}();
 import { pathExists } from "../../core/fs/fs-utils.js";
 import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
 import { toItemRecord } from "../../core/item/item-record.js";
@@ -8,6 +8,8 @@ import { parseStatusFilterCsv } from "../../core/item/status-filter.js";
 import { resolveItemTypeRegistry } from "../../core/item/type-registry.js";
 import { parseIntegerLimit, parsePriority, parseType } from "../shared-parsers.js";
 import { collectRuntimeFilterValues, matchesRuntimeFilters } from "../../core/schema/runtime-field-filters.js";
+import { hasMissingMetadataFilter, itemMatchesMissingMetadata, lifecycleClassifierFromStatusRegistry, } from "../../core/governance/metadata-coverage.js";
+import { contentFiltersNeedBody, contentFiltersNeedCollections, hasContentFieldFilter, itemMatchesContentFilters, } from "../../core/governance/content-fields.js";
 import { resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, } from "../../core/schema/runtime-schema.js";
 import { EXIT_CODE, FRONT_MATTER_KEY_ORDER } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
@@ -16,6 +18,54 @@ import { listAllFrontMatter, listAllFrontMatterLight, listAllFrontMatterWithBody
 import { HEAVY_METADATA_KEYS } from "../../core/store/front-matter-cache.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
+/** Extract the missing-metadata selection filters from list/update-many options. */
+export function resolveMissingMetadataFilters(options) {
+    return {
+        acMissing: options.filterAcMissing === true,
+        estimatesMissing: options.filterEstimatesMissing === true,
+        resolutionMissing: options.filterResolutionMissing === true,
+        metadataMissing: options.filterMetadataMissing === true,
+        reviewerMissing: options.filterReviewerMissing === true,
+        riskMissing: options.filterRiskMissing === true,
+        confidenceMissing: options.filterConfidenceMissing === true,
+        sprintMissing: options.filterSprintMissing === true,
+        releaseMissing: options.filterReleaseMissing === true,
+    };
+}
+const CONTENT_FIELD_FLAG_MAPPINGS = [
+    { field: "notes", presentKey: "hasNotes", absentKey: "noNotes", presentFlag: "--has-notes", absentFlag: "--no-notes" },
+    { field: "learnings", presentKey: "hasLearnings", absentKey: "noLearnings", presentFlag: "--has-learnings", absentFlag: "--no-learnings" },
+    { field: "files", presentKey: "hasFiles", absentKey: "noFiles", presentFlag: "--has-files", absentFlag: "--no-files" },
+    { field: "docs", presentKey: "hasDocs", absentKey: "noDocs", presentFlag: "--has-docs", absentFlag: "--no-docs" },
+    { field: "tests", presentKey: "hasTests", absentKey: "noTests", presentFlag: "--has-tests", absentFlag: "--no-tests" },
+    { field: "comments", presentKey: "hasComments", absentKey: "noComments", presentFlag: "--has-comments", absentFlag: "--no-comments" },
+    { field: "deps", presentKey: "hasDeps", absentKey: "noDeps", presentFlag: "--has-deps", absentFlag: "--no-deps" },
+    { field: "body", presentKey: "hasBody", absentKey: "emptyBody", presentFlag: "--has-body", absentFlag: "--empty-body" },
+    { field: "linked_command", presentKey: "hasLinkedCommand", absentKey: "noLinkedCommand", presentFlag: "--has-linked-command", absentFlag: "--no-linked-command" },
+];
+/**
+ * Resolve the content-field presence/absence selections from list/search
+ * options. A field requested both present AND absent is a usage error (the two
+ * selections are mutually exclusive). Returns an empty object when no
+ * content-field filter is active.
+ */
+export function resolveContentFieldFilters(options) {
+    const filters = {};
+    for (const mapping of CONTENT_FIELD_FLAG_MAPPINGS) {
+        const present = options[mapping.presentKey] === true;
+        const absent = options[mapping.absentKey] === true;
+        if (present && absent) {
+            throw new PmCliError(`Cannot combine ${mapping.presentFlag} with ${mapping.absentFlag} for the same field.`, EXIT_CODE.USAGE);
+        }
+        if (present) {
+            filters[mapping.field] = "present";
+        }
+        else if (absent) {
+            filters[mapping.field] = "absent";
+        }
+    }
+    return filters;
+}
 export const LIST_SORT_FIELDS = ["priority", "deadline", "updated_at", "created_at", "title", "parent"];
 export const LIST_SORT_ORDER_VALUES = ["asc", "desc"];
 const DEFAULT_COMPACT_LIST_FIELDS = ["id", "title", "status", "type", "priority", "parent", "updated_at"];
@@ -29,6 +79,62 @@ const HEAVY_PROJECTION_FIELDS = new Set(HEAVY_METADATA_KEYS);
 function isNonEmptyRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
 }
+// Active content-field filter flags, keyed by the options dest and the snake_case
+// summary key emitted in the filters echo (GH-242). Presence and absence are
+// distinct echo keys (has_notes vs no_notes; has_body vs empty_body).
+const CONTENT_FILTER_ECHO_ENTRIES = [
+    { key: "hasNotes", summaryKey: "has_notes" },
+    { key: "hasLearnings", summaryKey: "has_learnings" },
+    { key: "hasFiles", summaryKey: "has_files" },
+    { key: "hasDocs", summaryKey: "has_docs" },
+    { key: "hasTests", summaryKey: "has_tests" },
+    { key: "hasComments", summaryKey: "has_comments" },
+    { key: "hasDeps", summaryKey: "has_deps" },
+    { key: "hasBody", summaryKey: "has_body" },
+    { key: "hasLinkedCommand", summaryKey: "has_linked_command" },
+    { key: "noNotes", summaryKey: "no_notes" },
+    { key: "noLearnings", summaryKey: "no_learnings" },
+    { key: "noFiles", summaryKey: "no_files" },
+    { key: "noDocs", summaryKey: "no_docs" },
+    { key: "noTests", summaryKey: "no_tests" },
+    { key: "noComments", summaryKey: "no_comments" },
+    { key: "noDeps", summaryKey: "no_deps" },
+    { key: "emptyBody", summaryKey: "empty_body" },
+    { key: "noLinkedCommand", summaryKey: "no_linked_command" },
+];
+// Active governance-missing filter flags (GH-236), keyed by options dest and the
+// snake_case summary key emitted in the filters echo.
+const GOVERNANCE_MISSING_ECHO_ENTRIES = [
+    { key: "filterReviewerMissing", summaryKey: "filter_reviewer_missing" },
+    { key: "filterRiskMissing", summaryKey: "filter_risk_missing" },
+    { key: "filterConfidenceMissing", summaryKey: "filter_confidence_missing" },
+    { key: "filterSprintMissing", summaryKey: "filter_sprint_missing" },
+    { key: "filterReleaseMissing", summaryKey: "filter_release_missing" },
+];
+function applyContentFilterEcho(filters, options) {
+    for (const entry of CONTENT_FILTER_ECHO_ENTRIES) {
+        if (options[entry.key] === true) {
+            filters[entry.summaryKey] = true;
+        }
+    }
+}
+function applyGovernanceMissingFilterEcho(filters, options) {
+    for (const entry of GOVERNANCE_MISSING_ECHO_ENTRIES) {
+        if (options[entry.key] === true) {
+            filters[entry.summaryKey] = true;
+        }
+    }
+}
+export function buildContentFilterEcho(options) {
+    const echo = {};
+    applyContentFilterEcho(echo, options);
+    return echo;
+}
+export function buildGovernanceMissingFilterEcho(options) {
+    const echo = {};
+    applyGovernanceMissingFilterEcho(echo, options);
+    return echo;
+}
 function buildCompactListFilterSummary(params) {
     const { filtersStatus, options, treeEnabled, treeDepth, sortField, sortOrder, runtimeFieldFilters, } = params;
     const filters = {};
@@ -80,6 +186,20 @@ function buildCompactListFilterSummary(params) {
     if (options.release !== undefined) {
         filters.release = options.release;
     }
+    if (options.filterAcMissing === true) {
+        filters.filter_ac_missing = true;
+    }
+    if (options.filterEstimatesMissing === true) {
+        filters.filter_estimates_missing = true;
+    }
+    if (options.filterResolutionMissing === true) {
+        filters.filter_resolution_missing = true;
+    }
+    if (options.filterMetadataMissing === true) {
+        filters.filter_metadata_missing = true;
+    }
+    applyGovernanceMissingFilterEcho(filters, options);
+    applyContentFilterEcho(filters, options);
     if (options.limit !== undefined) {
         filters.limit = options.limit;
     }
@@ -314,6 +434,11 @@ function applyFilters(items, status, options, typeRegistry, statusRegistry, runt
     const parentFilter = options.parent?.trim();
     const sprintFilter = options.sprint?.trim();
     const releaseFilter = options.release?.trim();
+    const missingMetadataFilters = resolveMissingMetadataFilters(options);
+    const missingMetadataActive = hasMissingMetadataFilter(missingMetadataFilters);
+    const lifecycleClassifier = lifecycleClassifierFromStatusRegistry(statusRegistry);
+    const contentFieldFilters = resolveContentFieldFilters(options);
+    const contentFiltersActive = hasContentFieldFilter(contentFieldFilters);
     if (assigneeFilter && (assigneeFilter.toLowerCase() === "none" || assigneeFilter.toLowerCase() === "null")) {
         throw new PmCliError('--assignee no longer accepts "none" or "null". Use --assignee-filter unassigned.', EXIT_CODE.USAGE);
     }
@@ -358,6 +483,12 @@ function applyFilters(items, status, options, typeRegistry, statusRegistry, runt
             return false;
         if (releaseFilter !== undefined && item.release !== releaseFilter)
             return false;
+        if (missingMetadataActive && !itemMatchesMissingMetadata(item, missingMetadataFilters, lifecycleClassifier)) {
+            return false;
+        }
+        if (contentFiltersActive && !itemMatchesContentFilters(item, contentFieldFilters)) {
+            return false;
+        }
         if (!matchesRuntimeFilters(item, runtimeFieldFilters)) {
             return false;
         }
@@ -508,6 +639,13 @@ function projectListItems(items, projection, treeMode = false) {
         return projected;
     });
 }
+function runtimeMetadataKeysForProjection(definitions) {
+    const keys = [];
+    for (const field of definitions) {
+        keys.push(field.metadata_key);
+    }
+    return keys;
+}
 export async function runList(status, options, global) {
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     if (!(await pathExists(getSettingsPath(pmRoot)))) {
@@ -519,7 +657,8 @@ export async function runList(status, options, global) {
     const runtimeFieldFilters = collectRuntimeFilterValues(options, runtimeFieldRegistry, "list");
     const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
     const projection = parseProjectionConfig(options);
-    validateListProjectionFields(projection, runtimeFieldRegistry.definitions.map((field) => field.metadata_key));
+    const runtimeMetadataKeys = runtimeMetadataKeysForProjection(runtimeFieldRegistry.definitions);
+    validateListProjectionFields(projection, runtimeMetadataKeys);
     const listWarnings = [];
     const projectionNeedsBody = projection.fields.some((field) => normalizeProjectionField(field) === "body");
     // The heavy collection fields are only emitted by `--full` (verbatim items) or an
@@ -528,11 +667,18 @@ export async function runList(status, options, global) {
     // light path that skips the large collections cache (the hot-path JSON.parse win).
     const projectionNeedsCollections = projection.mode === "full" ||
         projection.fields.some((field) => HEAVY_PROJECTION_FIELDS.has(normalizeProjectionField(field)));
+    // Content-field filters (GH-242) inspect the heavy collection arrays and/or the
+    // body, so they force the matching load path even when the projection alone
+    // would take the light path. notes/learnings/files/docs/tests/comments/deps/
+    // linked_command live in the heavy collections; body needs the body load.
+    const contentFieldFilters = resolveContentFieldFilters(options);
+    const contentNeedsCollections = contentFiltersNeedCollections(contentFieldFilters);
+    const contentNeedsBody = contentFiltersNeedBody(contentFieldFilters);
     let items;
-    if (options.includeBody || projectionNeedsBody) {
+    if (options.includeBody || projectionNeedsBody || contentNeedsBody) {
         items = await listAllFrontMatterWithBody(pmRoot, settings.item_format, typeRegistry.type_to_folder, listWarnings, settings.schema);
     }
-    else if (projectionNeedsCollections) {
+    else if (projectionNeedsCollections || contentNeedsCollections) {
         items = await listAllFrontMatter(pmRoot, settings.item_format, typeRegistry.type_to_folder, listWarnings, settings.schema);
     }
     else {
@@ -560,10 +706,16 @@ export async function runList(status, options, global) {
             : resolvedStatus;
     const sorted = sortItems(filtered, sortField, sortOrder, statusRegistry);
     const ordered = treeEnabled ? orderItemsAsTree(sorted, parentRoot, treeDepth) : sorted;
-    const limit = parseIntegerLimit(options.limit);
+    // --no-truncate (alias --all) forces full results, overriding any --limit so an
+    // agent can pull the entire matched set in one call (GH-154).
+    const noTruncate = options.noTruncate === true;
+    const limit = noTruncate ? undefined : parseIntegerLimit(options.limit);
     const offset = parseOffset(options.offset) ?? 0;
     const limited = limit === undefined ? ordered.slice(offset) : ordered.slice(offset, offset + limit);
     const projected = projectListItems(limited, projection, treeEnabled);
+    const totalMatched = ordered.length;
+    // Surface the pre-pagination total only when rows were actually omitted.
+    const truncationExtras = projected.length < totalMatched ? { total: totalMatched } : {};
     const now = nowIso();
     const warnings = [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right));
     const projectionFields = projection.mode === "full" ? null : [...projection.fields];
@@ -584,6 +736,7 @@ export async function runList(status, options, global) {
         return {
             items: projected,
             count: projected.length,
+            ...truncationExtras,
             filters: compactFilters,
             ...(warnings.length > 0 ? { warnings } : {}),
         };
@@ -591,6 +744,7 @@ export async function runList(status, options, global) {
     return {
         items: projected,
         count: projected.length,
+        ...truncationExtras,
         filters: {
             status: filtersStatus,
             type: options.type ?? null,
@@ -608,8 +762,15 @@ export async function runList(status, options, global) {
             parent: options.parent ?? null,
             sprint: options.sprint ?? null,
             release: options.release ?? null,
+            ...(options.filterAcMissing === true ? { filter_ac_missing: true } : {}),
+            ...(options.filterEstimatesMissing === true ? { filter_estimates_missing: true } : {}),
+            ...(options.filterResolutionMissing === true ? { filter_resolution_missing: true } : {}),
+            ...(options.filterMetadataMissing === true ? { filter_metadata_missing: true } : {}),
+            ...buildGovernanceMissingFilterEcho(options),
+            ...buildContentFilterEcho(options),
             limit: options.limit ?? null,
             offset: options.offset ?? null,
+            ...(noTruncate ? { no_truncate: true } : {}),
             include_body: options.includeBody ?? null,
             compact: options.compact ?? null,
             fields: options.fields ?? null,
@@ -630,5 +791,32 @@ export async function runList(status, options, global) {
         ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
+export const _testOnly = {
+    applyFilters,
+    buildCompactListFilterSummary,
+    buildContentFilterEcho,
+    buildGovernanceMissingFilterEcho,
+    resolveContentFieldFilters,
+    resolveMissingMetadataFilters,
+    compareBySortField,
+    compareDefaultSort,
+    compareNullableString,
+    compareNullableTimestamp,
+    normalizeProjectionField,
+    parseAssigneeFilter,
+    parseFieldSelectors,
+    parseIdsFilter,
+    parseOffset,
+    parseProjectionConfig,
+    parseSortField,
+    parseSortOrder,
+    orderItemsAsTree,
+    projectListItems,
+    readListFieldValue,
+    runtimeMetadataKeysForProjection,
+    sortItems,
+    trimNonEmpty,
+    withTreeMetadata,
+};
 //# sourceMappingURL=list.js.map
-//# debugId=380accc4-3226-5273-bad1-679bc6595543
+//# debugId=1ca90421-424f-5c56-a603-210edd1a5377