hammerkit 1.27.0-next.3 → 1.27.0-next.30

package/dist/harness/service-tools.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_TOOLS = exports.describeServiceRun = exports.parseEndpoint = exports.serviceToolArgs = exports.serviceToolSchema = void 0;
+// the most of a page an agent gets back
+const MAX_PAGE_CHARS = 20000;
+// The parameters as a JSON schema, for MCP, pi and opencode 2.
+function serviceToolSchema(tool) {
+    return {
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => [
+            name,
+            parameter.type === 'string'
+                ? { type: 'string', description: parameter.description }
+                : { type: 'array', items: { type: 'string' }, description: parameter.description },
+        ])),
+        required: tool.required,
+    };
+}
+exports.serviceToolSchema = serviceToolSchema;
+// The parameters with the zod of opencode 1.
+function serviceToolArgs(tool, z) {
+    return Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+        const type = parameter.type === 'string' ? z.string() : z.array(z.string());
+        return [name, (tool.required.includes(name) ? type : type.optional()).describe(parameter.description)];
+    }));
+}
+exports.serviceToolArgs = serviceToolArgs;
+// `web:8080` as the server takes an endpoint
+function parseEndpoint(value) {
+    const index = value.lastIndexOf(':');
+    const port = Number(value.slice(index + 1));
+    if (index <= 0 || !Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${value} is not an endpoint, write it as service:port, such as web:8080`);
+    }
+    return { service: value.slice(0, index), port };
+}
+exports.parseEndpoint = parseEndpoint;
+// How a service run stands, for an agent: where its endpoints are and until when.
+function describeServiceRun(run) {
+    const lines = [`run ${run.id}: ${run.state}${run.up ? ` (${run.up.name})` : ''}`];
+    if (run.state === 'up') {
+        lines.push(`up until ${run.expiresAt}, stop it with services_stop when it is no longer needed`);
+        if (run.up?.sleepTtl) {
+            lines.push('without a request for a while the services sleep, the next request wakes them');
+        }
+        for (const endpoint of run.up?.endpoints ?? []) {
+            lines.push(`${endpoint.service}:${endpoint.port} -> ${endpoint.url}`);
+        }
+        if ((run.up?.endpoints ?? []).length > 0) {
+            lines.push('a person opens these addresses in a browser and signs in; read a page yourself with endpoint_get');
+        }
+    }
+    else if (run.error) {
+        lines.push(`error: ${run.error}`);
+    }
+    for (const [task, result] of Object.entries(run.results ?? {})) {
+        if (result.status === 'failed') {
+            lines.push(`${task} failed${result.error ? `: ${result.error}` : ''}`, ...result.lastLog);
+        }
+    }
+    if (run.state !== 'up') {
+        lines.push(`read the log with run_logs { "run": "${run.id}" }`);
+    }
+    return lines.join('\n');
+}
+exports.describeServiceRun = describeServiceRun;
+exports.SERVICE_TOOLS = [
+    {
+        name: 'services_up',
+        title: 'Start services',
+        description: 'Start services of the published build file on the hammerkit server, with the files of the sandbox (or of ' +
+            'a branch), and keep them up for a person to look at: each endpoint (service:port) gets an address of its ' +
+            'own behind the sign-in of the server. Answers once they are up, with the addresses and until when they ' +
+            'stay. A second start with the same name replaces the first, so its addresses stay the same. A server on ' +
+            'Kubernetes starts services from a branch only: push the sandbox and pass branch.',
+        parameters: {
+            services: { type: 'string[]', description: 'The services to start, as the build file names them' },
+            endpoints: { type: 'string[]', description: 'The ports to publish, as service:port, such as web:8080' },
+            ttl: {
+                type: 'string',
+                description: 'How long they stay once ready, such as 2h, then they are removed; the server default when left out',
+            },
+            sleepTtl: {
+                type: 'string',
+                description: 'How long they stay up without a request, such as 30m, then they sleep until the next request wakes ' +
+                    'them (from a branch only); the server default when left out',
+            },
+            name: {
+                type: 'string',
+                description: 'Lower case letters, digits and -; the addresses carry it. The branch when left out',
+            },
+            branch: {
+                type: 'string',
+                description: 'Start from this pushed branch of the repository instead of the files of the sandbox',
+            },
+        },
+        required: ['services'],
+        async call(client, args, signal) {
+            const followed = await client.up({
+                services: args.services,
+                endpoints: (args.endpoints ?? []).map(parseEndpoint),
+                ttl: args.ttl || undefined,
+                sleepTtl: args.sleepTtl || undefined,
+                name: args.name || undefined,
+                branch: args.branch || undefined,
+            }, { signal });
+            return describeServiceRun(followed.run);
+        },
+    },
+    {
+        name: 'endpoint_get',
+        title: 'Read a page of an endpoint',
+        description: 'GET a path of an endpoint of a service run started with services_up, signed in as you, and answer its ' +
+            'status and body: to check that the app answers before a person opens it.',
+        parameters: {
+            run: { type: 'string', description: 'The id of the service run' },
+            path: { type: 'string', description: 'The path, such as / or /api/health' },
+            service: { type: 'string', description: 'The service of the endpoint, the first endpoint when left out' },
+        },
+        required: ['run', 'path'],
+        async call(client, args, signal) {
+            const page = await client.fetchEndpoint(args.run, args.path, args.service || undefined, signal);
+            const body = page.body.length > MAX_PAGE_CHARS
+                ? `${page.body.slice(0, MAX_PAGE_CHARS)}\n… (${page.body.length} characters, the first ${MAX_PAGE_CHARS} shown)`
+                : page.body;
+            return [`GET ${page.url}: ${page.status}${page.type ? ` (${page.type})` : ''}`, '', body].join('\n');
+        },
+    },
+    {
+        name: 'services_stop',
+        title: 'Stop services',
+        description: 'Stop a service run started with services_up: its services and endpoints go.',
+        parameters: { run: { type: 'string', description: 'The id of the service run' } },
+        required: ['run'],
+        async call(client, args) {
+            const run = await client.stop(args.run);
+            return `run ${run.id}: ${run.state === 'up' ? 'stopping' : run.state}`;
+        },
+    },
+];
+//# sourceMappingURL=service-tools.js.map

package/dist/harness/task-tools.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskToolArgs = exports.taskToolSchema = exports.createTaskTools = exports.describeTasks = exports.describeRun = exports.readLogHint = exports.readTaskListing = exports.LIST_TASKS_MS = void 0;
+const sandbox_client_1 = require("./sandbox-client");
+// the most tasks a description lists, and of a task's description or command it shows
+const MAX_LISTED = 40;
+const MAX_DESCRIPTION_CHARS = 200;
+const MAX_COMMAND_CHARS = 100;
+// how long a client waits for the tasks of the build file when it starts, it goes on without them
+exports.LIST_TASKS_MS = 15000;
+// The tasks of the published version, or why they could not be read within `ms`.
+async function readTaskListing(list, ms = exports.LIST_TASKS_MS) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`no answer within ${ms / 1000} s`)), ms);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([list(), timeout]);
+    }
+    catch (e) {
+        return { error: e instanceof Error ? e.message : String(e) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+exports.readTaskListing = readTaskListing;
+// the hint at the end of a cut output or a result, for the model
+function readLogHint(run, task) {
+    return `read more of the log with run_logs { "run": "${run}", "task": "${task}" }`;
+}
+exports.readLogHint = readLogHint;
+// A run of a task in a few lines: how it went, why it ran, its last lines.
+function describeRun(task, ran) {
+    const result = ran.result;
+    const lines = [`run ${ran.run.id}: ${ran.run.state}`];
+    if (result) {
+        lines.push(`task ${task}: ${result.status}` +
+            (result.exitCode !== undefined ? `, exit code ${result.exitCode}` : '') +
+            (result.durationMs !== undefined ? `, ${result.durationMs} ms` : '') +
+            (result.cache?.hit ? ', from the cache' : ''));
+        if (result.error) {
+            lines.push(`error: ${result.error}`);
+        }
+        if (result.cache?.causes?.length) {
+            lines.push(`ran because: ${result.cache.causes.join('; ')}`);
+        }
+    }
+    else if (ran.run.error) {
+        lines.push(`error: ${ran.run.error}`);
+    }
+    if (result && result.lastLog.length > 0) {
+        lines.push('last lines:', ...result.lastLog);
+    }
+    lines.push(readLogHint(ran.run.id, task));
+    return lines.join('\n');
+}
+exports.describeRun = describeRun;
+/**
+ * The tasks for the model, one line each: what it is for (or its command, when the build
+ * file says nothing) and whether it takes arguments. `shell` is left out, the shell tool runs it.
+ */
+function describeTasks(listing, shell) {
+    if (listing === undefined) {
+        return '';
+    }
+    if (!Array.isArray(listing)) {
+        return `The tasks of the build file could not be listed (${listing.error}); name one as the build file does.`;
+    }
+    const tasks = listing.filter((task) => !shell || task.name !== shell);
+    if (tasks.length === 0) {
+        return 'The published build file has no tasks to run.';
+    }
+    const lines = tasks.slice(0, MAX_LISTED).map((task) => {
+        const parts = [`- ${task.name}`];
+        if (task.description) {
+            parts.push(`: ${cut(oneLine(task.description), MAX_DESCRIPTION_CHARS)}`);
+        }
+        else if (task.command) {
+            parts.push(`: runs \`${cut(oneLine(task.command), MAX_COMMAND_CHARS)}\``);
+        }
+        if (task.args === null) {
+            parts.push(' (takes args)');
+        }
+        else if (task.args !== undefined || task.command === null) {
+            parts.push(' (takes no args)');
+        }
+        return parts.join('');
+    });
+    if (tasks.length > MAX_LISTED) {
+        lines.push(`- and ${tasks.length - MAX_LISTED} more`);
+    }
+    return ['The tasks of the published build file:', ...lines].join('\n');
+}
+exports.describeTasks = describeTasks;
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function cut(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/**
+ * `run_task`, `run_logs` and `check`, with the tasks the description of `run_task` lists. Without a
+ * listing it names none, as the MCP tools before a version could be read.
+ */
+function createTaskTools(listing, shell) {
+    const tasks = describeTasks(listing, shell);
+    return [
+        {
+            name: 'run_task',
+            title: 'Run a task',
+            description: 'Run a task of the published build file on the sandbox, such as test or build, and answer how it went: ' +
+                'its status, exit code, why it was not taken from the cache, and its last lines. args are appended to ' +
+                'its last command, for example a test file. It runs in the container, with the network and the ' +
+                'options the build file gives the task.' +
+                (tasks ? `\n\n${tasks}` : ''),
+            parameters: {
+                task: { type: 'string', description: 'The name of the task' },
+                args: { type: 'string[]', description: 'Arguments for its last command' },
+            },
+            required: ['task'],
+            async call(client, args, signal) {
+                const ran = await client.runTask(args.task, { args: args.args?.length ? args.args : undefined, signal });
+                return describeRun(args.task, ran);
+            },
+        },
+        {
+            name: 'run_logs',
+            title: 'Read the log of a run',
+            description: 'Read the log of a run as numbered lines: one task, the last lines (tail), a range (from, limit) or ' +
+                'the lines that contain a text (grep, a fixed string) with lines of context around them.',
+            parameters: {
+                run: { type: 'string', description: 'The id of the run' },
+                task: { type: 'string', description: 'Only the lines of this task' },
+                tail: {
+                    type: 'integer',
+                    description: 'The last lines, or with grep the last matches',
+                    minimum: 1,
+                    maximum: 1000,
+                },
+                from: { type: 'integer', description: 'The first line to read', minimum: 1 },
+                limit: { type: 'integer', description: 'How many lines to read', minimum: 1, maximum: 1000 },
+                grep: { type: 'string', description: 'Only lines that contain this text' },
+                ignore_case: { type: 'boolean', description: 'Ignore case in grep' },
+                context: { type: 'integer', description: 'Lines before and after each match', minimum: 0, maximum: 20 },
+            },
+            required: ['run'],
+            async call(client, args) {
+                const page = await client.logs(args.run, {
+                    task: args.task || undefined,
+                    tail: args.tail || undefined,
+                    from: args.from || undefined,
+                    limit: args.limit || undefined,
+                    grep: args.grep || undefined,
+                    i: args.ignore_case || undefined,
+                    context: args.context || undefined,
+                });
+                const lines = page.lines.map((line) => `${line.line}${line.match === false ? '-' : ':'} ${args.task ? '' : `[${line.task}] `}${line.text}`);
+                lines.push('', `(${page.total} lines${args.grep ? ` searched, ${page.lines.filter((line) => line.match !== false).length} match here` : ''}${page.next ? `, read on with from ${page.next}` : ''}${page.truncated ? ', the server cut the log off at its limit' : ''})`);
+                return lines.join('\n');
+            },
+        },
+        {
+            name: 'check',
+            title: 'Run a check',
+            description: sandbox_client_1.CHECK_DESCRIPTION,
+            parameters: { task: { type: 'string', description: 'The name of the task' } },
+            required: ['task'],
+            call(client, args, signal) {
+                return (0, sandbox_client_1.runCheck)(client, args.task, signal);
+            },
+        },
+    ];
+}
+exports.createTaskTools = createTaskTools;
+// The parameters as a JSON schema, for MCP and opencode 2.
+function taskToolSchema(tool) {
+    return {
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+            if (parameter.type === 'string[]') {
+                return [name, { type: 'array', items: { type: 'string' }, description: parameter.description }];
+            }
+            if (parameter.type === 'integer') {
+                const { maximum } = parameter;
+                return [
+                    name,
+                    {
+                        type: 'integer',
+                        description: parameter.description,
+                        minimum: parameter.minimum,
+                        ...(maximum !== undefined ? { maximum } : {}),
+                    },
+                ];
+            }
+            return [name, { type: parameter.type, description: parameter.description }];
+        })),
+        required: tool.required,
+    };
+}
+exports.taskToolSchema = taskToolSchema;
+// The parameters with the zod of opencode 1.
+function taskToolArgs(tool, z) {
+    return Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+        let type;
+        if (parameter.type === 'string[]') {
+            type = z.array(z.string());
+        }
+        else if (parameter.type === 'integer') {
+            type = z.number().int().min(parameter.minimum);
+            type = parameter.maximum !== undefined ? type.max(parameter.maximum) : type;
+        }
+        else {
+            type = parameter.type === 'boolean' ? z.boolean() : z.string();
+        }
+        return [name, (tool.required.includes(name) ? type : type.optional()).describe(parameter.description)];
+    }));
+}
+exports.taskToolArgs = taskToolArgs;
+//# sourceMappingURL=task-tools.js.map

