@pikku/cli 0.12.136 → 0.12.141

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

package/dist/src/functions/wirings/scopes/serialize-scopes-types.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 `ScopeId` union and scope metadata from `defineScope`
  * declarations.
@@ -19,13 +19,15 @@ export const serializeScopesTypes = ({ 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';
     const displayNames = [...flat]
         .sort((a, b) => a.id.localeCompare(b.id))
         .flatMap((scope) => {
         const displayName = definitions.find((d) => d.name === scope.id)?.displayName;
-        return displayName ? [`  ${quote(scope.id)}: ${quote(displayName)},`] : [];
+        return displayName
+            ? [`  ${tsLiteral(scope.id)}: ${tsLiteral(displayName)},`]
+            : [];
     });
     return `/**
  * This file was generated by the @pikku/cli

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

@@ -1,12 +1,6 @@
 import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
 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 serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile, packageMappings, }) => {
     const secrets = validateAndBuildSecretDefinitionsMeta(definitions, schemaLookup);
     const credentialEntries = Object.entries(secrets);
@@ -20,8 +14,8 @@ export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile,
             needsOAuth2Types = true;
             mapEntries.push(`  '${meta.secretId}': OAuth2AppCredential`);
             mapEntries.push(`  '${meta.oauth2.tokenSecretId}': OAuth2Token`);
-            metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${literal(meta.displayName)}, oauth2: { tokenSecretId: '${meta.oauth2.tokenSecretId}' } }`);
-            metaEntries.push(`  '${meta.oauth2.tokenSecretId}': { name: '${name}_tokens', displayName: ${literal(`${meta.displayName} Tokens`)} }`);
+            metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${tsLiteral(meta.displayName)}, oauth2: { tokenSecretId: '${meta.oauth2.tokenSecretId}' } }`);
+            metaEntries.push(`  '${meta.oauth2.tokenSecretId}': { name: '${name}_tokens', displayName: ${tsLiteral(`${meta.displayName} Tokens`)} }`);
         }
         else if (meta.schema && typeof meta.schema === 'string') {
             const schemaRef = schemaLookup.get(meta.schema);
@@ -32,7 +26,7 @@ export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile,
                 }
                 schemaImports.get(schemaRef.sourceFile).add(schemaRef.variableName);
                 mapEntries.push(`  '${meta.secretId}'${meta.optional ? '?' : ''}: z.infer<typeof ${schemaRef.variableName}>`);
-                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${literal(meta.displayName)}${meta.optional ? ', optional: true' : ''} }`);
+                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${tsLiteral(meta.displayName)}${meta.optional ? ', optional: true' : ''} }`);
             }
         }
     }

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

@@ -4,7 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeTriggerMeta, serializeTriggerMetaTS, serializeTriggerSourceMeta, serializeTriggerSourceMetaTS, } from './serialize-trigger-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 pikkuTrigger = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -14,16 +14,16 @@ export const pikkuTrigger = pikkuSessionlessFunc({
             return undefined;
         }
         const fullMeta = serializeTriggerMeta(triggers.meta);
-        // Write minimal JSON (runtime-only fields)
-        const minimalMeta = stripVerboseFields(fullMeta);
-        await writeFileInDir(logger, triggersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(fullMeta)) {
-            const verbosePath = triggersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(triggersWiringMetaFile, triggersWiringMetaJsonFile, packageMappings);
-        await writeFileInDir(logger, triggersWiringMetaFile, serializeTriggerMetaTS(triggers.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: fullMeta,
+            metaJsonFile: triggersWiringMetaJsonFile,
+            metaFile: triggersWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ jsonImportPath }) => serializeTriggerMetaTS(triggers.meta, jsonImportPath, supportsImportAttributes),
+        });
         await writeFileInDir(logger, triggersWiringFile, serializeFileImports('wireTrigger', triggersWiringFile, triggers.files, packageMappings));
         const sourceMetaJson = serializeTriggerSourceMeta(triggers.sourceMeta);
         await writeFileInDir(logger, triggerSourcesMetaJsonFile, JSON.stringify(sourceMetaJson, null, 2));

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

@@ -1,12 +1,6 @@
 import { validateAndBuildVariableDefinitionsMeta } from '@pikku/core/variable';
 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 serializeVariablesTypes = ({ definitions, schemaLookup, variablesFile, packageMappings, }) => {
     const variables = validateAndBuildVariableDefinitionsMeta(definitions, schemaLookup);
     const variableEntries = Object.entries(variables);
@@ -28,7 +22,7 @@ export const serializeVariablesTypes = ({ definitions, schemaLookup, variablesFi
                 // declaring the schema import each other: reading it while the modules
                 // are still initializing throws `Cannot access '<schema>' before
                 // initialization`, and deferring the read to first use avoids the cycle.
