@pikku/core 0.12.17 → 0.12.19

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -34,7 +34,7 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
     if (request instanceof Request) {
         http = createHTTPWire(new PikkuFetchHTTPRequest(request), response);
     }
-    const userSession = new PikkuSessionService(channelStore, channelId);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     const { channelConfig, openingData, meta } = await openChannel({
         channelId,
         request,
@@ -77,6 +77,11 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
                 channelMiddlewareMeta: meta.channelMiddleware,
             });
         }
+        // Store the pikkuUserId mapping after auth middleware has run
+        const pikkuUserId = userSession.getPikkuUserId();
+        if (pikkuUserId) {
+            await channelStore.setPikkuUserId(channelId, pikkuUserId);
+        }
         http?.response?.status(101);
     }
     catch (e) {
@@ -98,21 +103,27 @@ export const runChannelDisconnect = async ({ channelId, channelStore, channelHan
     // there's nothing to disconnect, so we can return early.
     let channelData;
     try {
-        channelData = await channelStore.getChannelAndSession(channelId);
+        channelData = await channelStore.getChannel(channelId);
     }
     catch {
         singletonServices.logger.info(`Channel ${channelId} not found during disconnect - already cleaned up`);
         return;
     }
-    const { openingData, channelName, session } = channelData;
+    const { openingData, channelName, pikkuUserId } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
         channelId,
         channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(channelStore, channelId);
-    userSession.setInitial(session);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
+    if (pikkuUserId) {
+        userSession.setPikkuUserId(pikkuUserId);
+        const session = await singletonServices.sessionStore?.get(pikkuUserId);
+        if (session) {
+            userSession.setInitial(session);
+        }
+    }
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
@@ -149,15 +160,21 @@ export const runChannelMessage = async ({ channelId, channelStore, channelHandle
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
-    const { openingData, channelName, session } = await channelStore.getChannelAndSession(channelId);
+    const { openingData, channelName, pikkuUserId } = await channelStore.getChannel(channelId);
     const { channel, channelHandler, channelConfig } = getVariablesForChannel({
         channelId,
         channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(channelStore, channelId);
-    userSession.setInitial(session);
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
+    if (pikkuUserId) {
+        userSession.setPikkuUserId(pikkuUserId);
+        const session = await singletonServices.sessionStore?.get(pikkuUserId);
+        if (session) {
+            userSession.setInitial(session);
+        }
+    }
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),

package/dist/wirings/cli/channel/cli-channel-runner.js

@@ -1,10 +1,12 @@
 import { pikkuState } from '../../../pikku-state.js';
 import { generateCommandHelp, parseCLIArguments } from '../command-parser.js';
 /**
- * Default JSON renderer for CLI output
+ * Default JSON renderer for CLI output. Emits single-line NDJSON so
+ * the output stays machine-parseable when the CLI is run with
+ * `--output json`; pretty-printing here would break NDJSON consumers.
  */
 const defaultJSONRenderer = (_services, data) => {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data));
 };
 /**
  * Execute a CLI program via WebSocket channel

package/dist/wirings/cli/cli-runner.js

@@ -17,10 +17,12 @@ export class CLIError extends Error {
     }
 }
 /**
- * Default JSON renderer for CLI output
+ * Default JSON renderer for CLI output. Emits single-line NDJSON so
+ * the output stays machine-parseable when the CLI is run with
+ * `--output json`; pretty-printing here would break NDJSON consumers.
  */
 const defaultJSONRenderer = (_services, data) => {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data));
 };
 /**
  * Registers a CLI command tree and all its functions
@@ -224,7 +226,7 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
         },
         state: 'open',
     };
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     const wire = {
         cli: {
             program,

package/dist/wirings/http/http-runner.js

@@ -201,9 +201,9 @@ export const createHTTPWire = (request, response) => {
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRoute = async (services, matchedRoute, http, options) => {
-    const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     // Attach URL parameters to the request object
     http?.request?.setParams(params);
     // Validate request headers if schema is defined

package/dist/wirings/mcp/mcp-runner.js

@@ -103,7 +103,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { mcp: mcp
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
-        const mcpSessionService = new PikkuSessionService();
+        const mcpSessionService = new PikkuSessionService(singletonServices.sessionStore);
         const wire = {
             mcp: mcpWire,
             ...createMiddlewareSessionWireProps(mcpSessionService),

package/dist/wirings/scheduler/scheduler-runner.js

@@ -41,7 +41,7 @@ export async function runScheduledTask({ name, session, traceId, }) {
         singletonServices.logger;
     const task = pikkuState(null, 'scheduler', 'tasks').get(name);
     const meta = pikkuState(null, 'scheduler', 'meta')[name];
-    const userSession = new PikkuSessionService();
+    const userSession = new PikkuSessionService(singletonServices.sessionStore);
     if (session) {
         userSession.set(session);
     }

package/dist/wirings/workflow/graph/graph-runner.js

@@ -580,7 +580,10 @@ export async function runWorkflowGraph(workflowService, graphName, triggerInput,
     if (!meta.graphHash) {
         throw new Error(`Workflow graph '${graphName}': missing graphHash in meta`);
     }
-    const runId = await workflowService.createRun(graphName, triggerInput, inline ?? false, meta.graphHash, wire ?? { type: 'unknown' });
+    const runId = await workflowService.createRun(graphName, triggerInput, inline ?? false, meta.graphHash, wire ?? { type: 'unknown' }, {
+        deterministic: meta.deterministic,
+        plannedSteps: meta.plannedSteps,
+    });
     if (inline) {
         workflowService.registerInlineRun(runId);
     }

package/dist/wirings/workflow/index.d.ts

@@ -8,5 +8,5 @@ export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGr
 export { validateWorkflowWiring, computeEntryNodeIds, } from './graph/graph-validation.js';
 export { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
 export type { WorkflowStepInput as WorkflowStepQueueInput, PikkuWorkflowOrchestratorInput, PikkuWorkflowSleeperInput, } from './workflow-queue-workers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+export type { WorkflowService, WorkflowServiceConfig, WorkflowPlannedStep, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, WorkflowRunStatus, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
 export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './workflow.types.js';

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../../types/core.types.js';
-import type { PikkuWorkflowWire, StepState, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
+import type { PikkuWorkflowWire, StepState, WorkflowPlannedStep, WorkflowRun, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
@@ -62,7 +62,10 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      */
     unregisterInlineRun(runId: string): void;
     registerWorkflowVersions(): Promise<void>;
-    abstract createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
+    abstract createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
+        deterministic?: boolean;
+        plannedSteps?: WorkflowPlannedStep[];
+    }): Promise<string>;
     /**
      * Get a workflow run by ID
      * @param id - Run ID

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -231,6 +231,8 @@ export class PikkuWorkflowService {
             status: run.status,
             startedAt: run.createdAt,
             completedAt: terminalStatuses.has(run.status) ? run.updatedAt : undefined,
+            deterministic: run.deterministic,
+            plannedSteps: run.plannedSteps,
             steps,
             output: run.status === 'completed' ? run.output : undefined,
             error: run.error
@@ -326,7 +328,10 @@ export class PikkuWorkflowService {
         const shouldInline = options?.inline ||
             workflowMeta.inline ||
             !getSingletonServices()?.queueService;
-        const runId = await this.createRun(name, input, shouldInline, workflowMeta.graphHash, wire);
+        const runId = await this.createRun(name, input, shouldInline, workflowMeta.graphHash, wire, {
+            deterministic: workflowMeta.deterministic,
+            plannedSteps: workflowMeta.plannedSteps,
+        });
         if (shouldInline) {
             this.inlineRuns.add(runId);
             try {
@@ -425,7 +430,6 @@ export class PikkuWorkflowService {
             const wire = {
                 workflow: workflowWire,
                 pikkuUserId: run.wire?.pikkuUserId,
-                session: rpcService.wire?.session,
                 rpc: rpcService.wire?.rpc,
             };
             try {

package/dist/wirings/workflow/workflow.types.d.ts

@@ -18,6 +18,10 @@ export interface WorkflowServiceConfig {
     stepWorkerQueueName: string;
     sleeperRPCName: string;
 }
+export interface WorkflowPlannedStep {
+    /** Human-readable step label for UI timeline */
+    stepName: string;
+}
 /**
  * Workflow run status
  */
