@pikku/cli 0.12.144 → 0.12.151

package/dist/src/deploy/analyzer/analyzer.js

@@ -6,9 +6,11 @@
  * Gateways (MCP, agents, channels) dispatch to function units via RPC.
  * Workflow orchestrators dispatch to step units via queue or RPC (inline).
  */
-import { resolveDeployTarget, } from '@pikku/inspector';
+import { incompatibleServicesFor, resolveDeployTarget, } from '@pikku/inspector';
 import { relative } from 'node:path';
 import { isScenarioFunction, withoutScenarios, withoutScenarioWorkflows, } from '../../functions/wirings/scenarios/scenario-partition.js';
+import { toSafeKebab } from './naming.js';
+import { createUnitResolver } from './grouping.js';
 export function analyzeDeployment(state, options) {
     const serverlessIncompatible = new Set(options.serverlessIncompatible ?? []);
     const defaultTarget = options.defaultTarget ?? 'serverless';
@@ -30,6 +32,110 @@ export function analyzeDeployment(state, options) {
     const functionsMeta = withoutScenarios(state.functions.meta);
     const graphMeta = withoutScenarioWorkflows(state.workflows.graphMeta);
     const httpMeta = state.http.meta;
+    const tagIndex = buildFunctionTagIndex(state, functionsMeta);
+    const tagsFor = (funcId) => tagIndex.get(funcId) ?? [];
+    const resolver = createUnitResolver(options.grouping, {
+        routesForFunction: (funcId) => collectHttpRoutes(httpMeta, funcId).flatMap((r) => [
+            r.route,
+            prefixed(r.route),
+        ]),
+        tagsForFunction: tagsFor,
+        servicesForFunction: (funcId) => functionsMeta[funcId]?.services?.services ?? [],
+        targetForFunction: (funcId) => {
+            const funcMeta = functionsMeta[funcId];
+            return funcMeta
+                ? resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget)
+                : defaultTarget;
+        },
+    });
+    const addFunctionUnit = (unit) => {
+        // Set here rather than at each call site: a unit is created from six
+        // places (functions, channels, agents, MCP, workflow orchestrators, steps)
+        // and a unit missing its key reads as one the strategy never named.
+        if (!unit.servicesKey) {
+            const key = resolver.serviceKeyForUnit(unit.name);
+            if (key)
+                unit.servicesKey = key;
+        }
+        const existing = units.find((u) => u.name === unit.name);
+        if (!existing) {
+            units.push(unit);
+            return;
+        }
+        if (existing.target !== unit.target) {
+            const rule = resolver.ruleForUnit(unit.name);
+            throw new Error(`deploy.grouping: unit "${unit.name}" would hold both serverless and server functions ` +
+                `(${existing.functionIds.join(', ')} vs ${unit.functionIds.join(', ')}). ` +
+                (rule
+                    ? `Give the server-target functions their own rule, or drop them from "${unit.name}".`
+                    : `A grouping rule cannot change a function's target.`));
+        }
+        for (const id of unit.functionIds) {
+            if (!existing.functionIds.includes(id)) {
+                existing.functionIds.push(id);
+            }
+        }
+        for (const service of unit.services) {
+            if (!existing.services.some((s) => s.capability === service.capability &&
+                s.sourceServiceName === service.sourceServiceName)) {
+                existing.services.push(service);
+            }
+        }
+        for (const dep of unit.dependsOn) {
+            if (dep !== existing.name && !existing.dependsOn.includes(dep)) {
+                existing.dependsOn.push(dep);
+            }
+        }
+        for (const tag of unit.tags) {
+            if (!existing.tags.includes(tag)) {
+                existing.tags.push(tag);
+            }
+        }
+        if (unit.targetForcedBy?.length) {
+            const forcedBy = existing.targetForcedBy ?? [];
+            for (const svc of unit.targetForcedBy) {
+                if (!forcedBy.includes(svc)) {
+                    forcedBy.push(svc);
+                }
+            }
+            existing.targetForcedBy = forcedBy;
+        }
+        for (const handler of unit.handlers) {
+            if (handler.type === 'fetch') {
+                const fetchHandler = existing.handlers.find((h) => h.type === 'fetch');
+                if (fetchHandler) {
+                    fetchHandler.routes.push(...handler.routes);
+                }
+                else {
+                    existing.handlers.push(handler);
+                }
+            }
+            else {
+                existing.handlers.push(handler);
+            }
+        }
+        if (unit.invokedAgents?.length) {
+            const merged = new Set([
+                ...(existing.invokedAgents ?? []),
+                ...unit.invokedAgents,
+            ]);
+            existing.invokedAgents = [...merged];
+        }
+    };
+    const unitFunctionIds = new Map();
+    const unitFor = (funcId) => {
+        const name = resolver.forFunction(funcId);
+        const existing = unitFunctionIds.get(name);
+        if (existing) {
+            if (!existing.includes(funcId)) {
+                existing.push(funcId);
+            }
+        }
+        else {
+            unitFunctionIds.set(name, [funcId]);
+        }
+        return name;
+    };
     // ── Step 1: Create function units ──────────────────────────────────
     // Each function gets one unit. Collect all its triggers.
     for (const [funcId, funcMeta] of entries(functionsMeta)) {
@@ -70,7 +176,7 @@ export function analyzeDeployment(state, options) {
                 handlers.push({ type: 'queue', queueName: queueMeta.name ?? queueName });
                 queues.push({
                     name: queueMeta.name ?? queueName,
-                    consumerUnit: toSafeKebab(funcId),
+                    consumerUnit: unitFor(funcId),
                     consumerFunctionId: funcId,
                 });
             }
@@ -86,7 +192,7 @@ export function analyzeDeployment(state, options) {
                 scheduledTasks.push({
                     name: schedMeta.name,
                     schedule: schedMeta.schedule,
-                    unitName: toSafeKebab(funcId),
+                    unitName: unitFor(funcId),
                     functionId: funcId,
                 });
             }
@@ -128,16 +234,21 @@ export function analyzeDeployment(state, options) {
             continue;
         }
         const invokedAgents = collectInvokedAgents(state, funcId);
-        units.push({
-            name: toSafeKebab(funcId),
+        const unitName = unitFor(funcId);
+        const groupedBy = resolver.ruleForUnit(unitName);
+        const forcedBy = incompatibleServicesFor(funcMeta, serverlessIncompatible);
+        addFunctionUnit({
+            name: unitName,
             role: 'function',
             target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
             functionIds: [funcId],
             services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
             dependsOn: [],
             handlers,
-            tags: funcMeta.tags ?? [],
+            tags: tagsFor(funcId),
             ...(invokedAgents.length > 0 && { invokedAgents }),
+            ...(groupedBy && { groupedBy }),
+            ...(forcedBy.length > 0 && { targetForcedBy: forcedBy }),
         });
     }
     // ── Step 1b: Addon units ───────────────────────────────────────────
@@ -147,11 +258,13 @@ export function analyzeDeployment(state, options) {
         if (exposed.length === 0) {
             continue;
         }
-        const unitName = `addon-${toSafeKebab(namespace)}`;
+        const unitName = resolver.forAddon(namespace);
+        const addonGroupedBy = resolver.ruleForUnit(unitName);
         const addonIncompatible = new Set(state.addonServerlessIncompatible?.get(namespace) ?? []);
         const routes = [];
         const functionIds = [];
         const services = [];
+        const addonForcedBy = [];
         let target = defaultTarget;
         for (const [funcName, funcMeta] of exposed) {
             const rpcName = `${namespace}:${funcName}`;
@@ -172,11 +285,16 @@ export function analyzeDeployment(state, options) {
                     services.push(service);
                 }
             }
+            for (const svc of incompatibleServicesFor(funcMeta, addonIncompatible)) {
+                if (!addonForcedBy.includes(svc)) {
+                    addonForcedBy.push(svc);
+                }
+            }
             if (resolveDeployTarget(funcMeta, addonIncompatible, rpcName, defaultTarget) === 'server') {
                 target = 'server';
             }
         }
-        units.push({
+        addFunctionUnit({
             name: unitName,
             role: 'function',
             target,
@@ -185,6 +303,8 @@ export function analyzeDeployment(state, options) {
             dependsOn: [],
             handlers: [{ type: 'fetch', routes }],
             tags: [],
+            ...(addonGroupedBy && { groupedBy: addonGroupedBy }),
+            ...(addonForcedBy.length > 0 && { targetForcedBy: addonForcedBy }),
         });
     }
     // ── Step 2: Agent gateways ─────────────────────────────────────────
@@ -193,7 +313,7 @@ export function analyzeDeployment(state, options) {
         const subAgentNames = agentMeta.agents ?? [];
         const unitName = `agent-${toSafeKebab(agentName)}`;
         // Agent gateway depends on its tool function units
-        const toolUnitNames = toolIds.map((id) => toSafeKebab(id));
+        const toolUnitNames = toolIds.map((id) => unitFor(id));
         const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toSafeKebab(sa)}`);
         // Agent needs AI services
         const agentServices = agentServiceRequirements();
@@ -271,7 +391,7 @@ export function analyzeDeployment(state, options) {
     const allMcpIds = [...mcpToolIds, ...mcpResourceIds, ...mcpPromptIds];
     if (allMcpIds.length > 0) {
         const unitName = 'mcp-server';
-        const mcpFuncUnitNames = allMcpIds.map((id) => toSafeKebab(id));
+        const mcpFuncUnitNames = allMcpIds.map((id) => unitFor(id));
         units.push({
             name: unitName,
             role: 'mcp',
@@ -280,7 +400,7 @@ export function analyzeDeployment(state, options) {
             services: [],
             dependsOn: mcpFuncUnitNames,
             handlers: [{ type: 'fetch', routes: [] }],
-            tags: collectTags(allMcpIds, functionsMeta),
+            tags: collectTags(allMcpIds, tagsFor),
         });
         mcpEndpoints.push({
             unitName,
@@ -295,7 +415,7 @@ export function analyzeDeployment(state, options) {
         if (funcIds.length === 0)
             continue;
         const unitName = `channel-${toSafeKebab(channelName)}`;
-        const funcUnitNames = funcIds.map((id) => toSafeKebab(id));
+        const funcUnitNames = funcIds.map((id) => unitFor(id));
         units.push({
             name: unitName,
             role: 'channel',
@@ -314,34 +434,35 @@ export function analyzeDeployment(state, options) {
         });
     }
     // ── Step 5: Workflows ──────────────────────────────────────────────
-    buildWorkflows(graphMeta, functionsMeta, { ...state.rpc?.exposedMeta, ...state.rpc?.internalMeta }, httpMeta, units, workflows, queues, workflowQueues);
+    buildWorkflows(graphMeta, functionsMeta, { ...state.rpc?.exposedMeta, ...state.rpc?.internalMeta }, httpMeta, units, workflows, queues, workflowQueues, unitFor);
     // ── Step 6: Ensure function units exist for gateway dependencies ───
     // Gateways depend on function units. If a function is only used via
     // a gateway (not directly wired to HTTP/queue/cron), it still needs
     // a unit with a fetch handler for RPC access.
-    const existingUnitNames = new Set(units.map((u) => u.name));
     const unitsSnapshot = Array.from(units);
     for (const unit of unitsSnapshot) {
         for (const dep of unit.dependsOn) {
-            if (!existingUnitNames.has(dep)) {
-                // Find the function ID for this dependency
-                const funcId = fromKebab(dep);
+            for (const funcId of unitFunctionIds.get(dep) ?? []) {
+                const existing = units.find((u) => u.name === dep);
+                if (existing?.functionIds.includes(funcId)) {
+                    continue;
+                }
                 const funcMeta = functionsMeta[funcId];
-                if (funcMeta) {
-                    const invokedAgents = collectInvokedAgents(state, funcId);
-                    units.push({
-                        name: dep,
-                        role: 'function',
-                        target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
-                        functionIds: [funcId],
-                        services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
-                        dependsOn: [],
-                        handlers: [{ type: 'fetch', routes: [] }],
-                        tags: funcMeta.tags ?? [],
-                        ...(invokedAgents.length > 0 && { invokedAgents }),
-                    });
-                    existingUnitNames.add(dep);
+                if (!funcMeta) {
+                    continue;
                 }
+                const invokedAgents = collectInvokedAgents(state, funcId);
+                addFunctionUnit({
+                    name: dep,
+                    role: 'function',
+                    target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
+                    functionIds: [funcId],
+                    services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
+                    dependsOn: [],
+                    handlers: [{ type: 'fetch', routes: [] }],
+                    tags: tagsFor(funcId),
+                    ...(invokedAgents.length > 0 && { invokedAgents }),
+                });
             }
         }
     }
@@ -557,7 +678,7 @@ export function analyzeDeployment(state, options) {
 // ---------------------------------------------------------------------------
 // Workflow builder
 // ---------------------------------------------------------------------------
-function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, workflows, queues, workflowQueues) {
+function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, workflows, queues, workflowQueues, unitFor) {
     for (const [_wfName, graph] of entries(graphMeta)) {
         const steps = [];
         const stepUnitNames = [];
@@ -566,7 +687,7 @@ function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, wor
                 continue;
             if (!('rpcName' in node))
                 continue;
-            const stepUnitName = toSafeKebab(node.rpcName);
+            const stepUnitName = unitFor(node.rpcName);
             // Step dispatch is decided per-function: a step runs inline unless its
             // function is marked `workflowQueued: true` (then it dispatches via queue).
             const stepFuncId = rpcMeta[node.rpcName] ?? node.rpcName;
@@ -654,7 +775,7 @@ function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, wor
                 const stepQueueName = `wf-step-${toSafeKebab(step.functionId)}`;
                 queues.push({
                     name: stepQueueName,
-                    consumerUnit: toSafeKebab(step.functionId),
+                    consumerUnit: unitFor(step.functionId),
                     consumerFunctionId: `pikkuWorkflowWorker:${step.functionId}`,
                 });
             }
@@ -797,32 +918,71 @@ function collectChannelFunctionIds(channelMeta) {
 // ---------------------------------------------------------------------------
 // Naming helpers
 // ---------------------------------------------------------------------------
-export function toSafeKebab(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-        .replace(/[:/\\]/g, '-')
-        .replace(/--+/g, '-')
-        .replace(/^-|-$/g, '')
-        .toLowerCase();
-}
-function fromKebab(str) {
-    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
+export { toSafeKebab } from './naming.js';
 // ---------------------------------------------------------------------------
 // Tag helpers
 // ---------------------------------------------------------------------------
-function collectTags(funcIds, functionsMeta) {
+function collectTags(funcIds, tagsFor) {
     const tags = new Set();
     for (const id of funcIds) {
-        const meta = functionsMeta[id];
-        if (meta?.tags) {
-            for (const tag of meta.tags)
-                tags.add(tag);
-        }
+        for (const tag of tagsFor(id))
+            tags.add(tag);
     }
     return [...tags];
 }
+/**
+ * Every tag that applies to a function, from the function itself and from every
+ * wiring that reaches it.
+ *
+ * Tags are almost always written on the wiring — `wireHTTP({ tags: ['todos'] })`
+ * — not on the `pikkuFunc`, so reading `FunctionMeta.tags` alone sees nothing in
+ * a typical project. `deploy.grouping` matches on the tags a user actually
+ * wrote, which means the union.
+ */
+function buildFunctionTagIndex(state, functionsMeta) {
+    const index = new Map();
+    const add = (funcId, tags) => {
+        if (!funcId || !tags?.length)
+            return;
+        let set = index.get(funcId);
+        if (!set) {
+            set = new Set();
+            index.set(funcId, set);
+        }
+        for (const tag of tags)
+            set.add(tag);
+    };
+    for (const [funcId, meta] of entries(functionsMeta)) {
+        add(funcId, meta.tags);
+    }
+    for (const method of HTTP_METHODS) {
+        const methodRoutes = state.http?.meta?.[method];
+        if (!methodRoutes)
+            continue;
+        for (const routeMeta of values(methodRoutes)) {
+            add(routeMeta.pikkuFuncId, routeMeta.tags);
+        }
+    }
+    for (const meta of values(state.queueWorkers?.meta ?? {})) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const meta of values(state.scheduledTasks?.meta ?? {})) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const meta of [
+        ...values(state.mcpEndpoints?.toolsMeta ?? {}),
+        ...values(state.mcpEndpoints?.resourcesMeta ?? {}),
+        ...values(state.mcpEndpoints?.promptsMeta ?? {}),
+    ]) {
+        add(meta.pikkuFuncId, meta.tags);
+    }
+    for (const channelMeta of values(state.channels?.meta ?? {})) {
+        for (const funcId of collectChannelFunctionIds(channelMeta)) {
+            add(funcId, channelMeta.tags);
+        }
+    }
+    return new Map([...index].map(([funcId, tags]) => [funcId, [...tags]]));
+}
 // ---------------------------------------------------------------------------
 // Typed iteration helpers
 // ---------------------------------------------------------------------------

package/dist/src/deploy/analyzer/grouping.d.ts

@@ -0,0 +1,57 @@
+import type { GroupingRule } from '@pikku/deploy';
+export type GroupingStrategy = 'function' | 'single' | 'services';
+export type { GroupingRule } from '@pikku/deploy';
+export interface GroupingConfig {
+    /**
+     * Defaults to `'services'`: one unit per distinct service combination. The
+     * alternatives are `'function'` (one unit per function — the smallest bundles
+     * and the most of them) and `'single'` (everything in one).
+     */
+    strategy?: GroupingStrategy;
+    rules?: GroupingRule[];
+}
+export interface UnitResolverInput {
+    routesForFunction: (funcId: string) => string[];
+    tagsForFunction: (funcId: string) => string[];
+    /**
+     * The singleton services the function's own body destructures. Only used by
+     * `strategy: 'services'`, which keys a unit on this set.
+     */
+    servicesForFunction: (funcId: string) => string[];
+    /**
+     * Where the function runs. Part of the `strategy: 'services'` key, because a
+     * target is not always implied by the services: a function carrying no
+     * serverless-incompatible service can still name `deploy: 'server'` itself,
+     * and merging it with a serverless function that happens to build the same
+     * services is the one grouping a target refusal exists to stop.
+     */
+    targetForFunction: (funcId: string) => 'serverless' | 'server';
+}
+export interface UnitResolver {
+    forFunction: (funcId: string) => string;
+    forAddon: (namespace: string) => string;
+    isGrouped: boolean;
+    ruleForUnit: (unitName: string) => GroupingRule | undefined;
+    /**
+     * The service set that named a unit under `strategy: 'services'`, or
+     * undefined for a unit that came from a rule or from one-per-function. The
+     * manifest's own `services` list cannot stand in for it: that list is keyed
+     * by capability, so `workflowService` and `workflowRunService` both arrive as
+     * `workflow-state` and two genuinely different units read as identical.
+     */
+    serviceKeyForUnit: (unitName: string) => string[] | undefined;
+}
+/**
+ * The distinguishing services in a set: what is left once the services every
+ * unit gets regardless are removed. This is the grouping key.
+ */
+export declare const serviceKey: (services: string[]) => string[];
+/**
+ * The unit name for one service set. Names the services themselves so a plan
+ * reads as what each unit builds; a set too long to spell out keeps the first
+ * few names and a digest of the whole set, which stays stable for that exact
+ * set and distinct from every other.
+ */
+export declare const serviceUnitName: (services: string[], target?: 'serverless' | 'server') => string;
+export declare const validateGrouping: (config: GroupingConfig) => void;
+export declare const createUnitResolver: (config: GroupingConfig | undefined, input: UnitResolverInput) => UnitResolver;

package/dist/src/deploy/analyzer/grouping.js

@@ -0,0 +1,148 @@
+import { createHash } from 'node:crypto';
+import { toSafeKebab } from './naming.js';
+const SINGLE_UNIT_NAME = 'app';
+/**
+ * One unit per distinct service combination. `'function'` gives a deployment
+ * as many units as it has functions, which is a cold start and a deploy step
+ * each for bundles that mostly build the same services.
+ */
+const DEFAULT_STRATEGY = 'services';
+/**
+ * Services every unit is given regardless of what it holds, so they say nothing
+ * about which functions belong together. `config`, `logger`, `variables`,
+ * `schema` and `secrets` are written into every generated services map as
+ * `defaultServices`; `rpc`, `mcp`, `channel` and `userSession` are the
+ * per-request services the inspector already excludes from tree-shaking.
+ *
+ * Only the base set is subtracted. A service that happens to be app-wide today
+ * — `auth` under a declared auth definition, say — is left in the key on
+ * purpose: it is constant, so it cannot split a partition, and dropping it
+ * would make the unit name lie about what the unit builds.
+ */
+const BASE_SERVICES = new Set([
+    'config',
+    'logger',
+    'variables',
+    'schema',
+    'secrets',
+    'rpc',
+    'mcp',
+    'channel',
+    'userSession',
+]);
+const SERVICE_UNIT_PREFIX = 'svc';
+/** Kept short enough to survive a provider's own name length limits. */
+const SERVICE_UNIT_NAME_LIMIT = 58;
+/**
+ * The distinguishing services in a set: what is left once the services every
+ * unit gets regardless are removed. This is the grouping key.
+ */
+export const serviceKey = (services) => [...new Set(services)].filter((service) => !BASE_SERVICES.has(service)).sort();
+/**
+ * The unit name for one service set. Names the services themselves so a plan
+ * reads as what each unit builds; a set too long to spell out keeps the first
+ * few names and a digest of the whole set, which stays stable for that exact
+ * set and distinct from every other.
+ */
+export const serviceUnitName = (services, target = 'serverless') => {
+    const suffix = target === 'server' ? '-server' : '';
+    const key = serviceKey(services);
+    if (key.length === 0) {
+        return `${SERVICE_UNIT_PREFIX}-base${suffix}`;
+    }
+    const full = `${SERVICE_UNIT_PREFIX}-${key.map(toSafeKebab).join('-')}${suffix}`;
+    if (full.length <= SERVICE_UNIT_NAME_LIMIT) {
+        return full;
+    }
+    const digest = createHash('sha256')
+        .update(key.join(','))
+        .digest('hex')
+        .slice(0, 6);
+    const room = SERVICE_UNIT_NAME_LIMIT - digest.length - suffix.length - 1;
+    return `${full.slice(0, room).replace(/-+$/, '')}-${digest}${suffix}`;
+};
+const routeMatcher = (pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+};
+export const validateGrouping = (config) => {
+    const rules = config.rules ?? [];
+    const seen = new Set();
+    for (const rule of rules) {
+        if (!rule.unit) {
+            throw new Error(`deploy.grouping: every rule needs a "unit" name (offending rule: ${JSON.stringify(rule)})`);
+        }
+        if (seen.has(rule.unit)) {
+            throw new Error(`deploy.grouping: two rules both name the unit "${rule.unit}". Merge them into one rule.`);
+        }
+        seen.add(rule.unit);
+        if (!rule.tags?.length && !rule.addon && !rule.routes?.length) {
+            throw new Error(`deploy.grouping: rule "${rule.unit}" matches nothing. Give it at least one of "tags", "addon" or "routes".`);
+        }
+    }
+};
+export const createUnitResolver = (config, input) => {
+    const strategy = config?.strategy ?? DEFAULT_STRATEGY;
+    const rules = config?.rules ?? [];
+    if (config) {
+        validateGrouping(config);
+    }
+    const compiled = rules.map((rule) => ({
+        rule,
+        unit: toSafeKebab(rule.unit),
+        tags: rule.tags,
+        addon: rule.addon,
+        routes: rule.routes?.map(routeMatcher),
+    }));
+    const byUnitName = new Map(compiled.map((c) => [c.unit, c.rule]));
+    const serviceKeys = new Map();
+    const matches = (c, tags, routes, addon) => {
+        if (c.tags && !c.tags.some((tag) => tags.includes(tag))) {
+            return false;
+        }
+        if (c.addon && c.addon !== addon) {
+            return false;
+        }
+        if (c.routes && !c.routes.some((re) => routes.some((r) => re.test(r)))) {
+            return false;
+        }
+        return true;
+    };
+    const fallback = (funcId) => {
+        if (strategy === 'single') {
+            return SINGLE_UNIT_NAME;
+        }
+        if (strategy === 'services') {
+            const services = input.servicesForFunction(funcId);
+            const name = serviceUnitName(services, input.targetForFunction(funcId));
+            serviceKeys.set(name, serviceKey(services));
+            return name;
+        }
+        return toSafeKebab(funcId);
+    };
+    return {
+        isGrouped: strategy !== 'function' || compiled.length > 0,
+        ruleForUnit: (unitName) => byUnitName.get(unitName),
+        serviceKeyForUnit: (unitName) => serviceKeys.get(unitName),
+        forFunction: (funcId) => {
+            if (compiled.length > 0) {
+                const tags = input.tagsForFunction(funcId);
+                const routes = input.routesForFunction(funcId);
+                for (const c of compiled) {
+                    if (matches(c, tags, routes, undefined)) {
+                        return c.unit;
+                    }
+                }
+            }
+            return fallback(funcId);
+        },
+        forAddon: (namespace) => {
+            for (const c of compiled) {
+                if (c.addon === namespace && !c.tags && !c.routes) {
+                    return c.unit;
+                }
+            }
+            return `addon-${toSafeKebab(namespace)}`;
+        },
+    };
+};

package/dist/src/deploy/analyzer/index.d.ts

@@ -1,2 +1,3 @@
 export { analyzeDeployment } from './analyzer.js';
 export type { AnalyzerOptions } from './analyzer.js';
+export type { GroupingConfig, GroupingRule, GroupingStrategy, } from './grouping.js';

package/dist/src/deploy/analyzer/naming.d.ts

@@ -0,0 +1 @@
+export declare function toSafeKebab(str: string): string;

package/dist/src/deploy/analyzer/naming.js

@@ -0,0 +1,9 @@
+export function toSafeKebab(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[:/\\]/g, '-')
+        .replace(/--+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}

package/dist/src/deploy/build-pipeline.d.ts

@@ -6,6 +6,7 @@
  */
 import type { InspectorState } from '@pikku/inspector';
 import { PikkuError } from '@pikku/core/errors';
+import type { GroupingConfig } from './analyzer/index.js';
 import type { DeploymentManifest } from '@pikku/deploy';
 import type { Bundler } from './bundler/bundler.interface.js';
 import type { BundleResult } from './bundler/types.js';
@@ -50,6 +51,7 @@ export declare function runBuildPipeline(options: {
     inspectorState: InspectorState;
     serverlessIncompatible?: string[];
     defaultTarget?: 'serverless' | 'server';
+    grouping?: GroupingConfig;
     globalHTTPPrefix?: string;
     getEntryContext: (unitDir: string, pikkuDir: string, unit: DeploymentManifest['units'][0], state: InspectorState) => unknown;
     /**