-                metaEntries.push(`  '${meta.variableId}': { name: '${name}', displayName: ${literal(meta.displayName)}, schema: () => ${schemaRef.variableName} }`);
+                metaEntries.push(`  '${meta.variableId}': { name: '${name}', displayName: ${tsLiteral(meta.displayName)}, schema: () => ${schemaRef.variableName} }`);
             }
         }
     }

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

@@ -16,7 +16,7 @@ import { serializeScenarioRegistration } from '../scenarios/serialize-scenario-r
 import { buildFeaturesMeta } from '../scenarios/serialize-feature-meta.js';
 import { serializeScenarioWorkflowMeta } from '../scenarios/serialize-scenario-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeMetaSidecar } from '../../../utils/write-wiring-meta.js';
 import { join, dirname } from 'path';
 import { rm } from 'fs/promises';
 export const pikkuWorkflow = pikkuSessionlessFunc({
@@ -62,13 +62,12 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
                 const metaDir = scenarioNameSet.has(name)
                     ? config.scenarioMetaDir
                     : workflowMetaDir;
-                const minimalMeta = stripVerboseFields(graphMeta);
-                const minimalPath = join(metaDir, `${name}.gen.json`);
-                await writeFileInDir(logger, minimalPath, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
-                if (hasVerboseFields(graphMeta)) {
-                    const verbosePath = join(metaDir, `${name}-verbose.gen.json`);
-                    await writeFileInDir(logger, verbosePath, JSON.stringify(graphMeta, null, 2), { ignoreModifyComment: true });
-                }
+                await writeMetaSidecar({
+                    logger,
+                    meta: graphMeta,
+                    metaJsonFile: join(metaDir, `${name}.gen.json`),
+                    ignoreModifyComment: true,
+                });
             }
         }
         // A project generated before scenarios moved out has their meta sitting in

package/dist/src/functions/workflows/all.workflow.js

@@ -5,6 +5,7 @@ import { assertSingleCoreVersion } from '../../utils/assert-single-core-version.
 import { warnOnSplitTypeIdentity } from '../validate/type-identity-checks.js';
 import { pruneLegacyScaffoldFiles, refreshScaffoldsImportingRemovedEntryPoints, removeRetiredScaffoldFiles, } from '../../utils/remove-legacy-scaffold-file.js';
 import { writeSurfaceUsage } from '../surface/write-surface-usage.js';
+import { writeSchemaArtifact } from '../db/local-db.js';
 import { PikkuTypecheckFailedError, renderTscFull, renderTscSummary, runProjectTypecheck, } from '../../utils/tsc-check.js';
 const scaffoldFiles = (config) => {
     const files = [];
@@ -255,10 +256,12 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         ]);
         let remoteRPC = false;
         let webhook = false;
