@pikku/cli 0.12.105 → 0.12.107

package/dist/src/functions/wirings/middleware/serialize-middleware-types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates the middleware authoring surface — every way a project declares or
+ * registers middleware, whatever wiring it ends up attached to.
+ *
+ * Middleware is one concept, so it is one leaf. `PikkuMiddleware` is declared
+ * here rather than alongside the function types that consume it; those types
+ * import it back, which is a type-only edge and carries no runtime cycle.
+ */
+export declare const serializeMiddlewareTypes: (functionTypesImportPath: string, packageName?: string) => string;

package/dist/src/functions/wirings/middleware/serialize-middleware-types.js

@@ -0,0 +1,176 @@
+/**
+ * Generates the middleware authoring surface — every way a project declares or
+ * registers middleware, whatever wiring it ends up attached to.
+ *
+ * Middleware is one concept, so it is one leaf. `PikkuMiddleware` is declared
+ * here rather than alongside the function types that consume it; those types
+ * import it back, which is a type-only edge and carries no runtime cycle.
+ */
+export const serializeMiddlewareTypes = (functionTypesImportPath, packageName) => {
+    const packageNameValue = packageName ? `'${packageName}'` : 'null';
+    return `/**
+ * Middleware type definitions and registration for all wirings
+ */
+
+import type { CorePikkuMiddleware, MiddlewarePriority } from '@pikku/core/middleware'
+import { addTagMiddleware as addTagMiddlewareCore, addGlobalMiddleware as addGlobalMiddlewareCore, pikkuMiddleware as pikkuMiddlewareCore } from '@pikku/core/middleware'
+import { addHTTPMiddleware as addHTTPMiddlewareCore } from '@pikku/core/http'
+import {
+  CorePikkuChannelMiddleware,
+  CorePikkuChannelMiddlewareFactory,
+  addChannelMiddleware as addChannelMiddlewareCore,
+} from '@pikku/core/channel'
+import type { PikkuAgentMiddlewareHooks } from '@pikku/core/agent'
+import type { Services, SingletonServices, WiredSingletonServices } from '${functionTypesImportPath}'
+
+export { cors } from '@pikku/core/middleware'
+export type { MiddlewarePriority }
+
+/**
+ * Type-safe middleware definition that can access your application's services and session.
+ * Use this to define reusable middleware that can be applied to multiple wirings.
+ *
+ * @template RequiredServices - The services required for this middleware
+ */
+export type PikkuMiddleware<RequiredServices extends SingletonServices = WiredSingletonServices> = CorePikkuMiddleware<RequiredServices>
+
+/**
+ * Configuration object for creating middleware with metadata
+ */
+type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = WiredSingletonServices> = {
+  /** The middleware function */
+  func: PikkuMiddleware<RequiredServices>
+  /** Optional human-readable name for the middleware */
+  name?: string
+  /** Optional description of what the middleware does */
+  description?: string
+  /** Execution priority. \`highest\` runs first (outermost). Defaults to 'medium'. */
+  priority?: MiddlewarePriority
+}
+
+/**
+ * Factory function for creating middleware with tree-shaking support.
+ * Supports both direct function and configuration object syntax.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Direct function syntax
+ * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
+ *   logger.info('Middleware executed')
+ *   await next()
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs all incoming requests',
+ *   priority: 'high',
+ *   func: async ({ logger }, wires, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddleware = <RequiredServices extends SingletonServices = WiredSingletonServices>(
+  middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>
+): PikkuMiddleware<RequiredServices> => {
+  return pikkuMiddlewareCore(middleware)
+}
+
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddlewareFactory = <In = any>(
+  factory: (input: In) => PikkuMiddleware
+): ((input: In) => PikkuMiddleware) => {
+  return factory
+}
+
+/**
+ * Wire-agnostic global middleware. Runs at the top of every wiring's
+ * middleware chain — before wire-, tag-, and function-level entries.
+ *
+ * Resolution order: global -> wire -> tag -> function.
+ *
+ * @example
+ * addGlobalMiddleware([telemetryMiddleware])
+ */
+export const addGlobalMiddleware = (middleware: PikkuMiddleware[]) => {
+  addGlobalMiddlewareCore(middleware as any, ${packageNameValue})
+}
+
+/**
+ * Tag-scoped middleware. Applies to any wiring that carries the matching tag.
+ *
+ * @example
+ * addTagMiddleware('admin', [adminMiddleware])
+ */
+export const addTagMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
+  addTagMiddlewareCore(tag, middleware as any, ${packageNameValue})
+}
+/**
+ * Registers HTTP middleware either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with middleware, the middleware
+ * is applied only to that route. Otherwise, if an array is provided, it is treated
+ * as global middleware (applied to all routes).
+ *
+ * @param routeOrMiddleware - Either a global middleware array or a route pattern string
+ * @param middleware - The middleware array to apply when a route pattern is specified
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP middleware
+ * addHTTPMiddleware([authMiddleware, loggingMiddleware])
+ *
+ * // Add route-specific middleware
+ * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
+ * \`\`\`
+ */
+export const addHTTPMiddleware = (
+  routeOrMiddleware: PikkuMiddleware[] | string,
+  middleware?: PikkuMiddleware[]
+) => {
+  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
+}
+
+export type PikkuChannelMiddleware<RequiredServices extends Services = Services, Event = unknown> = CorePikkuChannelMiddleware<RequiredServices, Event>
+
+export const pikkuChannelMiddleware = <RequiredServices extends Services = Services, Event = unknown>(
+  middleware: PikkuChannelMiddleware<RequiredServices, Event>
+): PikkuChannelMiddleware<RequiredServices, Event> => {
+  return middleware
+}
+
+export const pikkuChannelMiddlewareFactory = <In = any>(
+  factory: CorePikkuChannelMiddlewareFactory<In>
+): CorePikkuChannelMiddlewareFactory<In> => {
+  return factory
+}
+
+export const addChannelMiddleware = (tag: string, middleware: PikkuChannelMiddleware[]) =>
+  addChannelMiddlewareCore(tag, middleware, ${packageNameValue})
+
+export const pikkuAgentMiddleware = <
+  State extends Record<string, unknown> = Record<string, unknown>,
+  RequiredServices extends Services = Services,
+>(
+  hooks: PikkuAgentMiddlewareHooks<State, RequiredServices>
+): PikkuAgentMiddlewareHooks<State, RequiredServices> => hooks
+`;
+};

