@pikku/cli 0.12.137 → 0.12.143

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

@@ -3,7 +3,7 @@ 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';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCommandChannels = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -21,12 +21,6 @@ export const pikkuCommandChannels = pikkuSessionlessFunc({
         // (channels.files is empty). Skipping either leaves the bootstrap importing
         // a file that was never generated and the per-unit deploy bundle fails.
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        const minimalMeta = stripVerboseFields(channels.meta);
-        await writeFileInDir(logger, channelsWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(channels.meta)) {
-            const verbosePath = channelsWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(channels.meta, null, 2));
-        }
         await writeFileInDir(logger, channelContractsMetaJsonFile, JSON.stringify(exportedContracts.channel, null, 2));
         if (hasChannelContracts) {
             const contractsJsonImportPath = getFileImportRelativePath(channelContractsMetaFile, channelContractsMetaJsonFile, packageMappings);
@@ -36,12 +30,15 @@ export const pikkuCommandChannels = pikkuSessionlessFunc({
                 : `import contractsMeta from '${contractsJsonImportPath}'`;
             await writeFileInDir(logger, channelContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
         }
-        const jsonImportPath = getFileImportRelativePath(channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
+        await writeWiringMeta({
+            logger,
+            meta: channels.meta,
+            metaJsonFile: channelsWiringMetaJsonFile,
+            metaFile: channelsWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`,
+        });
         return true;
     },
     middleware: [

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

@@ -3,7 +3,7 @@ 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';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCLI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -21,12 +21,6 @@ export const pikkuCLI = pikkuSessionlessFunc({
         // Skipping either leaves the bootstrap importing a file that was never
         // generated and the per-unit deploy bundle fails.
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
-        const minimalMeta = stripVerboseFields(cli.meta);
-        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(cli.meta)) {
-            const verbosePath = cliWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(cli.meta, null, 2));
-        }
         await writeFileInDir(logger, cliContractsMetaJsonFile, JSON.stringify(exportedContracts.cli, null, 2));
         if (hasCLIContracts) {
             const contractsJsonImportPath = getFileImportRelativePath(cliContractsMetaFile, cliContractsMetaJsonFile, packageMappings);
@@ -36,12 +30,15 @@ export const pikkuCLI = pikkuSessionlessFunc({
                 : `import contractsMeta from '${contractsJsonImportPath}'`;
             await writeFileInDir(logger, cliContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
         }
-        const jsonImportPath = getFileImportRelativePath(cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
+        await writeWiringMeta({
+            logger,
+            meta: cli.meta,
+            metaJsonFile: cliWiringMetaJsonFile,
+            metaFile: cliWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`,
+        });
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.js

@@ -1,10 +1,9 @@
 import { pikkuSessionlessFunc } from '#pikku/function';
 import { ErrorCode } from '@pikku/inspector';
-import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { readFile } from 'fs/promises';
 import { join, isAbsolute } from 'path';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeMetaSidecar } from '../../../utils/write-wiring-meta.js';
 import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
 const loadIcon = async (iconPath, rootDir, logger) => {
     if (!iconPath)
@@ -73,19 +72,12 @@ export const pikkuNodesMeta = pikkuSessionlessFunc({
             metaData.requiredParentServices = state.addonRequiredParentServices;
         }
         if (addonMetaJsonFile && (config.scaffold?.console || config.addon)) {
-            const minimalMeta = stripVerboseFields(metaData);
-            await writeFileInDir(logger, addonMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
-            if (hasVerboseFields(metaData)) {
-                const verbosePath = addonMetaJsonFile.endsWith('.gen.json')
-                    ? addonMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json')
-                    : addonMetaJsonFile.replace(/(\.\w+)$/, '-verbose$1');
-                if (verbosePath === addonMetaJsonFile) {
-                    logger.warn(`Cannot derive verbose path from ${addonMetaJsonFile}, skipping verbose metadata`);
-                }
-                else {
-                    await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
-                }
-            }
+            await writeMetaSidecar({
+                logger,
+                meta: metaData,
+                metaJsonFile: addonMetaJsonFile,
+                ignoreModifyComment: true,
+            });
         }
         return true;
     },

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

@@ -1,12 +1,6 @@
 import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-/**
- * A display name is the human-facing label a developer wrote, so an apostrophe
- * in it is ordinary. `JSON.stringify` emits a valid, escaped TypeScript string
- * literal; interpolating the raw text into a quoted one terminates the string
- * and the generated file stops parsing.
- */
-const literal = (value) => JSON.stringify(value);
+import { tsLiteral } from '../../../utils/ts-literal.js';
 export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentialsFile, packageMappings, }) => {
     const credentials = validateAndBuildCredentialDefinitionsMeta(definitions, schemaLookup);
     const credentialEntries = Object.entries(credentials);
@@ -29,7 +23,7 @@ export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentia
         }
         const metaParts = [
             `name: '${name}'`,
-            `displayName: ${literal(meta.displayName)}`,
+            `displayName: ${tsLiteral(meta.displayName)}`,
             `type: '${meta.type}'`,
         ];
         if (meta.oauth2) {

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

@@ -3,31 +3,32 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeFunctionImports } from './serialize-function-imports.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, reattachFunctionServices, } from '../../../utils/strip-verbose-meta.js';
+import { stripVerboseFields, reattachFunctionServices, reattachAgentToolDescriptions, } from '../../../utils/strip-verbose-meta.js';
+import { writeMetaSidecar, writeWiringMeta, } from '../../../utils/write-wiring-meta.js';
 import { partitionScenarioFunctions, partitionScenarioFunctionsMeta, } from '../scenarios/scenario-partition.js';
 import { serializeScenarioFunctionMeta } from '../scenarios/serialize-scenario-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
+        const { functions, rpc, agents } = await getInspectorState();
         const { functionsMetaFile, functionsMetaJsonFile, functionsFile, scenarioStepsFile, scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings, schema, } = config;
         const { app: appFunctionsMeta, scenario: scenarioFunctionsMeta } = partitionScenarioFunctionsMeta(functions.meta);
         let minimalMeta = stripVerboseFields(appFunctionsMeta);
         if (config.addonName) {
             minimalMeta = reattachFunctionServices(minimalMeta, appFunctionsMeta);
         }
-        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(appFunctionsMeta)) {
-            const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(appFunctionsMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
+        minimalMeta = reattachAgentToolDescriptions(minimalMeta, appFunctionsMeta, new Set(Object.values(agents.agentsMeta).flatMap((agent) => agent.tools ?? [])));
         const packageName = config.addonName ? `'${config.addonName}'` : 'null';
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport type { FunctionsMeta } from '@pikku/core/services'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: appFunctionsMeta,
+            minimalMeta,
+            metaJsonFile: functionsMetaJsonFile,
+            metaFile: functionsMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport type { FunctionsMeta } from '@pikku/core/services'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`,
+        });
         // For addon packages, register ALL functions (they'll be invoked by consumers)
         // For main packages, only register functions that are invoked via internal RPCs
         const isAddon = !!config.addonName;
@@ -43,13 +44,15 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         // Always written, even when empty: a project that deletes its last scenario
         // must stop registering the one it had, and the scenario bootstrap imports
         // these unconditionally.
-        await writeFileInDir(logger, scenarioStepsMetaJsonFile, JSON.stringify(stripVerboseFields(scenarioFunctionsMeta), null, 2));
+        //
         // The bootstrap imports the stripped copy; the verbose one is read off disk
         // by whatever documents a scenario — the console needs `sourceFile` and
         // `exportedName` to show the code a step runs.
-        if (hasVerboseFields(scenarioFunctionsMeta)) {
-            await writeFileInDir(logger, scenarioStepsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json'), JSON.stringify(scenarioFunctionsMeta, null, 2));
-        }
+        await writeMetaSidecar({
+            logger,
+            meta: scenarioFunctionsMeta,
+            metaJsonFile: scenarioStepsMetaJsonFile,
+        });
         await writeFileInDir(logger, scenarioStepsMetaFile, serializeScenarioFunctionMeta(getFileImportRelativePath(scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings), getFileImportRelativePath(scenarioStepsMetaFile, functionsMetaFile, packageMappings), supportsImportAttributes, config.addonName));
         await writeFileInDir(logger, scenarioStepsFile, scenarioFiles.size === 0
             ? 'export {}'

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

@@ -2,8 +2,7 @@ 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';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 import { serializeGatewayMeta, serializeGatewayMetaTS, } from './serialize-gateway-meta.js';
 export const pikkuGateway = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
@@ -14,14 +13,16 @@ export const pikkuGateway = pikkuSessionlessFunc({
             return undefined;
         }
         const fullMeta = serializeGatewayMeta(gateways.meta);
-        const minimalMeta = stripVerboseFields(fullMeta);
-        await writeFileInDir(logger, gatewaysWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(fullMeta)) {
-            const verbosePath = gatewaysWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(gatewaysWiringMetaFile, gatewaysWiringMetaJsonFile, packageMappings);
-        await writeFileInDir(logger, gatewaysWiringMetaFile, serializeGatewayMetaTS(jsonImportPath, schema?.supportsImportAttributes ?? false));
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: fullMeta,
+            metaJsonFile: gatewaysWiringMetaJsonFile,
+            metaFile: gatewaysWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ jsonImportPath }) => serializeGatewayMetaTS(jsonImportPath, supportsImportAttributes),
+        });
         await writeFileInDir(logger, gatewaysWiringFile, serializeFileImports('wireGateway', gatewaysWiringFile, gateways.files, packageMappings));
         return true;
     },

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

@@ -3,7 +3,7 @@ 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';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCommandHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -22,12 +22,6 @@ export const pikkuCommandHTTP = pikkuSessionlessFunc({
         // bootstrap importing a file that was never generated and the per-unit
         // deploy bundle fails to resolve it.
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        const minimalMeta = stripVerboseFields(http.meta);
-        await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(http.meta)) {
-            const verbosePath = httpWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(http.meta, null, 2));
-        }
         await writeFileInDir(logger, httpContractsMetaJsonFile, JSON.stringify(exportedContracts.http, null, 2));
         if (hasHTTPContracts) {
             const contractsJsonImportPath = getFileImportRelativePath(httpContractsMetaFile, httpContractsMetaJsonFile, packageMappings);
@@ -37,12 +31,15 @@ export const pikkuCommandHTTP = pikkuSessionlessFunc({
                 : `import contractsMeta from '${contractsJsonImportPath}'`;
             await writeFileInDir(logger, httpContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
         }
-        const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeWiringMeta({
+            logger,
+            meta: http.meta,
+            metaJsonFile: httpWiringMetaJsonFile,
+            metaFile: httpWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`,
+        });
         return true;
     },
     middleware: [

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

@@ -4,8 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
@@ -74,20 +73,14 @@ export const pikkuMCP = pikkuSessionlessFunc({
             toolsMeta: mcpEndpoints.toolsMeta,
             promptsMeta: promptsMetaWithArguments,
         };
-        // Write minimal JSON (runtime-only fields)
-        const minimalMeta = stripVerboseFields(metaData);
-        await writeFileInDir(logger, config.mcpWiringsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(metaData)) {
-            const verbosePath = config.mcpWiringsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(mcpWiringsMetaFile, config.mcpWiringsMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/state'
+        await writeWiringMeta({
+            logger,
+            meta: metaData,
+            metaJsonFile: config.mcpWiringsMetaJsonFile,
+            metaFile: mcpWiringsMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'
 import type {
   MCPResourceMeta,
   MCPToolMeta,
@@ -96,7 +89,8 @@ import type {
 ${importStatement}
 pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
 pikkuState(null, 'mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
-pikkuState(null, 'mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`);
+pikkuState(null, 'mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`,
+        });
         return true;
     },
     middleware: [

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

@@ -1,4 +1,4 @@
-const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
+import { tsLiteral } from '../../../utils/ts-literal.js';
 /**
  * Generates the `PersonaId` union and a `definePersonas` whose `roles` are
  * checked against the declared system roles.
@@ -12,7 +12,7 @@ export const serializePersonasTypes = ({ rolesImportPath, environmentNames, }) =
     const environmentUnion = environmentNames.length > 0
         ? `\n${[...environmentNames]
             .sort()
-            .map((name) => `  | ${quote(name)}`)
+            .map((name) => `  | ${tsLiteral(name)}`)
             .join('\n')}`
         : ' never';
     return `/**

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

@@ -3,8 +3,7 @@ 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';
 import { serializeQueueMeta, serializeQueueMetaTS, } from './serialize-queue-meta.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCommandQueue = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -23,18 +22,16 @@ export const pikkuCommandQueue = pikkuSessionlessFunc({
             return undefined;
         }
         const fullMeta = serializeQueueMeta(queueWorkers.meta);
-        // Write minimal JSON file (runtime-only fields)
-        const minimalMeta = stripVerboseFields(fullMeta);
-        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(fullMeta)) {
-            const verbosePath = queueWorkersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
-        }
-        // Calculate relative path from TS file to JSON file
-        const jsonImportPath = getFileImportRelativePath(queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings);
-        // Write TypeScript file that imports JSON
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMetaTS(jsonImportPath, schema?.supportsImportAttributes ?? false));
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: fullMeta,
+            metaJsonFile: queueWorkersWiringMetaJsonFile,
+            metaFile: queueWorkersWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ jsonImportPath }) => serializeQueueMetaTS(jsonImportPath, supportsImportAttributes),
+        });
         await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
         return true;
     },

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

@@ -0,0 +1 @@
+export declare const pikkuRemoteJobs: 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/remote-jobs/pikku-command-remote-jobs.js

@@ -0,0 +1,31 @@
+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 { remoteJobsSchemasFile } from '../../../utils/remote-jobs-schemas-file.js';
+import { serializeRemoteJobs } from './serialize-remote-jobs.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
+export const pikkuRemoteJobs = pikkuSessionlessFunc({
+    func: async ({ logger, config, variables }) => {
+        if (await isDeployCodegen(variables)) {
+            return false;
+        }
+        const schemasFile = remoteJobsSchemasFile(config.remoteJobsFile);
+        if (config.remoteJobsFile && schemasFile) {
+            const leaf = (name) => getLeafImportPath(config.remoteJobsFile, name, config);
+            const { schemas, functions } = serializeRemoteJobs(leaf);
+            await writeFileInDir(logger, schemasFile, schemas);
+            await writeFileInDir(logger, config.remoteJobsFile, functions);
+            await removeLegacyScaffoldFile(config.remoteJobsFile);
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Remote Jobs',
+            commandEnd: 'Generated Remote Jobs',
+        }),
+    ],
+});

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

@@ -0,0 +1,16 @@
+export interface RemoteJobsGenOutput {
+    schemas: string;
+    functions: string;
+}
+/**
+ * Generate the remote-jobs inbox: the HTTP routes an external dispatcher posts
+ * to so a runtime that holds neither a queue consumer nor a clock still runs
+ * its queue workers and scheduled tasks.
+ *
+ * Ordinary `wireHTTP` routes rather than runtime-level handlers, so every
+ * runtime serves them from one implementation, and the secret check is
+ * middleware a deployment can sit its own scheme in front of. The routes are
+ * literals rather than the constants core exports, because the inspector reads
+ * them statically to build the HTTP map.
+ */
+export declare const serializeRemoteJobs: (leaf: (name: string) => string) => RemoteJobsGenOutput;

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

@@ -0,0 +1,78 @@
+/**
+ * Generate the remote-jobs inbox: the HTTP routes an external dispatcher posts
+ * to so a runtime that holds neither a queue consumer nor a clock still runs
+ * its queue workers and scheduled tasks.
+ *
+ * Ordinary `wireHTTP` routes rather than runtime-level handlers, so every
+ * runtime serves them from one implementation, and the secret check is
+ * middleware a deployment can sit its own scheme in front of. The routes are
+ * literals rather than the constants core exports, because the inspector reads
+ * them statically to build the HTTP map.
+ */
+export const serializeRemoteJobs = (leaf) => {
+    const schemas = `/**
+ * Auto-generated remote job inbox schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const RemoteQueueJob = z.object({
+  queueName: z.string(),
+  data: z.unknown().optional(),
+  jobId: z.string().optional(),
+  traceId: z.string().optional(),
+})
+
+export const RemoteScheduledJob = z.object({
+  taskName: z.string(),
+})
+`;
+    const functions = `/**
+ * Auto-generated remote job inbox
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireHTTP } from '${leaf('http')}'
+import {
+  pikkuRemoteQueueJobFunc,
+  pikkuRemoteScheduledJobFunc,
+} from '@pikku/core/services'
+import { remoteJobsSecret } from '@pikku/core/middleware'
+import { RemoteQueueJob, RemoteScheduledJob } from './remote-jobs.schemas.gen.js'
+
+const runRemoteQueueJob = pikkuSessionlessFunc({
+  auth: false,
+  input: RemoteQueueJob,
+  tags: ['pikku'],
+  description: 'Runs one queue worker for a job delivered by an external dispatcher.',
+  func: async ({ logger }, data) => pikkuRemoteQueueJobFunc({ logger }, data),
+})
+
+const runRemoteScheduledJob = pikkuSessionlessFunc({
+  auth: false,
+  input: RemoteScheduledJob,
+  tags: ['pikku'],
+  description: 'Runs one scheduled task for a tick delivered by an external scheduler.',
+  func: async ({ logger }, data) => pikkuRemoteScheduledJobFunc({ logger }, data),
+})
+
+wireHTTP({
+  method: 'post',
+  route: '/__pikku/queue-job',
+  auth: false,
+  tags: ['pikku'],
+  func: runRemoteQueueJob,
+  middleware: [remoteJobsSecret],
+})
+
+wireHTTP({
+  method: 'post',
+  route: '/__pikku/scheduler-job',
+  auth: false,
+  tags: ['pikku'],
+  func: runRemoteScheduledJob,
+  middleware: [remoteJobsSecret],
+})
+`;
+    return { schemas, functions };
+};

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

@@ -1,4 +1,4 @@
-const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
+import { tsLiteral } from '../../../utils/ts-literal.js';
 /**
  * Generates the `SystemRoleName` union and role metadata from
  * `defineSystemRole` declarations.
@@ -11,7 +11,7 @@ const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
 export const serializeRolesTypes = ({ definitions }) => {
     const names = [...new Set(definitions.map((d) => d.name))].sort();
     const union = names.length > 0
-        ? `\n${names.map((name) => `  | ${quote(name)}`).join('\n')}`
+        ? `\n${names.map((name) => `  | ${tsLiteral(name)}`).join('\n')}`
         : ' never';
     return `/**
  * This file was generated by the @pikku/cli

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

@@ -3,8 +3,7 @@ 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';
 import { serializeSchedulerMeta, serializeSchedulerMetaTS, } from './serialize-scheduler-meta.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuScheduler = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -15,16 +14,16 @@ export const pikkuScheduler = pikkuSessionlessFunc({
             return undefined;
         }
         const fullMeta = serializeSchedulerMeta(scheduledTasks.meta);
-        // Write minimal JSON (runtime-only fields)
-        const minimalMeta = stripVerboseFields(fullMeta);
-        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(fullMeta)) {
-            const verbosePath = schedulersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings);
-        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMetaTS(scheduledTasks.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: fullMeta,
+            metaJsonFile: schedulersWiringMetaJsonFile,
+            metaFile: schedulersWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ jsonImportPath }) => serializeSchedulerMetaTS(scheduledTasks.meta, jsonImportPath, supportsImportAttributes),
+        });
         await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
         return true;
     },

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

@@ -1,5 +1,5 @@
 import { flattenScopeDefinitions } from '@pikku/core/scope';
-const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
+import { tsLiteral } from '../../../utils/ts-literal.js';
 /**
  * Generates the browser-side scope client: the `ScopeId` union and a
  * `hasScopes` that decides whether held grants satisfy a requirement.
@@ -20,7 +20,7 @@ export const serializeScopesClient = ({ definitions, }) => {
         ...ids.filter(hasChildren).map((id) => `${id}:*`),
     ].sort();
     const union = requirable.length > 0
-        ? `\n${requirable.map((id) => `  | ${quote(id)}`).join('\n')}`
+        ? `\n${requirable.map((id) => `  | ${tsLiteral(id)}`).join('\n')}`
         : ' never';
     return `/**
  * This file was generated by the @pikku/cli