@@ -50,6 +54,10 @@ export interface WorkflowRun {
     inline?: boolean;
     /** Graph hash of the workflow definition at run creation time */
     graphHash?: string;
+    /** True when the workflow has a static, pre-computable step timeline */
+    deterministic?: boolean;
+    /** Static planned steps snapshot captured at run start */
+    plannedSteps?: WorkflowPlannedStep[];
     /** Wire origin info (how this run was started) */
     wire: WorkflowRunWire;
     /** Creation timestamp */
@@ -95,6 +103,8 @@ export interface WorkflowRunStatus {
     status: WorkflowStatus;
     startedAt: Date;
     completedAt?: Date;
+    deterministic?: boolean;
+    plannedSteps?: WorkflowPlannedStep[];
     steps: Array<{
         name: string;
         status: StepStatus;
@@ -211,6 +221,10 @@ export interface WorkflowRuntimeMeta {
     entryNodeIds?: string[];
     /** Hash of graph topology (nodes, edges, input mappings) */
     graphHash?: string;
+    /** True when the workflow has a static, pre-computable step timeline */
+    deterministic?: boolean;
+    /** Static planned steps metadata for deterministic workflows */
+    plannedSteps?: WorkflowPlannedStep[];
 }
 /**
  * Unified workflow runtime metadata map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.17",
+  "version": "0.12.19",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/function/function-runner.ts

@@ -26,15 +26,44 @@ import type {
 } from './functions.types.js'
 import { parseVersionedId } from '../version.js'
 import type { SessionService } from '../services/user-session-service.js'
-import { createFunctionSessionWireProps } from '../services/user-session-service.js'
+import {
+  PikkuSessionService,
+  createFunctionSessionWireProps,
+} from '../services/user-session-service.js'
 import { ForbiddenError, ReadonlySessionError } from '../errors/errors.js'
 import {
   PikkuCredentialWireService,
   createWireServicesCredentialWireProps,
 } from '../services/credential-wire-service.js'
+import { defaultPikkuUserIdResolver } from '../services/pikku-user-id.js'
 import { rpcService } from '../wirings/rpc/rpc-runner.js'
 import { closeWireServices } from '../utils.js'
 
+async function resolveSession(
+  wire: PikkuWire,
+  singletonServices: CoreSingletonServices,
+  sessionService?: SessionService<CoreUserSession>
+): Promise<void> {
+  const pikkuUserId = defaultPikkuUserIdResolver(wire)
+  if (pikkuUserId) {
+    wire.pikkuUserId = pikkuUserId
+    if (sessionService instanceof PikkuSessionService) {
+      sessionService.setPikkuUserId(pikkuUserId)
+    }
+  }
+
+  const { sessionStore } = singletonServices
+  if (!sessionStore || !pikkuUserId) return
+
+  if (!wire.session) {
+    const stored = await sessionStore.get(pikkuUserId)
+    if (stored) {
+      wire.session = stored
+      sessionService?.setInitial(stored)
+    }
+  }
+}
+
 /**
  * Get or create singleton services for an addon package.
  * Services are cached in pikkuState to avoid recreation on each call.
@@ -256,6 +285,12 @@ export const runPikkuFunc = async <In = any, Out = any>(
 
   // Helper function to run permissions and execute the function
   const executeFunction = async () => {
+    await resolveSession(
+      resolvedWire,
+      resolvedSingletonServices,
+      sessionService
+    )
+
     if (sessionService) {
       resolvedWire.session = sessionService.freezeInitial()
       resolvedWire.setSession = (s: any) => sessionService.set(s)

package/src/function/functions.types.ts

@@ -74,15 +74,8 @@ export type CorePikkuFunctionSessionless<
 export type CorePikkuPermission<
   In = any,
   Services extends CoreSingletonServices = CoreServices,
-  Wire extends PikkuWire<
-    In,
-    never,
-    false,
-    CoreUserSession,
-    any,
-    never,
-    never
-  > = PikkuWire<In, never, false, CoreUserSession, never, never, never>,
+  Wire extends PikkuWire<In, never, false, CoreUserSession, any, never, never> =
+    PikkuWire<In, never, false, CoreUserSession, never, never, never>,
 > = (services: Services, data: In, wire: Wire) => Promise<boolean>
 
 /**
@@ -269,11 +262,8 @@ export type CorePikkuFunctionConfig<
   PikkuFunction extends
     | CorePikkuFunction<any, any, any, any, any>
     | CorePikkuFunctionSessionless<any, any, any, any, any>,
-  PikkuPermission extends CorePikkuPermission<
-    any,
-    any,
-    any
-  > = CorePikkuPermission<any>,
+  PikkuPermission extends CorePikkuPermission<any, any, any> =
+    CorePikkuPermission<any>,
   PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<
     any,
     any
@@ -292,6 +282,7 @@ export type CorePikkuFunctionConfig<
   remote?: boolean
   mcp?: boolean
   readonly?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: any
   func: PikkuFunction

package/src/services/in-memory-session-store.test.ts

@@ -0,0 +1,58 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { InMemorySessionStore } from './in-memory-session-store.js'
+
+describe('InMemorySessionStore', () => {
+  test('get returns undefined for unknown user', async () => {
+    const store = new InMemorySessionStore()
+    const result = await store.get('unknown')
+    assert.equal(result, undefined)
+  })
+
+  test('set and get round-trip', async () => {
+    const store = new InMemorySessionStore()
+    const session = { userId: 'user-1', organizationId: 'org-1' } as any
+    await store.set('user-1', session)
+
+    const result = await store.get('user-1')
+    assert.deepEqual(result, session)
+  })
+
+  test('set overwrites previous session', async () => {
+    const store = new InMemorySessionStore()
+    await store.set('user-1', { userId: 'user-1', role: 'admin' } as any)
+    await store.set('user-1', { userId: 'user-1', role: 'member' } as any)
+
+    const result = await store.get('user-1')
+    assert.deepEqual(result, { userId: 'user-1', role: 'member' })
+  })
+
+  test('clear removes session', async () => {
+    const store = new InMemorySessionStore()
+    await store.set('user-1', { userId: 'user-1' } as any)
+    assert.ok(await store.get('user-1'))
+
+    await store.clear('user-1')
+    const result = await store.get('user-1')
+    assert.equal(result, undefined)
+  })
+
+  test('clear is no-op for unknown user', async () => {
+    const store = new InMemorySessionStore()
+    await store.clear('nonexistent')
+  })
+
+  test('users are isolated', async () => {
+    const store = new InMemorySessionStore()
+    await store.set('user-a', { userId: 'a' } as any)
+    await store.set('user-b', { userId: 'b' } as any)
+
+    assert.deepEqual(await store.get('user-a'), { userId: 'a' })
+    assert.deepEqual(await store.get('user-b'), { userId: 'b' })
+
+    await store.clear('user-a')
+    assert.equal(await store.get('user-a'), undefined)
+    assert.deepEqual(await store.get('user-b'), { userId: 'b' })
+  })
+})

package/src/services/in-memory-session-store.ts

@@ -0,0 +1,21 @@
+import type { CoreUserSession } from '../types/core.types.js'
+import type { SessionStore } from './session-store.js'
+
+export class InMemorySessionStore<
+  UserSession extends CoreUserSession = CoreUserSession,
+> implements SessionStore<UserSession>
+{
+  private sessions = new Map<string, UserSession>()
+
+  async get(pikkuUserId: string): Promise<UserSession | undefined> {
+    return this.sessions.get(pikkuUserId)
+  }
+
+  async set(pikkuUserId: string, session: UserSession): Promise<void> {
+    this.sessions.set(pikkuUserId, session)
+  }
+
+  async clear(pikkuUserId: string): Promise<void> {
+    this.sessions.delete(pikkuUserId)
+  }
+}

package/src/services/in-memory-workflow-service.test.ts

@@ -46,6 +46,27 @@ describe('InMemoryWorkflowService', () => {
       const state = await service.getRunState(runId)
       assert.deepStrictEqual(state, {})
     })
+
+    test('should persist deterministic planned steps metadata', async () => {
+      const runId = await service.createRun(
+        'wf',
+        {},
+        true,
+        'h',
+        {} as any,
+        {
+          deterministic: true,
+          plannedSteps: [{ stepName: 'Step 1' }, { stepName: 'Step 2' }],
+        }
+      )
+
+      const run = await service.getRun(runId)
+      assert.strictEqual(run?.deterministic, true)
+      assert.deepStrictEqual(run?.plannedSteps, [
+        { stepName: 'Step 1' },
+        { stepName: 'Step 2' },
+      ])
+    })
   })
 
   describe('getRun', () => {

package/src/services/in-memory-workflow-service.ts

@@ -2,6 +2,7 @@ import { randomUUID } from 'crypto'
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js'
 import type { SerializedError } from '../types/core.types.js'
 import type {
+  WorkflowPlannedStep,
   WorkflowRun,
   WorkflowRunService,
   WorkflowRunWire,
@@ -55,7 +56,11 @@ export class InMemoryWorkflowService
     input: any,
     inline: boolean,
     graphHash: string,
-    wire: WorkflowRunWire
+    wire: WorkflowRunWire,
+    options?: {
+      deterministic?: boolean
+      plannedSteps?: WorkflowPlannedStep[]
+    }
   ): Promise<string> {
     const runId = randomUUID()
     const now = new Date()
@@ -67,6 +72,8 @@ export class InMemoryWorkflowService
       input,
       inline,
       graphHash,
+      deterministic: options?.deterministic,
+      plannedSteps: options?.plannedSteps,
       wire,
       createdAt: now,
       updatedAt: now,

package/src/services/index.ts

@@ -68,6 +68,8 @@ export type {
 } from './typed-credential-service.js'
 export type { VariableStatus, VariableMeta } from './typed-variables-service.js'
 export type { MetaService } from './meta-service.js'
+export type { SessionStore } from './session-store.js'
+export { InMemorySessionStore } from './in-memory-session-store.js'
 export type {
   MCPMeta,
   RPCMetaRecord,

package/src/services/session-store.ts

@@ -0,0 +1,9 @@
+import type { CoreUserSession } from '../types/core.types.js'
+
+export interface SessionStore<
+  UserSession extends CoreUserSession = CoreUserSession,
+> {
+  get(pikkuUserId: string): Promise<UserSession | undefined>
+  set(pikkuUserId: string, session: UserSession): Promise<void>
+  clear(pikkuUserId: string): Promise<void>
+}

package/src/services/user-session-service.test.ts

@@ -19,17 +19,17 @@ describe('PikkuSessionService', () => {
     assert.strictEqual(service.get(), undefined)
   })
 
-  test('should mark sessionChanged when set is called', () => {
+  test('should mark sessionChanged when set is called', async () => {
     const service = new PikkuSessionService()
     assert.strictEqual(service.sessionChanged, false)
-    service.set({ userId: 'user-1' })
+    await service.set({ userId: 'user-1' })
     assert.strictEqual(service.sessionChanged, true)
   })
 
-  test('should clear session', () => {
+  test('should clear session', async () => {
     const service = new PikkuSessionService()
     service.setInitial({ userId: 'user-1' })
-    service.clear()
+    await service.clear()
     assert.strictEqual(service.get(), undefined)
     assert.strictEqual(service.sessionChanged, true)
   })
@@ -41,35 +41,69 @@ describe('PikkuSessionService', () => {
     assert.deepStrictEqual(frozen, { userId: 'user-1' })
   })
 
-  test('should only freeze initial once', () => {
+  test('should only freeze initial once', async () => {
     const service = new PikkuSessionService()
     service.setInitial({ userId: 'user-1' })
     service.freezeInitial()
-    service.set({ userId: 'user-2' })
+    await service.set({ userId: 'user-2' })
     const frozen2 = service.freezeInitial()
     assert.deepStrictEqual(frozen2, { userId: 'user-1' })
   })
 
-  test('should throw when channelStore provided without channelId', () => {
-    assert.throws(() => new PikkuSessionService({} as any), {
-      message: 'Channel ID is required when using channel store',
-    })
-  })
-
-  test('should use channelStore when provided', async () => {
+  test('should persist to sessionStore on set when pikkuUserId is set', async () => {
+    let storedId: string | undefined
     let storedSession: any
     const store = {
-      setUserSession: (id: string, session: any) => {
+      get: async () => undefined,
+      set: async (id: string, session: any) => {
+        storedId = id
         storedSession = session
       },
-      getChannelAndSession: (id: string) => ({ session: { userId: 'stored' } }),
+      clear: async () => {},
     }
-    const service = new PikkuSessionService(store as any, 'ch-1')
-    service.set({ userId: 'new' })
+    const service = new PikkuSessionService(store as any)
+    service.setPikkuUserId('user-123')
+    await service.set({ userId: 'new' })
+    assert.strictEqual(storedId, 'user-123')
     assert.deepStrictEqual(storedSession, { userId: 'new' })
+  })
 
-    const session = service.get()
-    assert.deepStrictEqual(session, { userId: 'stored' })
+  test('should not persist to sessionStore when pikkuUserId is not set', async () => {
+    let setCalled = false
+    const store = {
+      get: async () => undefined,
+      set: async () => {
+        setCalled = true
+      },
+      clear: async () => {},
+    }
+    const service = new PikkuSessionService(store as any)
+    await service.set({ userId: 'new' })
+    assert.strictEqual(setCalled, false)
+  })
+
+  test('should clear from sessionStore when pikkuUserId is set', async () => {
+    let clearedId: string | undefined
+    const store = {
+      get: async () => undefined,
+      set: async () => {},
+      clear: async (id: string) => {
+        clearedId = id
+      },
+    }
+    const service = new PikkuSessionService(store as any)
+    service.setPikkuUserId('user-123')
+    service.setInitial({ userId: 'user-123' })
+    await service.clear()
+    assert.strictEqual(clearedId, 'user-123')
+    assert.strictEqual(service.get(), undefined)
+  })
+
+  test('getPikkuUserId should return set value', () => {
+    const service = new PikkuSessionService()
+    assert.strictEqual(service.getPikkuUserId(), undefined)
+    service.setPikkuUserId('user-456')
+    assert.strictEqual(service.getPikkuUserId(), 'user-456')
   })
 })