package/dist/kubernetes/apply.js

@@ -36,28 +36,39 @@ exports.apply = apply;
  * of a policy).
  */
 async function replace(instance, spec) {
-    let current;
-    try {
-        current = await instance.objectApi.read(spec);
-    }
-    catch (e) {
-        if (statusCodeOf(e) !== 404) {
-            throw e;
+    for (let attempt = 1;; attempt++) {
+        let current;
+        try {
+            current = await instance.objectApi.read(spec);
+        }
+        catch (e) {
+            if (statusCodeOf(e) !== 404) {
+                throw e;
+            }
+            try {
+                return await instance.objectApi.create(spec);
+            }
+            catch (createError) {
+                if (statusCodeOf(createError) !== 409) {
+                    throw createError;
+                }
+                current = await instance.objectApi.read(spec);
+            }
         }
         try {
-            return await instance.objectApi.create(spec);
+            return await instance.objectApi.replace({
+                ...spec,
+                metadata: { ...spec.metadata, resourceVersion: current.metadata?.resourceVersion },
+            });
         }
-        catch (createError) {
-            if (statusCodeOf(createError) !== 409) {
-                throw createError;
+        catch (e) {
+            // replaced by someone else since it was read (the server sets up a caller's
+            // namespace for a run and for a sandbox at the same time): read it again
+            if (statusCodeOf(e) !== 409 || attempt >= 3) {
+                throw e;
             }
-            current = await instance.objectApi.read(spec);
         }
     }
-    return await instance.objectApi.replace({
-        ...spec,
-        metadata: { ...spec.metadata, resourceVersion: current.metadata?.resourceVersion },
-    });
 }
 exports.replace = replace;
 //# sourceMappingURL=apply.js.map

package/dist/kubernetes/await-running-state.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stopJob = exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.deleteJob = exports.awaitJobCompletion = exports.awaitRunningState = void 0;
+exports.stopJob = exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.PASSING_FAILURE_MS = exports.deleteJob = exports.awaitJobCompletion = exports.awaitRunningState = void 0;
 const abort_1 = require("../executer/abort");
 const abort_event_1 = require("../utils/abort-event");
 const apply_1 = require("./apply");
 const sleep_1 = require("../utils/sleep");
+const cluster_state_1 = require("./cluster-state");
 // The waits below poll instead of using the client's Watch: Watch aborts every
 // request after 30s, which a pod or deployment still pulling its image outlasts.
 async function awaitRunningState(instance, env, name, phase, pollInterval = 1000) {
@@ -76,29 +77,74 @@ async function deleteJob(instance, env, name) {
     }
 }
 exports.deleteJob = deleteJob;
-// Waits for a ready replica. The deadline only starts once a pod runs, so an
-// image pull doesn't count against it (as on docker, where it starts after
-// the container started).
+// how long a reason that may still pass (an image pull a registry refused for now, a
+// container the runtime could not create) may last before it fails the service
+exports.PASSING_FAILURE_MS = 60000;
+// Waits for an available replica: a ready one, for a service without a healthcheck one that
+// stayed ready for a while. The deadline only starts once the container runs, and again
+// at each start of it, so an image pull or a back-off doesn't count against it (as on
+// docker, where it starts after the container started). A pod that won't get there without a change (an image
+// that isn't there, a container that crashed once more than its
+// service's `restarts`, 2 by default) fails it at once, with
+// the reason the cluster gives; one that may still pass fails once it lasted a minute.
+// Only the pods of this Deployment count: not the ones of one deleted before it was
+// created again, which may still be there, terminating or not yet.
 async function awaitDeployRunningState(instance, env, name, readiness, pollInterval = 1000, now = Date.now) {
     let runningSince = null;
+    // how often the container was restarted when last looked at
+    let restarts = 0;
+    let said;
+    // since when a pod has had a failure that may still pass, by pod
+    const failingSince = new Map();
     for (;;) {
         const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
-        if ((deployment.status?.readyReplicas ?? 0) > 0) {
+        // available: ready for the Deployment's minReadySeconds
+        if ((deployment.status?.availableReplicas ?? 0) > 0) {
             return;
         }
+        const created = deployment.metadata?.creationTimestamp;
+        const listed = await instance.coreApi.listNamespacedPod({
+            namespace: env.namespace,
+            labelSelector: readiness.podSelector,
+        });
+        const pods = listed.items.filter((pod) => !pod.metadata?.deletionTimestamp &&
+            !(created && pod.metadata?.creationTimestamp && pod.metadata.creationTimestamp < created));
+        for (const [index, pod] of pods.entries()) {
+            const key = pod.metadata?.name ?? `${index}`;
+            const failure = (0, cluster_state_1.getPodFailure)(pod, readiness.container, readiness.restarts);
+            if (!failure) {
+                failingSince.delete(key);
+                continue;
+            }
+            const since = failingSince.get(key) ?? now();
+            failingSince.set(key, since);
+            if (failure.final || now() - since >= exports.PASSING_FAILURE_MS) {
+                throw new Error(`${readiness.subject ?? name} can not become ready, ${failure.text}`);
+            }
+        }
+        const waiting = pods.map((pod) => (0, cluster_state_1.getPodWaiting)(pod, readiness.container)).find((text) => !!text);
+        if (waiting && waiting !== said) {
+            readiness.onWaiting?.(waiting);
+        }
+        said = waiting;
         if (readiness.timeout !== null) {
-            if (runningSince === null) {
-                const pods = await instance.coreApi.listNamespacedPod({
-                    namespace: env.namespace,
-                    labelSelector: readiness.podSelector,
-                });
-                if (pods.items.some((pod) => pod.status?.phase === 'Running')) {
-                    runningSince = now();
-                }
+            // the deadline bounds each start of the container, as on Docker: a crash is counted by
+            // `restarts`, and the back-off before the next start doesn't count against it
+            const statuses = pods.flatMap((pod) => (pod.status?.containerStatuses ?? []).filter((status) => !readiness.container || status.name === readiness.container));
+            const running = statuses.length > 0
+                ? statuses.some((status) => status.state?.running)
+                : pods.some((pod) => pod.status?.phase === 'Running');
+            const restarted = Math.max(0, ...statuses.map((status) => status.restartCount ?? 0));
+            if (!running) {
+                runningSince = null;
+            }
+            else if (runningSince === null || restarted !== restarts) {
+                runningSince = now();
             }
             else if (now() - runningSince >= readiness.timeout) {
                 throw new Error(readiness.timeoutMessage);
             }
+            restarts = restarted;
         }
         await (0, sleep_1.sleep)(pollInterval);
     }

package/dist/kubernetes/claim-layout.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOutputsFlatteningAlike = exports.hasPathsEndingAlike = exports.byDepth = exports.getClaimSubPath = void 0;
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const portable_path_1 = require("../planner/utils/portable-path");
+// The paths a work item keeps in its claim. Its consumers mount its outputs by the same
+// paths, so they find the same folders.
+function getClaimPaths(work) {
+    const data = work.data;
+    const paths = [];
+    if ('mounts' in data) {
+        paths.push(...data.mounts.map((mount) => mount.containerPath));
+    }
+    if ('src' in data) {
+        paths.push(...data.src.filter((src) => !src.inherited).map((src) => src.absolutePath));
+    }
+    if ('generates' in data) {
+        paths.push(...data.generates.filter((generate) => !generate.inherited).map((generate) => generate.path));
+    }
+    if ('volumes' in data) {
+        paths.push(...data.volumes.filter((volume) => !volume.inherited).map((volume) => volume.containerPath));
+    }
+    return paths;
+}
+// Where `path` is in the claim of `work`, relative to its root. A path is named after its
+// last segment, so claims without two such paths are laid out as they always were (a
+// service's data among them). Of the paths with the same last segment, the least deep one
+// (then the first in sorted order) keeps the name, and the others also carry a hash of
+// their path. Both go by the path
+// relative to the project, as the task's id does, so a run in another checkout directory
+// (each run of a server has its own) or with its `generates` in another order finds the
+// same folders in a kept claim.
+function getClaimSubPath(work, path) {
+    const name = (0, path_1.basename)(path) || 'root';
+    const alike = getClaimPaths(work).filter((other) => other !== path && (0, path_1.basename)(other) === (0, path_1.basename)(path));
+    if (alike.length === 0) {
+        return name;
+    }
+    const own = (0, portable_path_1.portablePath)(work.data.projectRoot, path);
+    const first = [own, ...alike.map((other) => (0, portable_path_1.portablePath)(work.data.projectRoot, other))].sort(byDepth)[0];
+    if (first === own) {
+        return name;
+    }
+    return `${name}-${(0, crypto_1.createHash)('sha256').update(own).digest('hex').slice(0, 12)}`;
+}
+exports.getClaimSubPath = getClaimSubPath;
+function byDepth(a, b) {
+    return a.split('/').length - b.split('/').length || (a < b ? -1 : a > b ? 1 : 0);
+}
+exports.byDepth = byDepth;
+// Whether two different paths of the claim of `work` end alike. Before getClaimSubPath
+// named them apart, they shared one folder, and outputs made then are mixed.
+function hasPathsEndingAlike(work) {
+    const paths = new Set(getClaimPaths(work));
+    return new Set([...paths].map((path) => (0, path_1.basename)(path))).size < paths.size;
+}
+exports.hasPathsEndingAlike = hasPathsEndingAlike;
+// Whether two outputs of `work` flatten to the same name of a cache archive (`a-b` and
+// `a/b`, see getArchivePaths). Before they were named apart, one archive held both.
+function hasOutputsFlatteningAlike(work) {
+    const data = work.data;
+    if (!('generates' in data) || !('cwd' in data)) {
+        return false;
+    }
+    const paths = new Set(data.generates.filter((generate) => !generate.inherited).map((generate) => generate.path));
+    const names = new Set([...paths].map((path) => (0, path_1.relative)(data.cwd, path).split(path_1.sep).join('-')));
+    return names.size < paths.size;
+}
+exports.hasOutputsFlatteningAlike = hasOutputsFlatteningAlike;
+//# sourceMappingURL=claim-layout.js.map