@pikku/core 0.12.0 → 0.12.2

package/dist/pikku-state.js

@@ -1,7 +1,15 @@
+const PIKKU_STATE_KEY = Symbol.for('@pikku/core/state');
+export const getAllPackageStates = () => {
+    if (!globalThis[PIKKU_STATE_KEY]) {
+        ;
+        globalThis[PIKKU_STATE_KEY] = new Map();
+    }
+    return globalThis[PIKKU_STATE_KEY];
+};
 /**
  * Get or set package-scoped pikku state
  *
- * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param packageName - Package name (null for main package, '@scope/package' for addon packages)
  * @param type - State category (function, rpc, http, etc.)
  * @param content - Content key within the category
  * @param value - Optional value to set
@@ -11,17 +19,16 @@
  * // Main package
  * pikkuState(null, 'function', 'functions').get(funcName)
  *
- * // External package
+ * // Addon package
  * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
  */
 export const pikkuState = (packageName, type, content, value) => {
     const resolvedPackageName = packageName ?? '__main__';
     // Initialize package state if it doesn't exist
-    if (!globalThis.pikkuState ||
-        !globalThis.pikkuState.has(resolvedPackageName)) {
+    if (!getAllPackageStates().has(resolvedPackageName)) {
         initializePikkuState(resolvedPackageName);
     }
-    const packageState = globalThis.pikkuState.get(resolvedPackageName);
+    const packageState = getAllPackageStates().get(resolvedPackageName);
     if (value !== undefined) {
         packageState[type][content] = value;
     }
@@ -35,7 +42,7 @@ const createEmptyPackageState = () => ({
     rpc: {
         meta: {},
         files: new Map(),
-        externalPackages: new Map(),
+        addons: new Map(),
     },
     http: {
         middleware: new Map(),
@@ -85,6 +92,10 @@ const createEmptyPackageState = () => ({
         agents: new Map(),
         agentsMeta: {},
     },
+    gateway: {
+        gateways: new Map(),
+        meta: {},
+    },
     cli: {
         meta: { programs: {}, renderers: {} },
         programs: {},
@@ -120,35 +131,41 @@ const createEmptyPackageState = () => ({
  * Initialize state for a new package
  */
 export const initializePikkuState = (packageName) => {
-    if (!globalThis.pikkuState) {
-        globalThis.pikkuState = new Map();
-    }
-    if (!globalThis.pikkuState.has(packageName)) {
-        globalThis.pikkuState.set(packageName, createEmptyPackageState());
+    if (!getAllPackageStates().has(packageName)) {
+        getAllPackageStates().set(packageName, createEmptyPackageState());
     }
 };
 export const resetPikkuState = () => {
     // Preserve the errors map before resetting
-    const existingErrors = globalThis.pikkuState?.get('__main__')?.misc.errors;
-    globalThis.pikkuState = new Map();
+    const existingErrors = getAllPackageStates().get('__main__')?.misc.errors;
+    globalThis[PIKKU_STATE_KEY] = new Map();
     initializePikkuState('__main__');
     // Restore the errors map if it existed
     if (existingErrors) {
-        const mainState = globalThis.pikkuState.get('__main__');
+        const mainState = getAllPackageStates().get('__main__');
         mainState.misc.errors = existingErrors;
     }
 };
-if (!globalThis.pikkuState) {
+if (!getAllPackageStates().has('__main__')) {
     resetPikkuState();
 }
 export const getPikkuMetaDir = (packageName) => {
     return pikkuState(packageName ?? null, 'package', 'metaDir');
 };
+export const getSingletonServices = () => {
+    const services = pikkuState(null, 'package', 'singletonServices');
+    if (!services)
+        throw new Error('Singleton services not initialized');
+    return services;
+};
+export const getCreateWireServices = () => {
+    return pikkuState(null, 'package', 'factories')?.createWireServices;
+};
 /**
- * Register service factories for an external package.
+ * Register service factories for an addon package.
  * These factories are used to create services when the package's functions are invoked.
  *
- * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param packageName - The package name (e.g., '@pikku/templates-function-addon')
  * @param factories - The service factory functions
  */
 export const addPackageServiceFactories = (packageName, factories) => {

package/dist/schema.d.ts

@@ -1,17 +1,17 @@
-import { Logger } from './services/logger.js';
-import { SchemaService } from './services/schema-service.js';
+import type { Logger } from './services/logger.js';
+import type { SchemaService } from './services/schema-service.js';
 /**
  * Adds a schema to the schemas map for a specific package.
  * @param name - The name of the schema.
  * @param value - The schema value.
- * @param packageName - The package name (null for main package, '@scope/package' for external packages).
+ * @param packageName - The package name (null for main package, '@scope/package' for addon packages).
  * @ignore
  */
 export declare const addSchema: (name: string, value: any, packageName?: string | null) => void;
 /**
  * Retrieves a schema from the schemas map for a specific package.
  * @param name - The name of the schema.
- * @param packageName - The package name (null for main package, '@scope/package' for external packages).
+ * @param packageName - The package name (null for main package, '@scope/package' for addon packages).
  * @returns The schema value or undefined if not found.
  * @ignore
  */

package/dist/schema.js

@@ -1,20 +1,21 @@
 import { MissingSchemaError, UnprocessableContentError, } from './errors/errors.js';
-import { pikkuState } from './pikku-state.js';
+import { pikkuState, getAllPackageStates } from './pikku-state.js';
 const schemaKey = (name, packageName) => packageName ? `${packageName}:${name}` : name;
 /**
  * Adds a schema to the schemas map for a specific package.
  * @param name - The name of the schema.
  * @param value - The schema value.
- * @param packageName - The package name (null for main package, '@scope/package' for external packages).
+ * @param packageName - The package name (null for main package, '@scope/package' for addon packages).
  * @ignore
  */
 export const addSchema = (name, value, packageName = null) => {
-    pikkuState(packageName, 'misc', 'schemas').set(name, value);
+    const schema = value?.default ?? value;
+    pikkuState(packageName, 'misc', 'schemas').set(name, schema);
 };
 /**
  * Retrieves a schema from the schemas map for a specific package.
  * @param name - The name of the schema.
- * @param packageName - The package name (null for main package, '@scope/package' for external packages).
+ * @param packageName - The package name (null for main package, '@scope/package' for addon packages).
  * @returns The schema value or undefined if not found.
  * @ignore
  */
@@ -26,10 +27,13 @@ export const getSchema = (name, packageName = null) => {
  * @param logger - A logger for logging information.
  */
 export const compileAllSchemas = (logger, schemaService) => {
+    if (!schemaService) {
+        schemaService = pikkuState(null, 'package', 'singletonServices')?.schema;
+    }
     if (!schemaService) {
         throw new Error('SchemaService needs to be defined to load schemas');
     }
-    for (const [pkgName, packageState] of globalThis.pikkuState) {
+    for (const [pkgName, packageState] of getAllPackageStates()) {
         const resolvedPkgName = pkgName === '__main__' ? null : pkgName;
         for (const [name, schema] of packageState.misc.schemas) {
             schemaService.compileSchema(schemaKey(name, resolvedPkgName), schema);

package/dist/services/ai-agent-runner-service.d.ts

@@ -1,4 +1,4 @@
-import { AIMessage, AIAgentStep, AIAgentToolDef, AIStreamChannel } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AIMessage, AIAgentStep, AIAgentToolDef, AIStreamChannel } from '../wirings/ai-agent/ai-agent.types.js';
 export type AIAgentRunnerParams = {
     model: string;
     temperature?: number;
@@ -18,7 +18,26 @@ export type AIAgentRunnerResult = {
         outputTokens: number;
     };
 };
+export type AIAgentStepResult = {
+    text: string;
+    object?: unknown;
+    toolCalls: {
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }[];
+    toolResults: {
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    finishReason: 'stop' | 'tool-calls' | 'length' | 'error' | 'unknown';
+};
 export interface AIAgentRunnerService {
-    stream(params: AIAgentRunnerParams, channel: AIStreamChannel): Promise<void>;
-    run(params: AIAgentRunnerParams): Promise<AIAgentRunnerResult>;
+    stream(params: AIAgentRunnerParams, channel: AIStreamChannel): Promise<AIAgentStepResult>;
+    run(params: AIAgentRunnerParams): Promise<AIAgentStepResult>;
 }

package/dist/services/ai-run-state-service.d.ts

@@ -1,4 +1,4 @@
-import { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
 export type CreateRunInput = Omit<AgentRunState, 'runId'>;
 export interface AIRunStateService {
     createRun(run: CreateRunInput): Promise<string>;

package/dist/services/ai-storage-service.d.ts

@@ -1,4 +1,4 @@
-import { AIThread, AIMessage } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AIThread, AIMessage } from '../wirings/ai-agent/ai-agent.types.js';
 export interface AIStorageService {
     createThread(resourceId: string, options?: {
         threadId?: string;

package/dist/services/content-service.d.ts

@@ -49,4 +49,10 @@ export interface ContentService {
      * @returns A readable file stream.
      */
     readFile(assetKey: string): Promise<ReadableStream | NodeJS.ReadableStream>;
+    /**
+     * Reads an entire file from storage into a Buffer.
+     * @param assetKey - The key of the file to read.
+     * @returns The file contents as a Buffer.
+     */
+    readFileAsBuffer(assetKey: string): Promise<Buffer>;
 }

package/dist/services/gateway-service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Abstract GatewayService interface.
+ *
+ * Implementations manage listener gateway lifecycle — initializing adapters
+ * and delivering messages to handler functions.
+ *
+ * A `LocalGatewayService` starts all listeners unconditionally;
+ * a distributed implementation could check leader election first.
+ */
+export interface GatewayService {
+    /**
+     * Start all listener gateways
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all listener gateways
+     */
+    stop(): Promise<void>;
+}

package/dist/services/gopass-secrets.d.ts

@@ -1,4 +1,4 @@
-import { SecretService } from './secret-service.js';
+import type { SecretService } from './secret-service.js';
 /**
  * Service for retrieving secrets from gopass.
  * Requires gopass to be installed and configured on the system.

package/dist/services/gopass-secrets.js

@@ -13,6 +13,9 @@ export class GopassSecretService {
         this.prefix = prefix;
     }
     getFullKey(key) {
+        if (!/^[\w.\-/]+$/.test(key)) {
+            throw new Error(`Invalid secret key format: ${key}`);
+        }
         return this.prefix ? `${this.prefix}${key}` : key;
     }
     /**

package/dist/services/in-memory-ai-run-state-service.d.ts

@@ -0,0 +1,15 @@
+import type { AIRunStateService, CreateRunInput } from './ai-run-state-service.js';
+import type { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
+export declare class InMemoryAIRunStateService implements AIRunStateService {
+    private runs;
+    private counter;
+    createRun(run: CreateRunInput): Promise<string>;
+    updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
+    getRun(runId: string): Promise<AgentRunState | null>;
+    getRunsByThread(threadId: string): Promise<AgentRunState[]>;
+    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<void>;
+    findRunByToolCallId(toolCallId: string): Promise<{
+        run: AgentRunState;
+        approval: PendingApproval;
+    } | null>;
+}

package/dist/services/in-memory-ai-run-state-service.js

@@ -0,0 +1,44 @@
+export class InMemoryAIRunStateService {
+    runs = new Map();
+    counter = 0;
+    async createRun(run) {
+        const runId = `run-${++this.counter}-${Date.now()}`;
+        this.runs.set(runId, { ...run, runId });
+        return runId;
+    }
+    async updateRun(runId, updates) {
+        const run = this.runs.get(runId);
+        if (run) {
+            Object.assign(run, updates, { updatedAt: new Date() });
+        }
+    }
+    async getRun(runId) {
+        return this.runs.get(runId) ?? null;
+    }
+    async getRunsByThread(threadId) {
+        return [...this.runs.values()].filter((r) => r.threadId === threadId);
+    }
+    async resolveApproval(toolCallId, status) {
+        for (const run of this.runs.values()) {
+            if (run.pendingApprovals) {
+                const approval = run.pendingApprovals.find((a) => a.toolCallId === toolCallId);
+                if (approval) {
+                    run.pendingApprovals = run.pendingApprovals.filter((a) => a.toolCallId !== toolCallId);
+                    run.updatedAt = new Date();
+                    return;
+                }
+            }
+        }
+    }
+    async findRunByToolCallId(toolCallId) {
+        for (const run of this.runs.values()) {
+            if (run.pendingApprovals) {
+                const approval = run.pendingApprovals.find((a) => a.toolCallId === toolCallId);
+                if (approval) {
+                    return { run, approval };
+                }
+            }
+        }
+        return null;
+    }
+}

package/dist/services/in-memory-trigger-service.d.ts

@@ -11,7 +11,6 @@ import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js
  * @example
  * ```typescript
  * const triggerService = new InMemoryTriggerService()
- * triggerService.setServices(singletonServices, createWireServices)
  * await triggerService.start()
  *
  * // On shutdown

package/dist/services/in-memory-trigger-service.js

@@ -1,4 +1,5 @@
 import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js';
+import { getSingletonServices } from '../pikku-state.js';
 /**
  * In-memory TriggerService implementation.
  *
@@ -11,7 +12,6 @@ import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js
  * @example
  * ```typescript
  * const triggerService = new InMemoryTriggerService()
- * triggerService.setServices(singletonServices, createWireServices)
  * await triggerService.start()
  *
  * // On shutdown
@@ -20,9 +20,7 @@ import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js
  */
 export class InMemoryTriggerService extends PikkuTriggerService {
     async start() {
-        if (!this.singletonServices) {
-            throw new Error('InMemoryTriggerService requires singletonServices to start triggers');
-        }
+        const singletonServices = getSingletonServices();
         const triggerTargets = this.getTriggerTargets();
         const triggerSources = this.getTriggerSources();
         for (const [name, source] of triggerSources) {
@@ -31,20 +29,20 @@ export class InMemoryTriggerService extends PikkuTriggerService {
             }
             const targets = triggerTargets.get(name);
             if (!targets || targets.length === 0) {
-                this.singletonServices.logger.info(`Trigger source '${name}' has no targets, skipping`);
+                singletonServices.logger.info(`Trigger source '${name}' has no targets, skipping`);
                 continue;
             }
             try {
                 const triggerInstance = await this.setupTriggerInstance(name, source.input, (data) => this.onTriggerFire(name, targets, data));
                 this.activeTriggers.set(name, triggerInstance);
-                this.singletonServices.logger.info(`Started trigger: ${name}`);
+                singletonServices.logger.info(`Started trigger: ${name}`);
             }
             catch (error) {
-                this.singletonServices.logger.error(`Failed to start trigger ${name}: ${error}`);
+                singletonServices.logger.error(`Failed to start trigger ${name}: ${error}`);
             }
         }
         if (this.activeTriggers.size === 0) {
-            this.singletonServices.logger.info('No triggers started (no matching sources and targets found)');
+            singletonServices.logger.info('No triggers started (no matching sources and targets found)');
         }
     }
 }

package/dist/services/index.d.ts

@@ -11,6 +11,8 @@ export { LocalVariablesService } from './local-variables.js';
 export { ConsoleLogger } from './logger-console.js';
 export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
+export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { LocalGatewayService } from './local-gateway-service.js';
 export type { ContentService } from './content-service.js';
 export type { JWTService } from './jwt-service.js';
 export type { Logger } from './logger.js';
@@ -18,11 +20,12 @@ export type { SecretService } from './secret-service.js';
 export type { VariablesService } from './variables-service.js';
 export type { SchemaService } from './schema-service.js';
 export type { SessionService } from './user-session-service.js';
-export type { ScheduledTaskSummary, ScheduledTaskInfo, SchedulerRuntimeHandlers, SchedulerService, } from './scheduler-service.js';
+export type { ScheduledTaskSummary, ScheduledTaskInfo, SchedulerService, } from './scheduler-service.js';
 export type { TriggerService } from './trigger-service.js';
+export type { GatewayService } from './gateway-service.js';
 export type { DeploymentService, DeploymentConfig, DeploymentInfo, DeploymentServiceConfig, } from './deployment-service.js';
 export type { AIStorageService } from './ai-storage-service.js';
-export type { AIAgentRunnerParams, AIAgentRunnerResult, AIAgentRunnerService, } from './ai-agent-runner-service.js';
+export type { AIAgentRunnerParams, AIAgentRunnerResult, AIAgentStepResult, AIAgentRunnerService, } from './ai-agent-runner-service.js';
 export type { CreateRunInput, AIRunStateService, } from './ai-run-state-service.js';
 export type { CredentialStatus, CredentialMeta, } from './typed-secret-service.js';
 export type { VariableStatus, VariableMeta } from './typed-variables-service.js';

package/dist/services/index.js

@@ -11,3 +11,5 @@ export { LocalVariablesService } from './local-variables.js';
 export { ConsoleLogger } from './logger-console.js';
 export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
+export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { LocalGatewayService } from './local-gateway-service.js';

package/dist/services/local-content.d.ts

@@ -1,4 +1,4 @@
-import { ContentService, Logger } from '@pikku/core/services';
+import type { ContentService, Logger } from '@pikku/core/services';
 export interface LocalContentConfig {
     localFileUploadPath: string;
     uploadUrlPrefix: string;
@@ -20,6 +20,7 @@ export declare class LocalContent implements ContentService {
     writeFile(assetKey: string, stream: ReadableStream | NodeJS.ReadableStream): Promise<boolean>;
     copyFile(assetKey: string, fromAbsolutePath: string): Promise<boolean>;
     readFile(assetKey: string): Promise<ReadableStream | NodeJS.ReadableStream>;
+    readFileAsBuffer(assetKey: string): Promise<Buffer>;
     deleteFile(assetKey: string): Promise<boolean>;
     private createDirectoryForFile;
 }

package/dist/services/local-content.js

@@ -1,5 +1,5 @@
 import { createReadStream, createWriteStream, promises } from 'fs';
-import { mkdir } from 'fs/promises';
+import { mkdir, readFile } from 'fs/promises';
 import { pipeline } from 'stream/promises';
 export class LocalContent {
     config;
@@ -69,6 +69,11 @@ export class LocalContent {
             throw e;
         }
     }
+    async readFileAsBuffer(assetKey) {
+        const filePath = `${this.config.localFileUploadPath}/${assetKey}`;
+        this.logger.debug(`Reading file as buffer: ${assetKey}`);
+        return readFile(filePath);
+    }
     async deleteFile(assetKey) {
         this.logger.debug(`deleting key: ${assetKey}`);
         try {

package/dist/services/local-gateway-service.d.ts

@@ -0,0 +1,22 @@
+import type { GatewayService } from './gateway-service.js';
+/**
+ * Local GatewayService implementation.
+ *
+ * Starts all registered listener gateways unconditionally (single-process).
+ * For distributed deployments, implement `GatewayService` with leader
+ * election or similar coordination.
+ *
+ * @example
+ * ```typescript
+ * const gatewayService = new LocalGatewayService()
+ * await gatewayService.start()
+ *
+ * // On shutdown
+ * await gatewayService.stop()
+ * ```
+ */
+export declare class LocalGatewayService implements GatewayService {
+    private activeAdapters;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/services/local-gateway-service.js

@@ -0,0 +1,51 @@
+import { pikkuState, getSingletonServices } from '../pikku-state.js';
+import { createListenerMessageHandler } from '../wirings/gateway/gateway-runner.js';
+/**
+ * Local GatewayService implementation.
+ *
+ * Starts all registered listener gateways unconditionally (single-process).
+ * For distributed deployments, implement `GatewayService` with leader
+ * election or similar coordination.
+ *
+ * @example
+ * ```typescript
+ * const gatewayService = new LocalGatewayService()
+ * await gatewayService.start()
+ *
+ * // On shutdown
+ * await gatewayService.stop()
+ * ```
+ */
+export class LocalGatewayService {
+    activeAdapters = new Map();
+    async start() {
+        const singletonServices = getSingletonServices();
+        const gateways = pikkuState(null, 'gateway', 'gateways');
+        for (const [name, config] of gateways) {
+            if (config.type !== 'listener')
+                continue;
+            if (this.activeAdapters.has(name))
+                continue;
+            const handleMessage = createListenerMessageHandler(name, config, singletonServices);
+            await config.adapter.init(handleMessage);
+            this.activeAdapters.set(name, config.adapter);
+            singletonServices.logger.info(`Started listener gateway: ${name}`);
+        }
+    }
+    async stop() {
+        for (const [name, adapter] of this.activeAdapters) {
+            try {
+                await adapter.close();
+            }
+            catch (e) {
+                try {
+                    getSingletonServices().logger.error(`Error closing listener gateway '${name}':`, e);
+                }
+                catch {
+                    // logger may not be available during shutdown
+                }
+            }
+        }
+        this.activeAdapters.clear();
+    }
+}

package/dist/services/local-secrets.d.ts

@@ -1,5 +1,5 @@
-import { SecretService } from './secret-service.js';
-import { VariablesService } from './variables-service.js';
+import type { SecretService } from './secret-service.js';
+import type { VariablesService } from './variables-service.js';
 /**
  * Service for retrieving secrets from environment variables.
  * Supports storing secrets locally in memory for CLI operations.

package/dist/services/local-variables.d.ts

@@ -1,4 +1,4 @@
-import { VariablesService } from './variables-service.js';
+import type { VariablesService } from './variables-service.js';
 export declare class LocalVariablesService implements VariablesService {
     private variables;
     constructor(variables?: Record<string, string | undefined>);

package/dist/services/logger-console.d.ts

@@ -1,4 +1,5 @@
-import { Logger, LogLevel } from './logger.js';
+import type { Logger } from './logger.js';
+import { LogLevel } from './logger.js';
 /**
  * A logger implementation that logs messages to the console.
  */

package/dist/services/scheduler-service.d.ts

@@ -1,5 +1,4 @@
 import type { CoreUserSession } from '../types/core.types.js';
-import type { Logger } from './logger.js';
 /**
  * Minimal metadata for listing scheduled tasks
  */
@@ -22,11 +21,6 @@ export interface ScheduledTaskInfo extends ScheduledTaskSummary {
     /** Task status */
     status?: 'scheduled' | 'active' | 'completed' | 'failed';
 }
-export interface SchedulerRuntimeHandlers {
-    logger: Logger;
-    invokeRPC: (rpcName: string, data?: any, session?: CoreUserSession) => Promise<void>;
-    runScheduledTask: (name: string) => Promise<void>;
-}
 /**
  * Abstract scheduler service for persistent scheduled task management
  * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
@@ -66,12 +60,6 @@ export declare abstract class SchedulerService {
      * Close any open connections
      */
     abstract close(): Promise<void>;
-    /**
-     * Set services needed for processing recurring tasks.
-     * Called after construction since the scheduler is created before
-     * singletonServices are fully assembled.
-     */
-    setServices(_handlers: SchedulerRuntimeHandlers): void;
     /**
      * Start recurring scheduled tasks
      */

package/dist/services/scheduler-service.js

@@ -3,12 +3,6 @@
  * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
  */
 export class SchedulerService {
-    /**
-     * Set services needed for processing recurring tasks.
-     * Called after construction since the scheduler is created before
-     * singletonServices are fully assembled.
-     */
-    setServices(_handlers) { }
     /**
      * Start recurring scheduled tasks
      */

package/dist/services/scoped-secret-service.d.ts

@@ -1,4 +1,4 @@
-import { SecretService } from './secret-service.js';
+import type { SecretService } from './secret-service.js';
 /**
  * A read-only wrapper around SecretService that restricts access
  * to only a defined set of allowed secret keys.

package/dist/services/trigger-service.d.ts

@@ -1,4 +1,3 @@
-import { CoreSingletonServices, CreateWireServices, CoreServices, CoreUserSession } from '../types/core.types.js';
 /**
  * Abstract TriggerService interface.
  *
@@ -6,12 +5,6 @@ import { CoreSingletonServices, CreateWireServices, CoreServices, CoreUserSessio
  * and dispatching to RPC targets or workflow starts.
  */
 export interface TriggerService {
-    /**
-     * Set services needed for processing triggers.
-     * Called after construction since the trigger service is created before
-     * singletonServices are fully assembled.
-     */
-    setServices(_singletonServices: CoreSingletonServices, _createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>): void;
     /**
      * Start all triggers
      */

package/dist/services/user-session-service.d.ts

@@ -1,5 +1,5 @@
-import { ChannelStore } from '../wirings/channel/channel-store.js';
-import { CoreUserSession } from '../types/core.types.js';
+import type { ChannelStore } from '../wirings/channel/channel-store.js';
+import type { CoreUserSession } from '../types/core.types.js';
 export interface SessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;
     initial: UserSession | undefined;
@@ -23,7 +23,7 @@ export declare class PikkuSessionService<UserSession extends CoreUserSession> im
     get(): Promise<UserSession> | UserSession | undefined;
 }
 export declare function createMiddlewareSessionWireProps<UserSession extends CoreUserSession>(session: SessionService<UserSession>): {
-    session: UserSession | Promise<UserSession> | undefined;
+    session: UserSession | undefined;
     setSession: (s: UserSession) => void;
     getSession: () => UserSession | Promise<UserSession> | undefined;
     hasSessionChanged: () => boolean;