@shieldaai/agent-map 0.1.0-alpha.3 → 1.0.0

package/dist/store/nodes.js

@@ -0,0 +1,237 @@
+import neo4j from 'neo4j-driver';
+import { immutableJson } from '@shieldaai/agent-guard/internal';
+import { s3BucketName, shortenScopeList } from '../common.js';
+import { MAP_PROPERTIES } from '../projection-fields.js';
+import { MAP_LABELS, mapIdentifier, MapQueryError, } from '../types.js';
+export const SCOPE_RECORD_BYTES = 1024 * 1024;
+export const SCOPE_HEADROOM_BYTES = 64 * 1024;
+/**
+ * A stable order for bounded, already materialized rows. Each row is serialized once: the
+ * comparator would otherwise re-serialize rows of up to 1 MiB on every comparison.
+ */
+export function sortedBySerialization(rows) {
+    return rows
+        .map(row => [JSON.stringify(row), row])
+        .sort((a, b) => a[0].localeCompare(b[0], 'en-US'))
+        .map(entry => entry[1]);
+}
+/**
+ * Tools sharing a role each list their own extras. Past the budget (1 MiB, or what is left of
+ * the read's byte budget if that is less), keep every record but drop the lists and report
+ * them truncated, rather than fail the read.
+ */
+export function boundedRecords(records, budget = SCOPE_RECORD_BYTES) {
+    if (Buffer.byteLength(JSON.stringify(records), 'utf8') <= budget)
+        return records;
+    return records.map(item => shortenScopeList(item, 0));
+}
+/** Stands in for a scope row that could not be kept; the classifier reads it as truncated. */
+export const oversized = (key) => immutableJson({ key: typeof key === 'number' ? key : -1, oversized: true });
+/** S3 bucket names that visible host bindings map to; the outside-guard reach asks only about these. */
+export function boundBuckets(nodes) {
+    const names = new Set();
+    for (const node of nodes) {
+        if (node.label !== 'GuardExternalResource' || node.properties.provider !== 'aws')
+            continue;
+        const name = s3BucketName(node.properties.arn);
+        if (name !== null)
+            names.add(name);
+    }
+    return [...names].sort();
+}
+export function text(value) {
+    return mapIdentifier(value, 'MAP_UNAVAILABLE');
+}
+export function converted(value) {
+    if (neo4j.isInt(value)) {
+        if (!value.inSafeRange())
+            throw new MapQueryError('MAP_UNAVAILABLE');
+        return value.toNumber();
+    }
+    if (Array.isArray(value))
+        return value.map(converted);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, converted(child)]));
+    return value;
+}
+export function safeNode(raw, label, sourceId, projectionId) {
+    if (!MAP_LABELS.includes(label) || !raw || typeof raw !== 'object' || Array.isArray(raw))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    const data = raw;
+    if (data.source_id !== sourceId || data.projection_id !== projectionId)
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    const properties = {};
+    for (const field of MAP_PROPERTIES[label])
+        if (Object.hasOwn(data, field))
+            properties[field] = converted(data[field]);
+    const opaque = (value) => typeof value === 'string' && value.length === 71 && /^opaque:[a-f0-9]{64}$/.test(value);
+    const optionalOpaque = (value) => value == null || opaque(value);
+    const opaqueArray = (value, maximum) => Array.isArray(value) && value.length <= maximum && new Set(value).size === value.length && value.every(opaque);
+    if (label === 'GuardCredentialReference' &&
+        (!opaque(properties.credential_id) ||
+            !optionalOpaque(properties.issuer_ref) ||
+            !opaqueArray(properties.audience_refs, 128) ||
+            !opaqueArray(properties.recipient_refs, 128) ||
+            !['active', 'rotating', 'revoked', 'expired', 'unknown'].includes(properties.lifecycle_state) ||
+            !['current', 'due', 'overdue', 'unknown'].includes(properties.rotation_status)))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardDeployment' &&
+        (!optionalOpaque(properties.runtime_ref) ||
+            !optionalOpaque(properties.build_ref) ||
+            ![undefined, null, 'found', 'none_declared'].includes(properties.direct_access_status)))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    // Outside-content labels feed the boundary flags; a malformed value must not read as declared.
+    const optionalFlag = (value) => value === undefined || value === null || typeof value === 'boolean';
+    const optionalMode = (value) => value === undefined || value === null || ['allow', 'require_approval', 'deny'].includes(value);
+    if (label === 'GuardTool' &&
+        (!optionalFlag(properties.reads_untrusted) ||
+            !optionalFlag(properties.sends_external) ||
+            !optionalMode(properties.untrusted_context) ||
+            !optionalMode(properties.untrusted_context_default)))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardTask' &&
+        (!optionalFlag(properties.untrusted) || !optionalFlag(properties.delegated) || !optionalFlag(properties.derived)))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardDirectAccess' &&
+        (!opaque(properties.access_id) ||
+            !optionalOpaque(properties.target_ref) ||
+            !['shell', 'database', 'network', 'sdk', 'mcp', 'other'].includes(properties.kind) ||
+            typeof properties.description !== 'string' ||
+            // The same display rule as the manifest: not blank (including separators) and no NUL.
+            /^[\s\u001c-\u001f\u0085\uFEFF]*$/.test(properties.description) ||
+            properties.description.includes('\0') ||
+            [...properties.description].length > 1024 ||
+            typeof properties.deployment_id !== 'string' ||
+            !properties.deployment_id ||
+            [...properties.deployment_id].length > 4096))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    // Fields the boundary flags read: a malformed value must not read as a known fact.
+    if (label === 'GuardGrant' &&
+        (typeof properties.tool !== 'string' ||
+            !Array.isArray(properties.resources) ||
+            properties.resources.some(item => typeof item !== 'string')))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardTask' &&
+        (!optionalFlag(properties.revoked) ||
+            !(properties.deadline == null || typeof properties.deadline === 'number') ||
+            !(properties.allowed_recipients == null ||
+                (Array.isArray(properties.allowed_recipients) &&
+                    properties.allowed_recipients.every(item => typeof item === 'string')))))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardResourceBinding' &&
+        properties.sensitivity != null &&
+        !['public', 'internal', 'confidential', 'restricted', 'unknown'].includes(properties.sensitivity))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardResourceBinding' &&
+        properties.approved_destinations != null &&
+        !opaqueArray(properties.approved_destinations, 128))
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    if (label === 'GuardExternalResource' && properties.provider === 'host') {
+        if (!opaque(properties.host_resource_id) ||
+            !['service', 'repository', 'database', 'queue', 'storage', 'other'].includes(properties.kind))
+            throw new MapQueryError('MAP_UNAVAILABLE');
+        // A host resource cannot acquire AWS identity through extra graph properties.
+        for (const key of [
+            'arn',
+            'partition',
+            'account_id',
+            'region',
+            'cloud_provider_label',
+            'cloud_provider_id',
+            'cloud_match_kind',
+        ])
+            delete properties[key];
+    }
+    return {
+        id: text(data.id),
+        entityId: text(data.entity_id),
+        sourceId,
+        projectionId,
+        label: label,
+        properties: immutableJson(properties, 4, 50_000, 512 * 1024),
+    };
+}
+export function observationTime(value) {
+    if (typeof value !== 'string' ||
+        !/^(?!0000)[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z$/.test(value))
+        return undefined;
+    const time = Date.parse(value);
+    return Number.isFinite(time) && new Date(time).toISOString().slice(0, 19) === value.slice(0, 19) ? time : undefined;
+}
+export function coreCaptureTimes(raw) {
+    // Older or incomplete graph metadata has unknown capture age. Recomposition
+    // changes generated_at, so it is never a safe substitute for these timestamps.
+    if (raw === null || raw === undefined)
+        return {};
+    try {
+        if (typeof raw !== 'string' || Buffer.byteLength(raw, 'utf8') > 4096)
+            throw new Error();
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error();
+        const result = {};
+        for (const component of ['tasks', 'tools']) {
+            const item = parsed[component];
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                throw new Error();
+            const record = item;
+            if (Object.keys(record).sort().join(',') !== 'observedAt,status' ||
+                record.status !== 'complete' ||
+                observationTime(record.observedAt) === undefined)
+                throw new Error();
+            result[component] = record.observedAt;
+        }
+        return result;
+    }
+    catch {
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    }
+}
+export function coverage(nodes, captures, profile, summary, now) {
+    const connections = nodes.filter(node => node.label === 'GuardMcpConnection');
+    const observed = connections.filter(node => node.properties.capture_status === 'observed').length;
+    const references = nodes.filter(node => (node.label === 'GuardExternalResource' || node.label === 'GuardExternalIdentity') &&
+        node.properties.provider !== 'host');
+    const captured = references.filter(node => typeof node.properties.cloud_status === 'string');
+    const resolved = captured.filter(node => node.properties.cloud_status === 'resolved').length;
+    const at = (values) => {
+        const times = values
+            .map(value => (typeof value === 'number' ? value * 1000 : typeof value === 'string' ? Date.parse(value) : NaN))
+            .filter(value => Number.isFinite(value) && value >= 0 && value <= 253_402_300_799_999);
+        return times.length ? { observedAt: new Date(Math.min(...times)).toISOString() } : {};
+    };
+    // Aggregate only visible connections. A new composition cannot renew a cached
+    // observation, and one missing/invalid/future timestamp must not disappear
+    // behind another fresh connection. Unavailable records have only capture time.
+    const mcpTimes = connections
+        .flatMap(node => node.properties.capture_status === 'observed'
+        ? [node.properties.capture_observed_at, node.properties.observed_at]
+        : [node.properties.capture_observed_at])
+        .map(observationTime);
+    const mcpCapture = mcpTimes.length && mcpTimes.every(time => time !== undefined && time <= now + 60_000)
+        ? { observedAt: new Date(Math.min(...mcpTimes)).toISOString() }
+        : {};
+    return {
+        tasks: summary
+            ? { status: 'not_collected' }
+            : { status: 'complete', ...(captures.tasks ? { observedAt: captures.tasks } : {}) },
+        tools: summary
+            ? { status: 'not_collected' }
+            : { status: 'complete', ...(captures.tools ? { observedAt: captures.tools } : {}) },
+        manifest: profile === 'core'
+            ? { status: 'not_collected' }
+            : { status: summary ? 'partial' : 'complete', ...at(nodes.map(node => node.properties.manifest_observed_at)) },
+        mcp: summary || profile !== 'host-mcp'
+            ? { status: 'not_collected' }
+            : {
+                status: observed === connections.length ? 'complete' : observed ? 'partial' : 'unavailable',
+                ...mcpCapture,
+            },
+        cloud: !captured.length
+            ? { status: 'not_collected' }
+            : {
+                status: resolved === references.length ? 'complete' : resolved ? 'partial' : 'unavailable',
+                ...at(captured.map(node => node.properties.cloud_observed_at)),
+            },
+    };
+}

package/dist/store/projection.d.ts

@@ -0,0 +1,19 @@
+import { type MapNode, type MapProjection, type MapSource } from '../types.js';
+import { StoreRead } from './read.js';
+/** One source row, as the source query returned it. */
+export interface SourceRow {
+    readonly sourceId: string;
+    readonly tenantId: string;
+    readonly currentId: string;
+    readonly profile: MapSource['profile'];
+    /** The snapshot's enrolled cloud coverage (its policy age limit), unparsed; read only when evidence is judged. */
+    readonly enrolled: () => unknown;
+}
+/**
+ * One projection of one source: its nodes label by label (each query limited to what earlier
+ * ones authorized), the edges among them and, for the current projection, the evidence the
+ * read mode asks for. Ancestors and identity scope are queued and read after every source.
+ */
+export declare function readProjection(read: StoreRead, source: SourceRow, id: string, snapshotId: string, generatedAt: string, rawCoverage: unknown, currentNodes?: readonly MapNode[]): Promise<MapProjection>;
+/** Every selected source with its current projection and, for a history read, its previous one. */
+export declare function readSources(read: StoreRead): Promise<MapSource[]>;

package/dist/store/projection.js

@@ -0,0 +1,242 @@
+import neo4j from 'neo4j-driver';
+import { s3BucketName } from '../common.js';
+import { identityScopePlan, policyEvidence, policyPlan } from '../policy-reader.js';
+import { MAP_LABELS, MAP_RELATIONSHIPS, mapIdentifier, MapQueryError, } from '../types.js';
+import { readPolicyRows } from './evidence.js';
+import { boundBuckets, converted, coreCaptureTimes, coverage, safeNode, SCOPE_RECORD_BYTES, text } from './nodes.js';
+import { EDGES, HIDDEN_SCOPE, IN_SCOPE_TARGETS, NODES, OWNER_INDEX, OWNER_INDEX_SCOPED, PREVIOUS, READ_ORDER, WILDCARD, } from './queries.js';
+import { StoreRead } from './read.js';
+/**
+ * One projection of one source: its nodes label by label (each query limited to what earlier
+ * ones authorized), the edges among them and, for the current projection, the evidence the
+ * read mode asks for. Ancestors and identity scope are queued and read after every source.
+ */
+export async function readProjection(read, source, id, snapshotId, generatedAt, rawCoverage, currentNodes = []) {
+    const { scope, selection, agentSelected, boundary, accessMode } = read;
+    const { sourceId, tenantId, currentId, profile } = source;
+    const captures = coreCaptureTimes(rawCoverage);
+    const params = {
+        ...read.common,
+        sourceId,
+        tenantId,
+        projectionId: id,
+        currentId,
+        labels: [...MAP_LABELS],
+        currentAgentEntityIds: currentNodes.filter(node => node.label === 'GuardAgent').map(node => node.entityId),
+        currentTaskEntityIds: currentNodes.filter(node => node.label === 'GuardTask').map(node => node.entityId),
+    };
+    const nodes = [];
+    // Ids already loaded, by label: each label's query is limited to what earlier ones found.
+    const idsByLabel = new Map();
+    const nodeQueries = NODES[accessMode][id === currentId ? 0 : 1];
+    for (const label of selection.summary
+        ? ['GuardAgent', 'GuardDeployment', 'GuardOwner']
+        : selection.owners
+            ? scope.allTeams
+                ? OWNER_INDEX
+                : OWNER_INDEX_SCOPED
+            : READ_ORDER) {
+        const authorized = Object.fromEntries(MAP_LABELS.map(kind => [`${kind}Ids`, idsByLabel.get(kind) ?? []]));
+        await read.run(nodeQueries[label], { ...params, ...authorized, nodeLimit: neo4j.int(read.limits.nodes - read.nodeCount + 1) }, item => {
+            if (++read.nodeCount > read.limits.nodes)
+                throw new MapQueryError('MAP_LIMIT_EXCEEDED');
+            if (item.get('label') !== label)
+                throw new MapQueryError('MAP_UNAVAILABLE');
+            const node = safeNode(item.get('node'), label, sourceId, id);
+            read.charge(node);
+            nodes.push(node);
+            const ids = idsByLabel.get(label);
+            if (ids)
+                ids.push(node.id);
+            else
+                idsByLabel.set(label, [node.id]);
+        });
+    }
+    // Delegation ancestors are read after every source's own nodes and edges (below).
+    if (agentSelected && boundary && id === currentId)
+        read.ancestorJobs.push({ sourceId, params });
+    const nodeIds = nodes.map(node => node.id);
+    if (new Set(nodeIds).size !== nodes.length || new Set(nodes.map(node => node.entityId)).size !== nodes.length)
+        throw new MapQueryError('MAP_UNAVAILABLE');
+    const ids = new Set(nodeIds);
+    const edges = [];
+    await read.run(EDGES, {
+        ...params,
+        nodeIds,
+        relationships: [...MAP_RELATIONSHIPS],
+        edgeLimit: neo4j.int(read.limits.edges - read.edgeCount + 1),
+    }, item => {
+        if (++read.edgeCount > read.limits.edges)
+            throw new MapQueryError('MAP_LIMIT_EXCEEDED');
+        const source = text(item.get('source')), target = text(item.get('target')), kind = item.get('kind');
+        if (!ids.has(source) || !ids.has(target) || !MAP_RELATIONSHIPS.includes(kind))
+            throw new MapQueryError('MAP_UNAVAILABLE');
+        const edge = { source, target, kind: kind };
+        read.charge(edge);
+        edges.push(edge);
+    });
+    let projection = {
+        id,
+        snapshotId,
+        generatedAt,
+        status: 'published',
+        nodes,
+        edges,
+        coverage: coverage(nodes, captures, profile, (selection.summary ?? false) || selection.owners === true, read.now() * 1000),
+    };
+    if (agentSelected && boundary && id === currentId) {
+        // The agent's own `*` grants (ancestors' grants are not read).
+        const wildcardTools = [
+            ...new Set(nodes
+                .filter(node => node.label === 'GuardGrant')
+                .filter(node => node.properties.resources.includes('*'))
+                .map(node => node.properties.tool)),
+        ].sort();
+        // No prototype: a tool may be named like an Object.prototype member.
+        const wildcardSensitivity = Object.create(null);
+        if (wildcardTools.length)
+            await read.run(WILDCARD[accessMode], { ...params, wildcardTools }, item => {
+                const tool = item.get('tool'), bindings = converted(item.get('bindings'));
+                if (typeof tool !== 'string' ||
+                    !wildcardTools.includes(tool) ||
+                    !Array.isArray(bindings) ||
+                    bindings.length > 5 ||
+                    Object.hasOwn(wildcardSensitivity, tool) ||
+                    bindings.some(binding => !binding ||
+                        typeof binding.id !== 'string' ||
+                        !['confidential', 'restricted'].includes(binding.sensitivity)))
+                    throw new MapQueryError('MAP_UNAVAILABLE');
+                // The same identifier rule as every node id, so list and detail agree.
+                for (const binding of bindings)
+                    mapIdentifier(binding.id, 'MAP_UNAVAILABLE');
+                wildcardSensitivity[tool] = bindings.map(binding => ({
+                    id: binding.id,
+                    sensitivity: binding.sensitivity,
+                }));
+            });
+        read.charge(wildcardSensitivity);
+        projection = { ...projection, wildcardSensitivity };
+    }
+    const reach = selection.agentId === undefined && selection.outsideGuard === true;
+    // Policy evidence only where the caller shows it. A listing that asked for none
+    // (`policy: false`) is not bound by the pair limit; it still gets the reach and
+    // boundary reads below, which share this block's recheck.
+    const wantsPolicy = selection.policy !== false;
+    const evidenceRead = !selection.summary && !selection.history && !selection.flags && !selection.owners && id === currentId;
+    if (evidenceRead && (wantsPolicy || reach || (selection.agentId !== undefined && boundary))) {
+        let plan = { records: [], probes: [] };
+        let policyNotLoaded = false;
+        if (wantsPolicy) {
+            const select = selection.policy || {};
+            try {
+                plan = policyPlan(scope.companyId, tenantId, nodes, edges, 512 - read.policyPairCount, select);
+            }
+            catch (error) {
+                // An optional read answers without policy evidence and says so.
+                if (select.optional !== true || !(error instanceof MapQueryError) || error.code !== 'MAP_LIMIT_EXCEEDED')
+                    throw error;
+                policyNotLoaded = true;
+            }
+        }
+        read.policyPairCount += plan.records.length;
+        const enrolled = source.enrolled();
+        const maximumAge = plan.probes.length ? read.maximumAgeFor(enrolled) : read.limits.policyAge;
+        const rows = await readPolicyRows(read, plan, params, true);
+        const evidence = policyEvidence(plan, rows, read.now(), maximumAge);
+        for (const item of evidence)
+            read.charge(item);
+        // A team reader sees only buckets and host targets that an in-scope binding maps;
+        // null allows all.
+        let readable = null;
+        let inScopeTargets;
+        if (selection.agentId !== undefined && boundary && !scope.allTeams) {
+            const names = new Set(boundBuckets(nodes));
+            const hosts = new Set();
+            let count = 0;
+            // Host ids only for targets the agent's own declared paths name: bounded by the read.
+            const targetRefs = [
+                ...new Set(nodes
+                    .filter(node => node.label === 'GuardDirectAccess')
+                    .map(node => node.properties.target_ref)
+                    .filter((ref) => typeof ref === 'string')),
+            ];
+            await read.run(IN_SCOPE_TARGETS, { ...params, targetRefs }, item => {
+                if (++count > 20_000)
+                    return;
+                const name = s3BucketName(item.get('arn'));
+                if (name !== null)
+                    names.add(name);
+                const host = item.get('host');
+                if (typeof host === 'string' && /^opaque:[a-f0-9]{64}$/.test(host))
+                    hosts.add(host);
+            });
+            // Past the bound, fall back to what this read holds: that only withholds more.
+            readable = count > 20_000 ? new Set(boundBuckets(nodes)) : names;
+            inScopeTargets = count > 20_000 ? [] : [...hosts].sort();
+            read.charge(inScopeTargets);
+        }
+        let outsideVisibleScope;
+        if (reach && !scope.allTeams) {
+            const visibleIds = nodes
+                .filter(node => node.label === 'GuardDeployment' || node.label === 'GuardTask')
+                .map(node => node.id);
+            const [hidden] = await read.run(HIDDEN_SCOPE, { ...params, visibleIds });
+            // Only an explicit "nothing hidden" lets none_found stand.
+            outsideVisibleScope = hidden?.get('hidden') !== false;
+        }
+        const enriched = {
+            ...projection,
+            ...(!wantsPolicy ? {} : policyNotLoaded ? { policyEvidenceNotLoaded: true } : { policyEvidence: evidence }),
+            ...(outsideVisibleScope === undefined ? {} : { outsideVisibleScope }),
+            ...(inScopeTargets === undefined ? {} : { inScopeTargets }),
+        };
+        const check = {
+            plan,
+            scopePlan: identityScopePlan(scope.companyId, tenantId, [], [], 0),
+            params,
+            rows,
+            scopeRows: [],
+            readable,
+            projection: enriched,
+            maximumAge,
+            scopeBudget: SCOPE_RECORD_BYTES,
+        };
+        read.policyChecks.push(check);
+        if ((selection.agentId !== undefined && boundary) || reach)
+            read.scopeJobs.push({ sourceId, check, reach, enrolled });
+        return enriched;
+    }
+    return projection;
+}
+/** Every selected source with its current projection and, for a history read, its previous one. */
+export async function readSources(read) {
+    const { scope, selection } = read;
+    const sources = [];
+    for (const record of read.selected) {
+        const sourceId = text(record.get('id'));
+        const tenantId = text(record.get('tenantId'));
+        const currentId = text(record.get('currentId'));
+        const profile = record.get('profile');
+        if (!scope.tenantIds.includes(tenantId) || !['core', 'host', 'host-mcp'].includes(profile))
+            throw new MapQueryError('MAP_UNAVAILABLE');
+        const source = {
+            sourceId,
+            tenantId,
+            currentId,
+            profile,
+            enrolled: () => record.get('policyCoverage'),
+        };
+        const current = await readProjection(read, source, currentId, text(record.get('currentSnapshotId')), text(record.get('currentGeneratedAt')), record.get('currentCoverage'));
+        let previous = null;
+        if (selection.history && record.get('previousId')) {
+            const previousId = text(record.get('previousId'));
+            const previousRecords = await read.run(PREVIOUS, { sourceId, projectionId: previousId });
+            if (previousRecords.length === 1) {
+                const item = previousRecords[0];
+                previous = await readProjection(read, source, previousId, text(item.get('snapshotId')), text(item.get('generatedAt')), item.get('coverage'), current.nodes);
+            }
+        }
+        sources.push({ id: sourceId, tenantId, sourceId: text(record.get('nativeSourceId')), profile, current, previous });
+    }
+    return sources;
+}

package/dist/store/queries.d.ts

@@ -0,0 +1,48 @@
+import { type GuardLabel } from '../types.js';
+export interface QueryAccess {
+    readonly allTeams: boolean;
+    readonly agentSelected: boolean;
+}
+export declare const QUERY_ACCESS: readonly QueryAccess[];
+export declare function agentPredicate(variable: string, access: QueryAccess): string;
+export declare const SOURCES: string[][];
+export declare const scoped: (variable: string) => string;
+export declare const READ_ORDER: readonly GuardLabel[];
+export declare const historicalVisibility: (label: 'GuardAgent' | 'GuardTask', parameter: string) => string;
+export declare function through(path: string, label: GuardLabel): string;
+export declare const predicates: Readonly<Record<Exclude<GuardLabel, 'GuardAgent'>, string>>;
+export declare function nodePredicate(label: GuardLabel, access: QueryAccess, historical: boolean): string;
+export declare const NODES: Readonly<Record<"GuardAgent" | "GuardCredentialReference" | "GuardDeployment" | "GuardDirectAccess" | "GuardExecutionBinding" | "GuardExternalIdentity" | "GuardExternalResource" | "GuardGrant" | "GuardMcpConnection" | "GuardMcpOperation" | "GuardOwner" | "GuardPrincipal" | "GuardResource" | "GuardResourceBinding" | "GuardTask" | "GuardTool", string>>[][];
+export declare const checked: (variable: string) => string;
+export declare const inScopeBinding: (binding: string) => string;
+export declare const ancestorsQuery: (access: QueryAccess) => string;
+export declare const ANCESTORS: string[];
+export declare const ANCESTOR_TASKS: string;
+export declare const wildcardQuery: (access: QueryAccess) => string;
+export declare const WILDCARD: string[];
+export declare const IN_SCOPE_TARGETS: string;
+export declare const HIDDEN_SCOPE: string;
+export declare const declaredTask: (task: string) => string;
+export declare const declaredPrincipal: (principal: string) => string;
+export declare const SNAPSHOT = "MATCH (p:GuardSnapshot {id:$projectionId,source_id:$sourceId,status:'published'})";
+export declare const UNDECLARED_COUNT_LIMIT = 10000;
+export declare const UNDECLARED_COUNTS: string;
+export declare const UNDECLARED_TASKS: string;
+export declare const UNDECLARED_PRINCIPALS: string;
+export declare const AWS_COLLECTION_LIMIT = 64;
+export declare const AWS_COLLECTION_COLUMNS: readonly ['id', 'tenantId', 'partition', 'accountId', 'schemaVersion', 'status', 'capturedAt', 'contentHash'];
+export declare const AWS_COLLECTIONS = "MATCH (c:GuardAwsCollection)\nWHERE c.company_id=$companyId AND c.tenant_id IN $tenantIds\nRETURN substring(c.id,0,65) AS id,substring(c.tenant_id,0,4097) AS tenantId,substring(c.partition,0,17) AS partition,\n substring(c.account_id,0,13) AS accountId,c.schema_version AS schemaVersion,substring(c.status,0,33) AS status,\n c.captured_at AS capturedAt,substring(c.content_hash,0,65) AS contentHash\nORDER BY id LIMIT $collectionLimit";
+export declare const CLAIM_LIMIT = 10000;
+export declare const CLAIMED_IDENTITIES: string;
+export declare const BINDINGS_WITHOUT_IDENTITY: string;
+export declare const AWS_MEMBER_LIMIT = 50000;
+export declare const UNCLAIMED_COUNTS = "MATCH (c:GuardAwsCollection)-[m:G_AWS_OBSERVED]->(p:AWSPrincipal)\nWHERE c.id=$collectionId AND c.company_id=$companyId AND c.tenant_id=$collectionTenantId\nWITH c,m,p LIMIT $memberLimit\nRETURN count(p) AS observed,\n sum(CASE WHEN coalesce(p.arn IN $claimed,false) THEN 0 ELSE 1 END) AS unclaimed,\n sum(CASE WHEN m.capture_hash=c.content_hash AND m.captured_at=c.captured_at AND p.lastupdated=c.captured_at\n   THEN 0 ELSE 1 END) AS inconsistent";
+export declare const UNCLAIMED_PAGE = "MATCH (c:GuardAwsCollection)-[:G_AWS_OBSERVED]->(p:AWSPrincipal)\nWHERE c.id IN $collectionIds AND c.company_id=$companyId AND c.tenant_id IN $tenantIds\n  AND NOT coalesce(p.arn IN $claimed,false)\nWITH c,p ORDER BY p.arn, c.id SKIP $pageOffset LIMIT $pageLimit\nRETURN substring(c.id,0,65) AS collectionId,substring(p.arn,0,2049) AS arn,p:AWSRole AS role,p:AWSUser AS user,\n substring(p.name,0,129) AS name,substring(p.path,0,513) AS path\nORDER BY arn, collectionId";
+export declare const EDGES = "MATCH (n)-[:G_IN_SNAPSHOT]->(:GuardSnapshot {id:$projectionId})\nMATCH (n)-[r]->(m)\nWHERE n.id IN $nodeIds AND m.id IN $nodeIds AND type(r) IN $relationships\n AND n.source_id=$sourceId AND m.source_id=$sourceId\n AND n.projection_id=$projectionId AND m.projection_id=$projectionId\n AND n.tenant_id=$tenantId AND m.tenant_id=$tenantId\nRETURN n.id AS source,m.id AS target,type(r) AS kind ORDER BY source,target,kind LIMIT $edgeLimit";
+export declare const PREVIOUS = "MATCH (p:GuardSnapshot {id:$projectionId,source_id:$sourceId,status:'published'})\nRETURN p.id AS id,p.snapshot_id AS snapshotId,p.generated_at AS generatedAt,\n substring(p.coverage_json,0,4097) AS coverage LIMIT 1";
+export declare const MAX_STORE_NODES = 10000;
+export declare const MAX_STORE_EDGES = 25000;
+export declare const MAX_STORE_BYTES: number;
+export declare const OWNER_INDEX: readonly GuardLabel[];
+export declare const OWNER_INDEX_SCOPED: readonly GuardLabel[];
+export declare const POLICY_SELECTION_KEYS: string[];