@pikku/cli 0.12.105 → 0.12.109

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

@@ -17,8 +17,7 @@
  * publish-side ergonomics (envelope shape) are documented in the
  * pikku-realtime skill.
  */
-export const serializeEventsScaffold = (authRequired, pikkuTypesImportPath) => {
-    const auth = authRequired ? 'true' : 'false';
+export const serializeEventsScaffold = (leaf) => {
     const schemas = `/**
  * Auto-generated realtime event schemas
  * Do not edit manually - regenerate with 'npx pikku'
@@ -27,13 +26,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'
 
 /**
@@ -71,7 +66,7 @@ export const realtimeRoutes = defineChannelRoutes({
 wireChannel({
   name: 'events',
   route: '/events',
-  auth: ${auth},
+  auth: false,
   onMessageWiring: {
     action: realtimeRoutes,
   },
@@ -99,7 +94,7 @@ wireHTTP({
   method: 'get',
   route: '/events/:topic',
   func: realtimeEventStream,
-  auth: ${auth},
+  auth: false,
   sse: true,
   tags: ['pikku:realtime', 'sse'],
 })

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

@@ -1,7 +1,7 @@
-export declare const pikkuRoles: import("#pikku").PikkuFunctionConfig<{
+export declare const pikkuRoles: 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/roles/pikku-command-roles.js

@@ -1,8 +1,8 @@
-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 { serializeRolesTypes } from './serialize-roles-types.js';
-import { validateAndBuildSystemRoleDefinitionsMeta } from '@pikku/core/ecosystem/role';
+import { validateAndBuildSystemRoleDefinitionsMeta } from '@pikku/core/role';
 export const pikkuRoles = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
         const { rolesFile, rolesMetaJsonFile } = config;
@@ -10,7 +10,7 @@ export const pikkuRoles = pikkuSessionlessFunc({
             return;
         }
         // Same cold-start reasoning as Scopes: on a bare .pikku this runs before
-        // pikku-types.gen.ts exists, so it takes the zero state. The file only has
+        // the function leaf exists, so it takes the zero state. The file only has
         // to exist so personas can import SystemRoleName; the real Roles step
         // regenerates it with the declarations once setup has run.
         const bootstrap = data?.bootstrap ?? false;

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

@@ -1,4 +1,4 @@
-import type { SystemRoleDefinitions } from '@pikku/core/ecosystem/role';
+import type { SystemRoleDefinitions } from '@pikku/core/role';
 export interface SerializeRolesOptions {
     definitions: SystemRoleDefinitions;
 }

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

@@ -16,8 +16,8 @@ export const serializeRolesTypes = ({ definitions }) => {
     return `/**
  * This file was generated by the @pikku/cli
  */
-import type { SystemRole, SystemRoleDefinitionsMeta } from '@pikku/core/ecosystem/role'
-import { flattenSystemRoleDefinitions } from '@pikku/core/ecosystem/role'
+import type { SystemRole, SystemRoleDefinitionsMeta } from '@pikku/core/role'
+import { flattenSystemRoleDefinitions } from '@pikku/core/role'
 import definitions from './pikku-roles-meta.gen.json' with { type: 'json' }
 
 /**

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

@@ -1 +1 @@
-export declare const pikkuPublicRPC: 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 pikkuPublicRPC: 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/rpc/pikku-command-public-rpc.js

@@ -1,19 +1,18 @@
-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';
 import { serializePublicRPC } from './serialize-public-rpc.js';
-import { resolveScaffoldFeature } from '../../../utils/resolve-scaffold-feature.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
-        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
-        if (deployCodegenFlag === '1') {
+        if (await isDeployCodegen(variables)) {
             return false;
         }
         if (config.scaffold?.rpc && config.publicRpcSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializePublicRPC(pathToPikkuTypes, resolveScaffoldFeature('rpc', config.scaffold.rpc).auth, config.globalHTTPPrefix || '');
+            const leaf = (name) => getLeafImportPath(config.publicRpcFile, name, config);
+            const { schemas, functions } = serializePublicRPC(leaf, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, config.publicRpcSchemasFile, schemas);
             await writeFileInDir(logger, config.publicRpcFile, functions);
             await removeLegacyScaffoldFile(config.publicRpcFile);

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

@@ -1 +1 @@
-export declare const pikkuReactQuery: 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 pikkuReactQuery: 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/rpc/pikku-command-react-query.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/rpc/pikku-command-remote-rpc.d.ts

@@ -1 +1 @@
-export declare const pikkuRemoteRPC: 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 pikkuRemoteRPC: 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/rpc/pikku-command-remote-rpc.js

@@ -1,18 +1,18 @@
-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';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
-        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
-        if (deployCodegenFlag === '1') {
+        if (await isDeployCodegen(variables)) {
             return false;
         }
         if (config.remoteRpcWorkersFile && config.remoteRpcSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializeRemoteRPC(pathToPikkuTypes);
+            const leaf = (name) => getLeafImportPath(config.remoteRpcWorkersFile, name, config);
+            const { schemas, functions } = serializeRemoteRPC(leaf);
             await writeFileInDir(logger, config.remoteRpcSchemasFile, schemas);
             await writeFileInDir(logger, config.remoteRpcWorkersFile, functions);
             await removeLegacyScaffoldFile(config.remoteRpcWorkersFile);

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

@@ -1 +1 @@
-export declare const pikkuRPCClient: 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 pikkuRPCClient: 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/rpc/pikku-command-rpc-client.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/rpc/pikku-command-rpc-map.d.ts

@@ -1,7 +1,7 @@
-export declare const pikkuRPCInternalMap: 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 pikkuRPCExposedMap: 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 pikkuRPCInternalMap: 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 pikkuRPCExposedMap: 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>;
 /**
  * The `remote: true` surface — what a `wireRemoteAddon` consumer imports.
  * Mirrors the exposed map but is fed from `rpc.remoteMeta`.
  */
-export declare const pikkuRPCRemoteMap: 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 pikkuRPCRemoteMap: 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/rpc/pikku-command-rpc-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 { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';

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

@@ -1,2 +1,2 @@
 export declare function filterInternalRPCMeta(internalMeta: Record<string, string>, functionsMeta: Record<string, unknown>): Record<string, string>;
-export declare const pikkuRPC: 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 pikkuRPC: 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/rpc/pikku-command-rpc.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 { getFileImportRelativePath } from '../../../utils/file-import-path.js';
@@ -32,7 +32,7 @@ export const pikkuRPC = pikkuSessionlessFunc({
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
             const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -5,4 +5,4 @@ export interface PublicRPCGenOutput {
 /**
  * Generate public RPC HTTP endpoint
  */
-export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => PublicRPCGenOutput;
+export declare const serializePublicRPC: (leaf: (name: string) => string, globalHTTPPrefix?: string) => PublicRPCGenOutput;

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

@@ -1,8 +1,7 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
-    const authFlag = requireAuth ? 'true' : 'false';
+export const serializePublicRPC = (leaf, globalHTTPPrefix = '') => {
     const schemas = `/**
  * Auto-generated public RPC endpoint schemas
  * Do not edit manually - regenerate with 'npx pikku'
@@ -18,12 +17,13 @@ export const RPCCall = z.object({
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireHTTP } from '${leaf('http')}'
 import { RPCCall } from './rpc-public.schemas.gen.js'
 
 export const rpcCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
-  auth: ${authFlag},
+  auth: false,
   input: RPCCall,
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await rpc.exposed(rpcName, data)
@@ -33,7 +33,7 @@ export const rpcCaller = pikkuSessionlessFunc({
 wireHTTP({
   route: '${globalHTTPPrefix}/rpc/:rpcName',
   method: 'post',
-  auth: ${authFlag},
+  auth: false,
   tags: ['pikku'],
   func: rpcCaller,
 })

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.d.ts

@@ -5,4 +5,4 @@ export interface RemoteRPCGenOutput {
 /**
  * Generate remote internal RPC queue worker and HTTP endpoint
  */
-export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => RemoteRPCGenOutput;
+export declare const serializeRemoteRPC: (leaf: (name: string) => string) => RemoteRPCGenOutput;

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

@@ -1,7 +1,7 @@
 /**
  * Generate remote internal RPC queue worker and HTTP endpoint
  */
-export const serializeRemoteRPC = (pathToPikkuTypes) => {
+export const serializeRemoteRPC = (leaf) => {
     const schemas = `/**
  * Auto-generated remote internal RPC schemas
  * Do not edit manually - regenerate with 'npx pikku'
@@ -17,8 +17,10 @@ export const RemoteRPCCall = z.object({
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP, wireQueueWorker } from '${pathToPikkuTypes}'
-import { pikkuRemoteAuthMiddleware } from '@pikku/core/ecosystem/middleware'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireHTTP } from '${leaf('http')}'
+import { wireQueueWorker } from '${leaf('queue')}'
+import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware'
 import { RemoteRPCCall } from './rpc-remote.schemas.gen.js'
 
 export const remoteRPCHandler = pikkuSessionlessFunc({

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

@@ -2,7 +2,7 @@ export const serializeRPCWrapper = (rpcMapPath, globalHTTPPrefix = '') => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
 import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow, TypedRunWorkflow, TypedWorkflowStatus } from '${rpcMapPath}'
-import type { WorkflowRunStatus } from '@pikku/core/ecosystem/workflow'
+import type { WorkflowRunStatus } from '@pikku/core/workflow'
 
 /**
  * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -59,7 +59,7 @@ ${generateAddonAgentImports(wireAddonDeclarations)}
 ${generateMergedAgentMap(wireAddonDeclarations)}
 
 import type { PikkuRPC } from '@pikku/core/rpc'
-import type { AgentInput } from '@pikku/core/ecosystem/agent'
+import type { AgentInput } from '@pikku/core/agent'
 
 export type TypedStartWorkflow = <Name extends keyof FlattenedWorkflowMap>(
   name: Name,

package/dist/src/functions/wirings/scenarios/register-scenario-instrumentation.d.ts

@@ -2,9 +2,8 @@
  * Register the instrumentation into the running dev server's state, so the
  * scenario runner can reach it over `/rpc/<name>` exactly as before.
  *
- * They are registered sessionless: `auth` decides whether a session is
- * *required*, and a sessioned function would demand one regardless of the flag.
- * `scaffold.scenarios: true` therefore requires a session; `{ auth: false }` is
- * what opens them.
+ * They are registered sessionless with `auth: true`, so a caller still needs a
+ * session: the `/rpc/:rpcName` dispatcher declines to gate, which leaves each
+ * function to answer for itself.
  */
-export declare const registerScenarioInstrumentation: (requireAuth: boolean) => void;
+export declare const registerScenarioInstrumentation: () => void;

package/dist/src/functions/wirings/scenarios/register-scenario-instrumentation.js

@@ -1,10 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { addFunction } from '@pikku/core/function';
-import { pikkuState } from '@pikku/core/ecosystem';
-import { isTestRun } from '@pikku/core/services';
-import { getStubTracker, } from '@pikku/core/ecosystem/services';
-import { enableScoreSnapshots, getScoreSnapshot, gradeRun as coreGradeRun, } from '@pikku/core/ecosystem/agent-scorer';
+import { pikkuState } from '@pikku/core/state';
+import { isTestRun, getStubTracker, } from '@pikku/core/services';
+import { enableScoreSnapshots, getScoreSnapshot, gradeRun as coreGradeRun, } from '@pikku/core/agent-scorer';
 /**
  * The instrumentation `pikku scenario run` calls on the server under test:
  * snapshot/reset live coverage, and reset/read recorded stub calls.
@@ -105,19 +104,18 @@ const instrumentation = {
  * Register the instrumentation into the running dev server's state, so the
  * scenario runner can reach it over `/rpc/<name>` exactly as before.
  *
- * They are registered sessionless: `auth` decides whether a session is
- * *required*, and a sessioned function would demand one regardless of the flag.
- * `scaffold.scenarios: true` therefore requires a session; `{ auth: false }` is
- * what opens them.
+ * They are registered sessionless with `auth: true`, so a caller still needs a
+ * session: the `/rpc/:rpcName` dispatcher declines to gate, which leaves each
+ * function to answer for itself.
  */
-export const registerScenarioInstrumentation = (requireAuth) => {
+export const registerScenarioInstrumentation = () => {
     const meta = pikkuState(null, 'function', 'meta');
     // Retaining finished runs is what makes them gradeable, and this is the only
     // place that can grade one — so the buffer is turned on here rather than by a
     // flag someone has to remember, and stays absent from every other process.
     enableScoreSnapshots();
     for (const [name, { func, title, description }] of Object.entries(instrumentation)) {
-        addFunction(name, { func, auth: requireAuth });
+        addFunction(name, { func, auth: true });
         meta[name] = {
             pikkuFuncId: name,
             inputSchemaName: null,

package/dist/src/functions/wirings/scenarios/scenario-partition.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
+import type { FunctionsMeta } from '@pikku/core/services';
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
 export type WiringFileMap = Map<string, {
     path: string;

package/dist/src/functions/wirings/scenarios/scenario-schema-partition.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
+import type { FunctionsMeta } from '@pikku/core/services';
 /**
  * The schema names a set of functions validates against.
  *

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

@@ -1,4 +1,4 @@
-import type { FeaturesMeta } from '@pikku/core/ecosystem/scenario';
+import type { FeaturesMeta } from '@pikku/core/scenario';
 import type { InspectorFeature } from '@pikku/inspector';
 /**
  * The feature meta the console reads, built from what the inspector could read

package/dist/src/functions/wirings/scenarios/serialize-scenario-meta.js

@@ -23,8 +23,8 @@ export const serializeScenarioWorkflowMeta = (outputPath, metaDir, appMetaImport
     const metaEntries = sortedNames
         .map((name) => `  '${name}': ${sanitizeTypeName(name)}Meta,`)
         .join('\n');
-    return `import { pikkuState } from '@pikku/core/ecosystem'
-import type { WorkflowsRuntimeMeta } from '@pikku/core/ecosystem/workflow'
+    return `import { pikkuState } from '@pikku/core/state'
+import type { WorkflowsRuntimeMeta } from '@pikku/core/workflow'
 import '${appMetaImportPath}'
 ${imports ? `\n${imports}\n` : ''}
 const scenariosMeta = {
@@ -44,8 +44,8 @@ export const serializeScenarioFunctionMeta = (jsonImportPath, appMetaImportPath,
     const importStatement = supportsImportAttributes
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
-    return `import { pikkuState } from '@pikku/core/ecosystem'
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services'
+    return `import { pikkuState } from '@pikku/core/state'
+import type { FunctionsMeta } from '@pikku/core/services'
 import '${appMetaImportPath}'
 ${importStatement}
 

package/dist/src/functions/wirings/scenarios/serialize-scenario-registration.js

@@ -15,7 +15,7 @@ export const serializeScenarioRegistration = (outputPath, metaImportPath, scenar
         lines.push(`import { addWorkflow } from '@pikku/core/workflow'`);
     }
     if (hasFeatures) {
-        lines.push(`import { addFeature } from '@pikku/core/ecosystem/scenario'`);
+        lines.push(`import { addFeature } from '@pikku/core/scenario'`);
     }
     lines.push(`import '${metaImportPath}'`);
     const sortedScenarios = Array.from(scenarioFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));

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

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: 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 pikkuSchedulerTypes: 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/scheduler/pikku-command-scheduler-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,10 @@ export const pikkuSchedulerTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { schedulersTypesFile, functionTypesFile, packageMappings } = config;
         const functionTypesImportPath = getFileImportRelativePath(schedulersTypesFile, functionTypesFile, packageMappings);
-        const content = serializeSchedulerTypes(functionTypesImportPath);
+        const middlewareTypesImportPath = getFileImportRelativePath(schedulersTypesFile, config.middlewareTypesFile, packageMappings);
+        const content = serializeSchedulerTypes(functionTypesImportPath, middlewareTypesImportPath, {
+            addon: !!config.addon,
+        });
         await writeFileInDir(logger, schedulersTypesFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuScheduler: 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 pikkuScheduler: 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/scheduler/pikku-command-scheduler.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/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
-import type { ScheduledTasksMeta } from '@pikku/core/ecosystem/scheduler';
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
 export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

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

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

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

@@ -1,21 +1,25 @@
 /**
  * Generates type definitions for scheduler wirings
  */
-export const serializeSchedulerTypes = (functionTypesImportPath) => {
+export const serializeSchedulerTypes = (functionTypesImportPath, middlewareTypesImportPath, { addon = false } = {}) => {
     return `/**
  * Scheduler-specific type definitions for tree-shaking optimization
  */
 
-import { wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
-import { CoreScheduledTask } from '@pikku/core/ecosystem/scheduler'
-import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+${addon ? '' : `import { wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'\n`}${addon
+        ? ''
+        : `import { CoreScheduledTask } from '@pikku/core/scheduler'
+import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { PikkuMiddleware } from '${middlewareTypesImportPath}'
 
 /**
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
 type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
-
+`}${addon
+        ? ''
+        : `
 /**
  * Registers a scheduled task with the Pikku framework.
  * Tasks run based on cron expressions and are sessionless.
@@ -25,5 +29,5 @@ type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'sessio
 export const wireScheduler = (task: SchedulerWiring) => {
   wireSchedulerCore(task as any)
 }
-`;
+`}`;
 };

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

@@ -1,7 +1,7 @@
-export declare const pikkuScopes: import("#pikku").PikkuFunctionConfig<{
+export declare const pikkuScopes: 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/scopes/pikku-command-scopes.js

@@ -1,17 +1,20 @@
-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 { serializeScopesTypes } from './serialize-scopes-types.js';
-import { validateAndBuildScopeDefinitionsMeta } from '@pikku/core/ecosystem/scope';
+import { serializeScopesClient } from './serialize-scopes-client.js';
+import { validateAndBuildScopeDefinitionsMeta } from '@pikku/core/scope';
 export const pikkuScopes = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
         const { scopesFile, scopesMetaJsonFile } = config;
+        const scopesClientFile = config.clientFiles?.scopesFile;
         if (!scopesFile) {
             return;
         }
-        // On a cold .pikku this runs before pikku-types.gen.ts exists, so it must
+        // On a cold .pikku this runs before the function leaf exists, so it must
         // take the zero state rather than a full inspect — inspecting here would
-        // try to import the project's zod schemas, which resolve '#pikku' and fail.
+        // try to import the project's zod schemas, which resolve '#pikku/function'
+        // and fail.
         // The file only has to exist so function types can import ScopeId; the real
         // Scopes step regenerates it with the declarations once setup has run.
         const bootstrap = data?.bootstrap ?? false;
@@ -20,6 +23,9 @@ export const pikkuScopes = pikkuSessionlessFunc({
             definitions: state.scopes.definitions,
         });
         await writeFileInDir(logger, scopesFile, content);
+        if (scopesClientFile) {
+            await writeFileInDir(logger, scopesClientFile, serializeScopesClient({ definitions: state.scopes.definitions }));
+        }
         if (scopesMetaJsonFile) {
             const meta = validateAndBuildScopeDefinitionsMeta(state.scopes.definitions);
             await writeFileInDir(logger, scopesMetaJsonFile, JSON.stringify(meta, null, 2));

package/dist/src/functions/wirings/scopes/serialize-scopes-client.d.ts

@@ -0,0 +1,16 @@
+import type { ScopeDefinitions } from '@pikku/core/scope';
+export interface SerializeScopesClientOptions {
+    definitions: ScopeDefinitions;
+}
+/**
+ * Generates the browser-side scope client: the `ScopeId` union and a
+ * `hasScopes` that decides whether held grants satisfy a requirement.
+ *
+ * The cascade is emitted inline rather than imported, so the file a frontend
+ * bundles has no imports at all. `@pikku/core` is a server package — it pulls
+ * AsyncLocalStorage and the wiring runtime behind it — so a UI reaching for
+ * `@pikku/core/scope` to render a permission drags the server into the bundle.
+ * `serialize-scopes-client.test.ts` checks this copy against core's over a
+ * shared case table.
+ */
+export declare const serializeScopesClient: ({ definitions, }: SerializeScopesClientOptions) => string;