package/dist/src/functions/wirings/package/pikku-command-package-types.d.ts

@@ -1,3 +1,3 @@
-export declare const pikkuSecretDefinitionTypes: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const pikkuScopeDefinitionTypes: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const pikkuVariableDefinitionTypes: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const pikkuSecretDefinitionTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuScopeDefinitionTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuVariableDefinitionTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/package/pikku-command-package-types.js

@@ -1,4 +1,4 @@
-import { pikkuVoidFunc } from '#pikku';
+import { pikkuVoidFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeScopeDefinitionTypes, serializeSecretDefinitionTypes, serializeVariableDefinitionTypes, } from './serialize-package-types.js';

package/dist/src/functions/wirings/package/pikku-command-package.d.ts

@@ -1 +1 @@
-export declare const pikkuPackage: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuPackage: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/package/pikku-command-package.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePackageFactories } from './serialize-package.js';

package/dist/src/functions/wirings/package/serialize-package-types.js

@@ -1,18 +1,13 @@
 export const serializeSecretDefinitionTypes = () => {
     return `export { defineSecret } from '@pikku/core/secret'
-export type { SecretDefinitionsMeta } from '@pikku/core/secret'
-export type { CoreSecret, SecretDefinitionMeta } from '@pikku/core/ecosystem/secret'
 `;
 };
 export const serializeScopeDefinitionTypes = () => {
-    return `export { defineScope } from '@pikku/core/ecosystem/scope'
-export type { CoreScopes, CoreScopeNode, FlatScope, ScopeDefinitionMeta, ScopeDefinitionsMeta } from '@pikku/core/ecosystem/scope'
-export { defineSystemRole } from '@pikku/core/ecosystem/role'
-export type { CoreSystemRole, CoreSystemRoles, SystemRole, SystemRoleDefinitionMeta, SystemRoleDefinitionsMeta } from '@pikku/core/ecosystem/role'
+    return `export { defineScope } from '@pikku/core/scope'
+export { defineSystemRole } from '@pikku/core/role'
 `;
 };
 export const serializeVariableDefinitionTypes = () => {
     return `export { defineVariable } from '@pikku/core/variable'
-export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/ecosystem/variable'
 `;
 };

package/dist/src/functions/wirings/package/serialize-package.js

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}, credentialsMeta, requiredParentServices, declaredSecrets) => {
     const imports = [
-        `import { pikkuState } from '@pikku/core/ecosystem'`,
+        `import { pikkuState } from '@pikku/core/state'`,
     ];
     const factoryEntries = [];
     if (configFactory) {

package/dist/src/functions/wirings/permissions/pikku-command-permissions.d.ts

@@ -1 +1 @@
-export declare const pikkuPermissions: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuPermissions: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/permissions/pikku-command-permissions.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePermissionsImports } from './serialize-permissions-imports.js';

package/dist/src/functions/wirings/personas/pikku-command-personas.d.ts

@@ -1,7 +1,7 @@
-export declare const pikkuPersonas: import("#pikku").PikkuFunctionConfig<{
+export declare const pikkuPersonas: import("#pikku/function").PikkuFunctionConfig<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/personas/pikku-command-personas.js

@@ -1,13 +1,13 @@
 import { existsSync } from 'node:fs';
 import { rm } from 'node:fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePersonasTypes } from './serialize-personas-types.js';
 import { serializePersonasSecrets } from './serialize-personas-secrets.js';
 import { personasSecretsFilePath } from './personas-secrets-file.js';
-import { personaEnvironmentErrors, validateAndBuildPersonasMeta, } from '@pikku/core/ecosystem/persona';
+import { personaEnvironmentErrors, validateAndBuildPersonasMeta, } from '@pikku/core/persona';
 export const pikkuPersonas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
         const { personasFile, personasMetaJsonFile, rolesFile, packageMappings } = config;

package/dist/src/functions/wirings/personas/serialize-personas-types.d.ts

@@ -1,4 +1,4 @@
-import type { PersonaDefinitions } from '@pikku/core/ecosystem/persona';
+import type { PersonaDefinitions } from '@pikku/core/persona';
 export interface SerializePersonasOptions {
     definitions: PersonaDefinitions;
     /** Relative import path to the generated roles file. */
@@ -15,4 +15,4 @@ export interface SerializePersonasOptions {
  * failure — a scatter of 403s in a run days later — looks nothing like the
  * mistake. Typed as `SystemRoleName[]`, it is a red squiggle in the editor.
  */
-export declare const serializePersonasTypes: ({ definitions, rolesImportPath, environmentNames, }: SerializePersonasOptions) => string;
+export declare const serializePersonasTypes: ({ rolesImportPath, environmentNames, }: SerializePersonasOptions) => string;

package/dist/src/functions/wirings/personas/serialize-personas-types.js

@@ -8,47 +8,24 @@ const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
  * failure — a scatter of 403s in a run days later — looks nothing like the
  * mistake. Typed as `SystemRoleName[]`, it is a red squiggle in the editor.
  */
-export const serializePersonasTypes = ({ definitions, rolesImportPath, environmentNames, }) => {
-    const ids = [...new Set(definitions.map((d) => d.id))].sort();
+export const serializePersonasTypes = ({ rolesImportPath, environmentNames, }) => {
     const environmentUnion = environmentNames.length > 0
         ? `\n${[...environmentNames]
             .sort()
             .map((name) => `  | ${quote(name)}`)
             .join('\n')}`
         : ' never';
-    const union = ids.length > 0
-        ? `\n${ids.map((id) => `  | ${quote(id)}`).join('\n')}`
-        : ' never';
-    const runnable = definitions
-        .filter((d) => d.runnable)
-        .map((d) => d.id)
-        .sort();
-    const runnableUnion = runnable.length > 0
-        ? `\n${runnable.map((id) => `  | ${quote(id)}`).join('\n')}`
-        : ' never';
     return `/**
  * This file was generated by the @pikku/cli
  */
 import { definePersonas as definePersonasCore } from '@pikku/core/persona'
 import type { PersonaMeta, PersonasMeta } from '@pikku/core/persona'
-import type { CorePersona } from '@pikku/core/ecosystem/persona'
+import type { CorePersona } from '@pikku/core/persona'
 import type { SystemRoleName } from '${rolesImportPath}'
 import definitions from './pikku-personas-meta.gen.json' with { type: 'json' }
 
-/** Every declared persona. */
-export type PersonaId =${union}
-
-/**
- * The personas a virtual user can actually be.
- *
- * Excludes anyone whose only login is a provider account — driving a consent
- * screen needs a human — and anyone declared \`runnable: false\`, who exists to
- * be acted upon rather than to act.
- */
-export type RunnablePersonaId =${runnableUnion}
-
 /** Every environment configured in pikku.config.json. */
-export type EnvironmentName =${environmentUnion}
+type EnvironmentName =${environmentUnion}
 
 /**
  * A persona whose roles are checked against \`defineSystemRole\` and whose
@@ -59,7 +36,7 @@ export type EnvironmentName =${environmentUnion}
  * \`disposition: 'accountable'\`, which the type cannot express and \`pikku\`
  * refuses at build time.
  */
-export type TypedPersona = Omit<CorePersona, 'roles' | 'environments'> & {
+type TypedPersona = Omit<CorePersona, 'roles' | 'environments'> & {
   roles?: SystemRoleName[]
   environments?: EnvironmentName[]
 }

package/dist/src/functions/wirings/queue/pikku-command-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuCommandQueueMap: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuCommandQueueMap: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue-map.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';

package/dist/src/functions/wirings/queue/pikku-command-queue-service.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueService: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuQueueService: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue-service.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/pikku-command-queue-types.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuQueueTypes: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -7,7 +7,9 @@ export const pikkuQueueTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { queueTypesFile, functionTypesFile, packageMappings } = config;
         const functionTypesImportPath = getFileImportRelativePath(queueTypesFile, functionTypesFile, packageMappings);
-        const content = serializeQueueTypes(functionTypesImportPath);
+        const content = serializeQueueTypes(functionTypesImportPath, {
+            addon: !!config.addon,
+        });
         await writeFileInDir(logger, queueTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/queue/pikku-command-queue.d.ts

@@ -1 +1 @@
-export declare const pikkuCommandQueue: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuCommandQueue: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/pikku-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueMap: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuQueueMap: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-queue-map.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';

package/dist/src/functions/wirings/queue/pikku-queue.d.ts

@@ -1 +1 @@
-export declare const pikkuQueue: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuQueue: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/serialize-queue-map.d.ts

@@ -1,4 +1,4 @@
-import type { QueueWorkersMeta } from '@pikku/core/ecosystem/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 import type { TypesMap } from '@pikku/inspector';
 import type { Logger } from '@pikku/core/services';
 export declare const serializeQueueMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, queueWorkersMeta: QueueWorkersMeta, resolvedIOTypes: Record<string, {

package/dist/src/functions/wirings/queue/serialize-queue-map.js

@@ -13,7 +13,7 @@ ${serializedImportMap}
 ${serializedCustomTypes}
 
 import type { QueueJob } from '@pikku/core/queue'
-import type { Safe } from '@pikku/core'
+import type { Safe } from '@pikku/core/classification'
 
 interface QueueHandler<I, O> {
     input: I;

package/dist/src/functions/wirings/queue/serialize-queue-meta.d.ts

@@ -1,3 +1,3 @@
-import type { QueueWorkersMeta } from '@pikku/core/ecosystem/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 export declare const serializeQueueMeta: (queueWorkersMeta: QueueWorkersMeta) => QueueWorkersMeta;
 export declare const serializeQueueMetaTS: (jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/queue/serialize-queue-types.d.ts

@@ -1,4 +1,6 @@
 /**
  * Generates type definitions for queue wirings
  */
-export declare const serializeQueueTypes: (functionTypesImportPath: string) => string;
+export declare const serializeQueueTypes: (functionTypesImportPath: string, { addon }?: {
+    addon?: boolean;
+}) => string;

package/dist/src/functions/wirings/queue/serialize-queue-types.js

@@ -1,14 +1,14 @@
 /**
  * Generates type definitions for queue wirings
  */
-export const serializeQueueTypes = (functionTypesImportPath) => {
+export const serializeQueueTypes = (functionTypesImportPath, { addon = false } = {}) => {
     return `/**
  * Queue-specific type definitions for tree-shaking optimization
  */
 
-import { wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
-import { CoreQueueWorker } from '@pikku/core/ecosystem/queue'
-import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+${addon ? '' : `import { wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'\n`}${addon
+        ? ''
+        : `import { CoreQueueWorker } from '@pikku/core/queue'\nimport type { PikkuFunctionConfig } from '${functionTypesImportPath}'
 
 /**
  * Type definition for queue workers that process background jobs.
@@ -17,7 +17,9 @@ import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
  * @template Out - Output type for the queue job
  */
 type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
-
+`}${addon
+        ? ''
+        : `
 /**
  * Registers a queue worker with the Pikku framework.
  * Workers process background jobs from queues.
@@ -27,5 +29,5 @@ type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'sessio
 export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
   wireQueueWorkerCore(queueWorker as any)
 }
-`;
+`}`;
 };

package/dist/src/functions/wirings/queue/serialize-queue-wrapper.js

@@ -1,7 +1,7 @@
 export const serializeQueueWrapper = (queueMapPath) => {
     return `
 import type { QueueService, QueueJob } from '@pikku/core/queue'
-import type { Safe } from '@pikku/core'
+import type { Safe } from '@pikku/core/classification'
 import type { QueueMap, TypedPikkuQueue } from '${queueMapPath}'
 
 export class PikkuQueue implements TypedPikkuQueue {

package/dist/src/functions/wirings/realtime/pikku-command-events-scaffold.d.ts

@@ -1 +1 @@
-export declare const pikkuEventsScaffold: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuEventsScaffold: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/realtime/pikku-command-events-scaffold.js

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
@@ -17,8 +17,7 @@ export const pikkuEventsScaffold = pikkuSessionlessFunc({
             return false;
         }
         const authRequired = resolveScaffoldFeature('events', config.scaffold.events).auth;
-        const pikkuTypesImportPath = getFileImportRelativePath(config.eventsChannelFile, config.typesDeclarationFile, config.packageMappings);
-        const { schemas, functions } = serializeEventsScaffold(authRequired, pikkuTypesImportPath);
+        const { schemas, functions } = serializeEventsScaffold(authRequired, (name) => getLeafImportPath(config.eventsChannelFile, name, config));
         await writeFileInDir(logger, config.eventsSchemasFile, schemas);
         await writeFileInDir(logger, config.eventsChannelFile, functions);
         await removeLegacyScaffoldFile(config.eventsChannelFile);

package/dist/src/functions/wirings/realtime/pikku-command-realtime.d.ts

@@ -1 +1 @@
-export declare const pikkuRealtime: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuRealtime: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/realtime/pikku-command-realtime.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.d.ts

@@ -21,4 +21,4 @@ export interface EventsGenOutput {
  * publish-side ergonomics (envelope shape) are documented in the
  * pikku-realtime skill.
  */
-export declare const serializeEventsScaffold: (authRequired: boolean, pikkuTypesImportPath: string) => EventsGenOutput;
+export declare const serializeEventsScaffold: (authRequired: boolean, leaf: (name: string) => string) => EventsGenOutput;

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.js

@@ -17,7 +17,7 @@
  * publish-side ergonomics (envelope shape) are documented in the
  * pikku-realtime skill.
  */
-export const serializeEventsScaffold = (authRequired, pikkuTypesImportPath) => {
+export const serializeEventsScaffold = (authRequired, leaf) => {
     const auth = authRequired ? 'true' : 'false';
     const schemas = `/**
  * Auto-generated realtime event schemas
@@ -27,13 +27,9 @@ import { z } from 'zod'
 
 export const TopicRef = z.object({ topic: z.string() })
 `;
-    const functions = `import {
-  pikkuChannelFunc,
-  pikkuSessionlessFunc,
-  wireChannel,
-  wireHTTP,
-  defineChannelRoutes,
-} from '${pikkuTypesImportPath}'
+    const functions = `import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { pikkuChannelFunc, wireChannel, defineChannelRoutes } from '${leaf('channel')}'
+import { wireHTTP } from '${leaf('http')}'
 import { TopicRef } from './events.schemas.gen.js'
 
 /**