+        let remoteJobs = false;
         let workflowRoutes = false;
         if (!config.addon) {
             remoteRPC = await workflow.do('Remote RPC', 'pikkuRemoteRPC', null);
             webhook = await workflow.do('Webhook', 'pikkuWebhook', null);
+            remoteJobs = await workflow.do('Remote jobs', 'pikkuRemoteJobs', null);
             if (workflows) {
                 workflowRoutes = await workflow.do('Workflow routes', 'pikkuWorkflowRoutes', null);
             }
@@ -279,6 +282,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         if (workflows ||
             remoteRPC ||
             webhook ||
+            remoteJobs ||
             workflowRoutes ||
             unresolvedSchemas) {
             await workflow.do('Re-inspect after workflows', async () => {
@@ -319,6 +323,10 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                 workflow.do('Channels', 'pikkuCommandChannels', null),
                 workflow.do('CLI', 'pikkuCLI', null),
             ]);
+            // Written on every build, empty when the addon has no tables: the
+            // consumer reads an absent file as a package that cannot say whether it
+            // ships a schema, which is a broken publish rather than a quiet no.
+            await writeSchemaArtifact(config.rootDir, config.outDir, config.db?.pgliteExtensions);
         }
         const hasFunctionRegistrations = await workflow.do('Functions', 'pikkuFunctions', null);
         allImports.push(config.functionsMetaFile);

package/dist/src/services.js

@@ -177,6 +177,7 @@ export const createSingletonServices = async (config) => {
     let unfilteredStateIsSetupOnly = false;
     let inspectedTsGeneration;
     let inspectorInvalidated = false;
+    let inspectPass = 0;
     const releaseProgram = (state) => {
         if (state)
             state.program = undefined;
@@ -244,6 +245,7 @@ export const createSingletonServices = async (config) => {
                 config.consoleFunctionsFile,
                 config.remoteRpcWorkersFile,
                 config.webhookWorkersFile,
+                config.remoteJobsFile,
                 config.workflowRoutesFile,
                 config.publicRpcFile,
                 config.publicAgentFile,
@@ -276,6 +278,16 @@ export const createSingletonServices = async (config) => {
                 ? ((await loadManifest(join(config.rootDir, 'versions.pikku.json'))) ??
                     undefined)
                 : undefined;
+            // The outgoing state's `typesLookup` holds live `ts.Type`s. A type reaches
+            // its checker and the checker reaches the whole program, so that one map
+            // pins a parsed program and an exercised checker for as long as the state
+            // exists — `releaseProgram` alone frees nothing. Every reader of the old
+            // state is done once a re-inspection is asked for, so drop the types here
+            // and the old program is collectable while the new one is built, instead
+            // of both being live at once.
+            if (unfilteredState && 'typesLookup' in unfilteredState) {
+                unfilteredState.typesLookup.clear();
+            }
             const oldProgram = unfilteredState?.program ?? undefined;
             const inspectStart = Date.now();
             unfilteredStateIsSetupOnly = setupOnly;
@@ -317,6 +329,17 @@ export const createSingletonServices = async (config) => {
                 manifest,
             });
             logger.debug(`Inspector took ${Date.now() - inspectStart}ms`);
+            // One row per inspector pass under PIKKU_TIMING, next to the step table
+            // `pikku all` prints: the counts say what the pass did, the ms say what
+            // it cost here. The benchmark gates on the counts.
+            if (process.env.PIKKU_TIMING && unfilteredState.stats) {
+                const s = unfilteredState.stats;
+                inspectPass++;
+                logger.info(`[INSPECT] pass=${inspectPass} ${setupOnly ? 'setup' : 'full'} ` +
+                    `files=${s.files} project=${s.projectFiles} reused=${s.filesReused} ` +
+                    `types=${s.types} instantiations=${s.instantiations} symbols=${s.symbols} ` +
+                    `cpu=${s.cpuMs}ms wall=${s.wallMs}ms heap=${s.heapUsedMb}MB`);
+            }
             inspectedTsGeneration = tsGenerationAtInspect;
             inspectorInvalidated = false;
             releaseProgram(unfilteredState);

package/dist/src/utils/pikku-cli-config.js

@@ -390,6 +390,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
             workflow: 'workflowRoutesFile',
             events: 'eventsChannelFile',
             remoteRpc: 'remoteRpcWorkersFile',
+            remoteJobs: 'remoteJobsFile',
         };
         const scaffoldBlock = result.scaffold;
         for (const [feature, outputField] of Object.entries(SCAFFOLD_OUTPUT_FIELDS)) {
@@ -415,6 +416,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (result.scaffold?.webhook && !result.webhookSchemasFile) {
             result.webhookSchemasFile = join(resolvedScaffoldDir, 'webhook', 'webhook.schemas.gen.ts');
         }
+        if (result.scaffold?.remoteJobs && !result.remoteJobsFile) {
+            result.remoteJobsFile = join(resolvedScaffoldDir, 'remote-jobs', 'remote-jobs.gen.ts');
+        }
         if (result.scaffold?.workflow && !result.workflowRoutesFile) {
             result.workflowRoutesFile = join(resolvedScaffoldDir, 'workflow', 'workflow-routes.gen.ts');
         }

package/dist/src/utils/remote-jobs-schemas-file.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The schemas module always sits beside the routes that import it, so there is
+ * nothing to configure: a settable path could be moved out from under the
+ * generated `./remote-jobs.schemas.gen.js` import and nothing would write it.
+ */
+export declare const remoteJobsSchemasFile: (remoteJobsFile: string | undefined) => string | undefined;