dataiku-sdk 3.0.0 → 3.2.0

package/dist/src/skill.js

@@ -1,17 +1,22 @@
+import { createHash, } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { fileURLToPath, } from "node:url";
 const SKILL_URLS = [
     new URL("../skills/dataiku-dss/SKILL.md", import.meta.url),
     new URL("../../skills/dataiku-dss/SKILL.md", import.meta.url),
 ];
-function skillContent() {
+function skillDirectory() {
     for (const skillUrl of SKILL_URLS) {
         if (fs.existsSync(skillUrl))
-            return fs.readFileSync(skillUrl, "utf-8");
+            return new URL("./", skillUrl);
     }
     throw new Error(`Bundled Dataiku skill not found. Checked: ${SKILL_URLS.map((url) => url.pathname).join(", ")}`);
 }
+function skillContent() {
+    return fs.readFileSync(new URL("SKILL.md", skillDirectory()), "utf-8");
+}
 export const AGENTS = {
     claude: {
         name: "Claude Code",
@@ -97,7 +102,39 @@ export function findWorkspaceRoot(startDir) {
     }
     return startDir;
 }
-export function planSkillInstalls(agents, opts) {
+function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function skillState(target, expectedSha256) {
+    if (!fs.existsSync(target))
+        return { status: "missing", };
+    const actualSha256 = sha256Hex(fs.readFileSync(target));
+    return {
+        status: actualSha256 === expectedSha256 ? "current" : "stale",
+        actualSha256,
+    };
+}
+/** Load the packaged tree, keeping portable relative paths in the report. */
+function skillFiles() {
+    const root = fileURLToPath(skillDirectory());
+    const files = new Map();
+    function visit(relativeDir) {
+        const dir = path.join(root, relativeDir);
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true, }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+            const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                visit(relativePath);
+            else if (entry.isFile()) {
+                files.set(relativePath, fs.readFileSync(path.join(root, relativePath)));
+            }
+            else
+                throw new Error(`Unsupported bundled skill entry: ${relativePath}`);
+        }
+    }
+    visit("");
+    return files;
+}
+function skillInstallPlan(agents, opts, bundle) {
     const home = os.homedir();
     const results = [];
     for (const { id, def, via, } of agents) {
@@ -108,18 +145,65 @@ export function planSkillInstalls(agents, opts) {
                 : undefined;
         if (!dir)
             continue;
-        results.push({ agent: id, path: path.join(dir, def.filename), via, });
+        const files = [];
+        for (const [sourcePath, source,] of bundle) {
+            const relativePath = sourcePath === "SKILL.md" ? def.filename : sourcePath;
+            const target = path.join(dir, relativePath);
+            const expectedSha256 = sha256Hex(sourcePath === "SKILL.md" ? def.content() : source);
+            const state = skillState(target, expectedSha256);
+            files.push({
+                relativePath,
+                path: target,
+                ...state,
+                changed: state.status !== "current",
+                expectedSha256,
+            });
+        }
+        const entrypoint = files.find((file) => file.relativePath === def.filename);
+        const changed = files.some((file) => file.changed);
+        results.push({
+            agent: id,
+            path: entrypoint.path,
+            via,
+            status: entrypoint.status === "missing" ? "missing" : changed ? "stale" : "current",
+            changed,
+            expectedSha256: entrypoint.expectedSha256,
+            ...(entrypoint.actualSha256 !== undefined ? { actualSha256: entrypoint.actualSha256, } : {}),
+            files,
+        });
     }
     return results;
 }
+export function planSkillInstalls(agents, opts) {
+    return skillInstallPlan(agents, opts, skillFiles());
+}
+function writeSkillFile(file, content) {
+    if (!file.changed)
+        return;
+    const dir = path.dirname(file.path);
+    fs.mkdirSync(dir, { recursive: true, });
+    const tmpPath = path.join(dir, `.${path.basename(file.path)}.tmp-${process.pid}-${Date.now().toString(36)}`);
+    try {
+        fs.writeFileSync(tmpPath, content);
+        fs.renameSync(tmpPath, file.path);
+    }
+    finally {
+        fs.rmSync(tmpPath, { force: true, });
+    }
+}
 export function installSkill(agents, opts) {
-    const results = planSkillInstalls(agents, opts);
+    const bundle = skillFiles();
+    const results = skillInstallPlan(agents, opts, bundle);
     for (const result of results) {
-        const def = AGENTS[result.agent];
-        if (!def)
+        if (!result.changed)
             continue;
-        fs.mkdirSync(path.dirname(result.path), { recursive: true, });
-        fs.writeFileSync(result.path, def.content(), "utf-8");
+        const def = agents.find((agent) => agent.id === result.agent).def;
+        // Publish referenced files first; never expose a new entrypoint with missing references.
+        for (const file of result.files) {
+            if (file.relativePath !== def.filename)
+                writeSkillFile(file, bundle.get(file.relativePath));
+        }
+        writeSkillFile(result.files.find((file) => file.relativePath === def.filename), def.content());
     }
     return results;
 }

package/dist/src/utils/flow-analysis.d.ts

@@ -0,0 +1,53 @@
+import type { FlowZone } from "../schemas.js";
+import type { NormalizedFlowMap, NormalizedFlowNode } from "./flow-map.js";
+export type FlowRenderFormat = "ascii" | "mermaid";
+export type FlowDiagnosticSeverity = "info" | "warning";
+export interface AnalyzedFlowNode extends NormalizedFlowNode {
+    componentId: string;
+    layer: number;
+    zoneId: string;
+    zoneName: string;
+}
+export interface FlowMapZone {
+    id: string;
+    name: string;
+    color?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    itemCount: number;
+    nodeIds: string[];
+}
+export interface FlowMapComponent {
+    id: string;
+    nodeIds: string[];
+    rootIds: string[];
+    leafIds: string[];
+    cyclic: boolean;
+}
+export interface FlowMapDiagnostic {
+    code: string;
+    severity: FlowDiagnosticSeverity;
+    message: string;
+    nodeIds?: string[];
+    componentIds?: string[];
+    edgeCount?: number;
+}
+export interface AnalyzedFlowMap extends Omit<NormalizedFlowMap, "nodes"> {
+    nodes: AnalyzedFlowNode[];
+    zones: FlowMapZone[];
+    components: FlowMapComponent[];
+    diagnostics: FlowMapDiagnostic[];
+    topologyFingerprint: string;
+}
+export interface FlowMapRendering {
+    format: FlowRenderFormat;
+    content: string;
+}
+export declare function flowTopologyFingerprint(map: NormalizedFlowMap): string;
+export declare function analyzeFlowMap(map: NormalizedFlowMap, flowZones: FlowZone[], options?: {
+    topologyFingerprint?: string;
+    truncated?: boolean;
+}): AnalyzedFlowMap;
+export declare function renderFlowMap(map: AnalyzedFlowMap, format: FlowRenderFormat): FlowMapRendering;

package/dist/src/utils/flow-analysis.js

@@ -0,0 +1,382 @@
+import { compareStrings, stableHash, } from "./stable-hash.js";
+function sorted(values) {
+    return [...values,].sort(compareStrings);
+}
+function validPosition(zone) {
+    const position = zone.position;
+    return position && Number.isFinite(position.x) && Number.isFinite(position.y)
+        ? { x: position.x, y: position.y, }
+        : undefined;
+}
+function zoneItems(zone) {
+    return [...(zone.items ?? []), ...(zone.shared ?? []),];
+}
+function resolveZoneItemNodeId(item, projectKey, nodeIds) {
+    if (item.projectKey && item.projectKey !== projectKey) {
+        const qualified = `${item.projectKey}.${item.objectId}`;
+        if (nodeIds.has(qualified))
+            return qualified;
+    }
+    return nodeIds.has(item.objectId) ? item.objectId : undefined;
+}
+function flowAdjacency(map) {
+    const outgoingSets = new Map();
+    const undirectedSets = new Map();
+    const selfLoops = new Set();
+    for (const node of map.nodes) {
+        outgoingSets.set(node.id, new Set());
+        undirectedSets.set(node.id, new Set());
+    }
+    for (const edge of map.edges) {
+        if (!outgoingSets.has(edge.from) || !outgoingSets.has(edge.to))
+            continue;
+        outgoingSets.get(edge.from).add(edge.to);
+        undirectedSets.get(edge.from).add(edge.to);
+        undirectedSets.get(edge.to).add(edge.from);
+        if (edge.from === edge.to)
+            selfLoops.add(edge.from);
+    }
+    return {
+        outgoing: new Map([...outgoingSets,].map(([id, values,]) => [id, sorted(values),])),
+        undirected: new Map([...undirectedSets,].map(([id, values,]) => [id, sorted(values),])),
+        selfLoops,
+    };
+}
+function strongComponents(nodeIds, outgoing, selfLoops) {
+    const incoming = new Map(nodeIds.map((nodeId) => [nodeId, [],]));
+    for (const [nodeId, successors,] of outgoing) {
+        for (const successor of successors)
+            incoming.get(successor)?.push(nodeId);
+    }
+    for (const predecessors of incoming.values())
+        predecessors.sort(compareStrings);
+    const visited = new Set();
+    const finished = [];
+    for (const start of nodeIds) {
+        if (visited.has(start))
+            continue;
+        visited.add(start);
+        const stack = [{ nodeId: start, next: 0, },];
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            const successors = outgoing.get(frame.nodeId) ?? [];
+            const successor = successors[frame.next];
+            if (successor !== undefined) {
+                frame.next += 1;
+                if (visited.has(successor))
+                    continue;
+                visited.add(successor);
+                stack.push({ nodeId: successor, next: 0, });
+                continue;
+            }
+            finished.push(frame.nodeId);
+            stack.pop();
+        }
+    }
+    const assigned = new Set();
+    const components = [];
+    for (let index = finished.length - 1; index >= 0; index -= 1) {
+        const start = finished[index];
+        if (assigned.has(start))
+            continue;
+        const members = [];
+        const stack = [start,];
+        assigned.add(start);
+        while (stack.length > 0) {
+            const nodeId = stack.pop();
+            members.push(nodeId);
+            for (const predecessor of incoming.get(nodeId) ?? []) {
+                if (assigned.has(predecessor))
+                    continue;
+                assigned.add(predecessor);
+                stack.push(predecessor);
+            }
+        }
+        members.sort(compareStrings);
+        components.push({
+            id: -1,
+            nodeIds: members,
+            cyclic: members.length > 1 || selfLoops.has(members[0]),
+        });
+    }
+    components.sort((a, b) => compareStrings(a.nodeIds[0], b.nodeIds[0]));
+    components.forEach((component, index) => component.id = index);
+    return components;
+}
+function componentLayers(strong, edges) {
+    const strongByNode = new Map();
+    const outgoing = new Map();
+    const indegree = new Map();
+    const layers = new Map();
+    for (const component of strong) {
+        outgoing.set(component.id, new Set());
+        indegree.set(component.id, 0);
+        layers.set(component.id, 0);
+        for (const nodeId of component.nodeIds)
+            strongByNode.set(nodeId, component.id);
+    }
+    for (const edge of edges) {
+        const from = strongByNode.get(edge.from);
+        const to = strongByNode.get(edge.to);
+        if (from === undefined || to === undefined || from === to || outgoing.get(from).has(to)) {
+            continue;
+        }
+        outgoing.get(from).add(to);
+        indegree.set(to, indegree.get(to) + 1);
+    }
+    const ready = strong.filter((component) => indegree.get(component.id) === 0).map((component) => component.id);
+    while (ready.length > 0) {
+        const current = ready.pop();
+        for (const successor of outgoing.get(current)) {
+            layers.set(successor, Math.max(layers.get(successor), layers.get(current) + 1));
+            indegree.set(successor, indegree.get(successor) - 1);
+            if (indegree.get(successor) === 0)
+                ready.push(successor);
+        }
+    }
+    return new Map([...strongByNode,].map(([nodeId, id,]) => [nodeId, layers.get(id) ?? 0,]));
+}
+function weakComponents(map, undirected, cyclicNodes) {
+    const seen = new Set();
+    const components = [];
+    const componentByNode = new Map();
+    const rootSet = new Set(map.roots);
+    const leafSet = new Set(map.leaves);
+    for (const start of map.nodes.map((node) => node.id)) {
+        if (seen.has(start))
+            continue;
+        const queue = [start,];
+        const nodeIds = [];
+        seen.add(start);
+        for (let index = 0; index < queue.length; index += 1) {
+            const current = queue[index];
+            nodeIds.push(current);
+            for (const adjacent of undirected.get(current) ?? []) {
+                if (seen.has(adjacent))
+                    continue;
+                seen.add(adjacent);
+                queue.push(adjacent);
+            }
+        }
+        nodeIds.sort(compareStrings);
+        const id = `component-${components.length + 1}`;
+        for (const nodeId of nodeIds)
+            componentByNode.set(nodeId, id);
+        components.push({
+            id,
+            nodeIds,
+            rootIds: nodeIds.filter((nodeId) => rootSet.has(nodeId)),
+            leafIds: nodeIds.filter((nodeId) => leafSet.has(nodeId)),
+            cyclic: nodeIds.some((nodeId) => cyclicNodes.has(nodeId)),
+        });
+    }
+    return { components, componentByNode, };
+}
+export function flowTopologyFingerprint(map) {
+    return stableHash({
+        nodes: [...map.nodes,]
+            .map((node) => ({ id: node.id, kind: node.kind, }))
+            .sort((a, b) => compareStrings(a.id, b.id)),
+        edges: [...map.edges,]
+            .map((edge) => ({ from: edge.from, to: edge.to, relation: edge.relation, }))
+            .sort((a, b) => compareStrings(a.from, b.from) || compareStrings(a.to, b.to)
+            || compareStrings(a.relation, b.relation)),
+    });
+}
+export function analyzeFlowMap(map, flowZones, options = {}) {
+    const nodeIds = new Set(map.nodes.map((node) => node.id));
+    const diagnostics = [];
+    const sortedZones = [...flowZones,].sort((a, b) => {
+        if (a.id === "default")
+            return b.id === "default" ? 0 : 1;
+        if (b.id === "default")
+            return -1;
+        const ap = validPosition(a);
+        const bp = validPosition(b);
+        if (ap && bp)
+            return ap.x - bp.x || ap.y - bp.y || compareStrings(a.name, b.name);
+        if (ap)
+            return -1;
+        if (bp)
+            return 1;
+        return compareStrings(a.name, b.name) || compareStrings(a.id, b.id);
+    });
+    if (!sortedZones.some((zone) => zone.id === "default")) {
+        sortedZones.push({ id: "default", name: "Default", items: [], });
+    }
+    const zoneByNode = new Map();
+    for (const zone of sortedZones) {
+        for (const item of zoneItems(zone)) {
+            const nodeId = resolveZoneItemNodeId(item, map.projectKey, nodeIds);
+            if (!nodeId)
+                continue;
+            const previous = zoneByNode.get(nodeId);
+            if (previous && previous.id !== zone.id) {
+                diagnostics.push({
+                    code: "duplicate_zone_assignment",
+                    severity: "warning",
+                    message: `Flow node ${nodeId} appears in zones ${previous.name} and ${zone.name}.`,
+                    nodeIds: [nodeId,],
+                });
+                continue;
+            }
+            zoneByNode.set(nodeId, zone);
+        }
+    }
+    const defaultZone = sortedZones.find((zone) => zone.id === "default");
+    for (const nodeId of nodeIds) {
+        if (!zoneByNode.has(nodeId))
+            zoneByNode.set(nodeId, defaultZone);
+    }
+    const adjacency = flowAdjacency(map);
+    const nodeIdList = sorted(nodeIds);
+    const strong = strongComponents(nodeIdList, adjacency.outgoing, adjacency.selfLoops);
+    const layers = componentLayers(strong, map.edges);
+    const cyclicNodes = new Set(strong.filter((component) => component.cyclic).flatMap((component) => component.nodeIds));
+    const { components, componentByNode, } = weakComponents(map, adjacency.undirected, cyclicNodes);
+    for (const component of strong.filter((candidate) => candidate.cyclic)) {
+        diagnostics.push({
+            code: "cycle_detected",
+            severity: "warning",
+            message: `Flow cycle contains ${component.nodeIds.length} node(s).`,
+            nodeIds: component.nodeIds,
+        });
+    }
+    if (components.length > 1) {
+        diagnostics.push({
+            code: "disconnected_components",
+            severity: "info",
+            message: `Flow contains ${components.length} disconnected components.`,
+            componentIds: components.map((component) => component.id),
+        });
+    }
+    const isolated = nodeIdList.filter((nodeId) => (adjacency.undirected.get(nodeId) ?? []).length === 0);
+    if (isolated.length > 0) {
+        diagnostics.push({
+            code: "isolated_nodes",
+            severity: "info",
+            message: `Flow contains ${isolated.length} isolated node(s).`,
+            nodeIds: isolated,
+        });
+    }
+    const defaultNodes = nodeIdList.filter((nodeId) => zoneByNode.get(nodeId).id === "default");
+    if (defaultNodes.length > 0) {
+        diagnostics.push({
+            code: "default_zone_items",
+            severity: "info",
+            message: `${defaultNodes.length} visible flow node(s) remain in the default zone.`,
+            nodeIds: defaultNodes,
+        });
+    }
+    const crossZoneEdges = map.edges.filter((edge) => {
+        const fromZone = zoneByNode.get(edge.from);
+        const toZone = zoneByNode.get(edge.to);
+        return fromZone !== undefined && toZone !== undefined && fromZone.id !== toZone.id;
+    }).length;
+    if (crossZoneEdges > 0) {
+        diagnostics.push({
+            code: "cross_zone_edges",
+            severity: "info",
+            message: `Flow contains ${crossZoneEdges} cross-zone edge(s).`,
+            edgeCount: crossZoneEdges,
+        });
+    }
+    if (options.truncated === true) {
+        diagnostics.push({
+            code: "analysis_truncated",
+            severity: "warning",
+            message: "Layers, components, zones, and diagnostics cover only the returned truncated map.",
+        });
+    }
+    diagnostics.sort((a, b) => compareStrings(a.code, b.code) || compareStrings(a.message, b.message));
+    const analyzedNodes = map.nodes.map((node) => {
+        const zone = zoneByNode.get(node.id);
+        return {
+            ...node,
+            componentId: componentByNode.get(node.id),
+            layer: layers.get(node.id) ?? 0,
+            zoneId: zone.id,
+            zoneName: zone.name,
+        };
+    });
+    const visibleByZone = new Map();
+    for (const node of analyzedNodes) {
+        const ids = visibleByZone.get(node.zoneId) ?? [];
+        ids.push(node.id);
+        visibleByZone.set(node.zoneId, ids);
+    }
+    const zones = sortedZones.map((zone) => {
+        const position = validPosition(zone);
+        return {
+            id: zone.id,
+            name: zone.name,
+            ...(zone.color ? { color: zone.color, } : {}),
+            ...(position ? { position, } : {}),
+            itemCount: zoneItems(zone).length,
+            nodeIds: sorted(visibleByZone.get(zone.id) ?? []),
+        };
+    });
+    return {
+        ...map,
+        nodes: analyzedNodes,
+        zones,
+        components,
+        diagnostics,
+        topologyFingerprint: options.topologyFingerprint ?? flowTopologyFingerprint(map),
+    };
+}
+function readableNode(node) {
+    return `${node.kind}:${node.name ?? node.id}`;
+}
+function mermaidLabel(value) {
+    return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;").replaceAll(/\s+/g, " ").trim();
+}
+function renderMermaid(map) {
+    const idByNode = new Map(map.nodes.map((node, index) => [node.id, `n${index}`,]));
+    const nodeById = new Map(map.nodes.map((node) => [node.id, node,]));
+    const lines = ["flowchart LR",];
+    for (const [zoneIndex, zone,] of map.zones.entries()) {
+        if (zone.nodeIds.length === 0)
+            continue;
+        lines.push(`  subgraph z${zoneIndex}["${mermaidLabel(zone.name)}"]`);
+        for (const nodeId of zone.nodeIds) {
+            const node = nodeById.get(nodeId);
+            lines.push(`    ${idByNode.get(nodeId)}["${mermaidLabel(readableNode(node))}"]`);
+        }
+        lines.push("  end");
+    }
+    for (const edge of map.edges) {
+        const from = idByNode.get(edge.from);
+        const to = idByNode.get(edge.to);
+        if (from && to)
+            lines.push(`  ${from} --> ${to}`);
+    }
+    return lines.join("\n");
+}
+function renderAscii(map) {
+    const nodeById = new Map(map.nodes.map((node) => [node.id, node,]));
+    const lines = [];
+    for (const component of map.components) {
+        lines.push(`${component.id}${component.cyclic ? " (cyclic)" : ""}`);
+        const layers = new Map();
+        for (const nodeId of component.nodeIds) {
+            const node = nodeById.get(nodeId);
+            const entries = layers.get(node.layer) ?? [];
+            entries.push(`${readableNode(node)} [${node.zoneName}]`);
+            layers.set(node.layer, entries);
+        }
+        for (const [layer, entries,] of [...layers,].sort(([a,], [b,]) => a - b)) {
+            lines.push(`  L${layer}: ${entries.sort(compareStrings).join(" | ")}`);
+        }
+    }
+    if (map.edges.length > 0) {
+        lines.push("edges");
+        for (const edge of map.edges)
+            lines.push(`  ${edge.from} -> ${edge.to} (${edge.relation})`);
+    }
+    return lines.join("\n");
+}
+export function renderFlowMap(map, format) {
+    return { format, content: format === "mermaid" ? renderMermaid(map) : renderAscii(map), };
+}

package/dist/src/utils/project-archive.d.ts

@@ -1,3 +1,33 @@
+/**
+ * Safety budgets applied by {@link inspectProjectArchive} while reading a
+ * project archive. A small malicious archive must not be able to exhaust
+ * CPU or memory during the pre-upload local inspection, so every limit is
+ * enforced: members whose central-directory record declares a compressed
+ * size or expanded/compressed ratio above budget are never streamed,
+ * per-member and aggregate expanded-byte overruns destroy the member
+ * stream immediately, and archives with too many members are reported
+ * without opening any member stream. All limits are per-inspection
+ * configuration: pass a partial object as `overrides` to adjust only what
+ * you need, otherwise the exported defaults apply.
+ */
+export interface ProjectArchiveInspectionLimits {
+    /** Maximum number of central-directory members. Default: 100000. */
+    maxMembers: number;
+    /** Maximum declared compressed bytes of one member. Default: 4 GiB. */
+    maxCompressedBytesPerMember: number;
+    /** Maximum expanded bytes streamed from one member. Default: 4 GiB. */
+    maxExpandedBytesPerMember: number;
+    /**
+     * Maximum declared expanded-to-compressed ratio of one member (zip-bomb
+     * guard, computed from the central-directory record before streaming).
+     * Default: 1000. Legitimate archives with members compressing better
+     * than this need a higher limit to be inspected.
+     */
+    maxCompressionRatio: number;
+    /** Maximum total expanded bytes across all streamed members. Default: 16 GiB. */
+    maxTotalExpandedBytes: number;
+}
+export declare const PROJECT_ARCHIVE_DEFAULT_LIMITS: Readonly<ProjectArchiveInspectionLimits>;
 export type ProjectArchiveIssueSeverity = "error" | "warning";
 export interface ProjectArchiveIssue {
     severity: ProjectArchiveIssueSeverity;
@@ -22,11 +52,20 @@ export interface ProjectArchiveInspection {
  * the generic dangling-reference/orphan-member graph checks. Identity,
  * history and machine-specific residue is reported only as warnings carrying
  * member paths and pattern counts, never matched values.
+ *
+ * Safety budgets (see {@link ProjectArchiveInspectionLimits}) bound every
+ * amount of work: archives with more members than `maxMembers` are reported
+ * without opening any member stream, members whose central-directory record
+ * declares a compressed size or compression ratio above budget are skipped
+ * without being read, and per-member/aggregate expanded-byte overruns
+ * destroy the member stream immediately. Pass a partial limits object as
+ * `overrides` to customize the budgets for a single inspection; importers
+ * use the exported defaults.
  */
-export declare function inspectProjectArchive(filePath: string): Promise<ProjectArchiveInspection>;
+export declare function inspectProjectArchive(filePath: string, overrides?: Partial<ProjectArchiveInspectionLimits>): Promise<ProjectArchiveInspection>;
 /**
  * Like `inspectProjectArchive`, but throws a `ClientValidationError` with the
  * `validation_failed` code when the inspection contains any error-severity
  * issue, so the archive cannot be imported.
  */
-export declare function assertImportableProjectArchive(filePath: string): Promise<ProjectArchiveInspection>;
+export declare function assertImportableProjectArchive(filePath: string, overrides?: Partial<ProjectArchiveInspectionLimits>): Promise<ProjectArchiveInspection>;