@pikku/core 0.12.145 → 0.12.147

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

@@ -1,4 +1,4 @@
-import { addonCallerOf, addonMayReach } from '../addon/addon-reach.js';
+import { AddonNotUsedError, addonCallerOf, addonMayReach, mapAddonCall, } from '../addon/addon-reach.js';
 import { forwardStepName, isCompensationStepName, } from '../../compensation-name.js';
 import { addonInstanceForNamespace } from '../addon/addon-runner.js';
 import { isAddonFunctionExposed } from '../addon/wire-addon.js';
@@ -6,6 +6,8 @@ import { pikkuState } from '../../pikku-state.js';
 import { PikkuError, addError } from '../../errors/error-handler.js';
 import { parseVersionedId } from '../../version.js';
 import { resolveRemoteAddonToken } from '../addon/remote-addon-auth.js';
+import { DEFAULT_REMOTE_ADDON_TIMEOUT_MS, REMOTE_CONTRACT_HEADER, } from '../addon/wire-remote-addon.js';
+import { BadRequestError, ConflictError, ForbiddenError, GoneError, LockedError, NotFoundError, PayloadTooLargeError, PaymentRequiredError, PreconditionFailedError, TooManyRequestsError, UnauthorizedError, UnprocessableContentError, UnsupportedMediaTypeError, } from '../../errors/errors.js';
 /**
  * The function runner, reached lazily. `function-runner` builds every
  * invocation's `wire.rpc` from this module, so a static import back would be a
@@ -31,8 +33,8 @@ const resolveWireSession = async (wire) => typeof wire.getSession === 'function'
  */
 export class RPCNotFoundError extends PikkuError {
     rpcName;
-    constructor(rpcName) {
-        super(`RPC function not found: ${rpcName}`);
+    constructor(rpcName, message = `RPC function not found: ${rpcName}`) {
+        super(message);
         this.rpcName = rpcName;
     }
 }
@@ -51,27 +53,120 @@ addError(RemoteAddonConfigError, {
     status: 500,
     message: 'Remote addon is misconfigured.',
 });
-/** Thrown when a remote addon answers an RPC with a non-2xx status. Maps to HTTP 502; the upstream status is kept on `httpStatus` and the first 300 characters of its body in the message. */
-export class RemoteAddonRequestError extends PikkuError {
-    httpStatus;
-    constructor(namespace, fnName, status, detail) {
-        super(`Remote addon '${namespace}:${fnName}' returned ${status}${detail ? `: ${detail}` : ''}`);
-        this.httpStatus = status;
+/**
+ * Thrown when a remote addon fails on its own side — a 5xx, an unreachable
+ * host, or a response that is not JSON. Maps to HTTP 502. What went wrong is
+ * logged on this host; none of it reaches the caller.
+ */
+export class RemoteAddonFailedError extends PikkuError {
+    constructor(namespace, fnName) {
+        super(`Remote addon '${namespace}:${fnName}' failed`);
     }
 }
-addError(RemoteAddonRequestError, {
+addError(RemoteAddonFailedError, {
     status: 502,
-    message: 'Remote addon request failed.',
+    message: 'Remote addon failed.',
 });
-export class AddonNotUsedError extends PikkuError {
-    constructor(caller, target) {
-        super(`Addon '${caller}' called '${target}' but does not list it in its wireAddon 'uses'.`);
+/** Thrown when a remote addon does not answer within the wiring's `timeoutMs`. Maps to HTTP 504. */
+export class RemoteAddonTimeoutError extends PikkuError {
+    constructor(namespace, fnName, timeoutMs) {
+        super(`Remote addon '${namespace}:${fnName}' did not answer within ${timeoutMs}ms`);
     }
 }
-addError(AddonNotUsedError, {
-    status: 403,
-    message: 'Addon called another addon it does not use.',
+addError(RemoteAddonTimeoutError, {
+    status: 504,
+    message: 'Remote addon timed out.',
 });
+/** Headers a wiring's `headers` hook cannot set: the call's auth, trace and contract. */
+const RESERVED_REMOTE_HEADERS = new Set([
+    'authorization',
+    'x-request-id',
+    REMOTE_CONTRACT_HEADER,
+    'content-type',
+    'accept',
+]);
+/**
+ * The plain error for each 4xx a remote addon may answer with, used when its
+ * body names no error this host knows. Constructed without a message, so the
+ * caller gets the registered generic one.
+ */
+const GENERIC_CLIENT_ERRORS = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    402: PaymentRequiredError,
+    403: ForbiddenError,
+    404: NotFoundError,
+    409: ConflictError,
+    410: GoneError,
+    412: PreconditionFailedError,
+    413: PayloadTooLargeError,
+    415: UnsupportedMediaTypeError,
+    422: UnprocessableContentError,
+    423: LockedError,
+    429: TooManyRequestsError,
+};
+/**
+ * The registered error class named `name` whose status is `status`, rebuilt
+ * without running its constructor — a constructor's arguments are not on the
+ * wire, and running one with the wrong ones could throw or mislabel the error.
+ */
+const rebuildRegisteredError = (name, status, message) => {
+    if (typeof name !== 'string' || !name) {
+        return undefined;
+    }
+    for (const [ErrorClass, details] of pikkuState(null, 'misc', 'errors')) {
+        if (ErrorClass.name !== name || details.status !== status) {
+            continue;
+        }
+        const error = Object.create(ErrorClass.prototype);
+        Object.defineProperty(error, 'name', {
+            value: name,
+            writable: true,
+            configurable: true,
+        });
+        Object.defineProperty(error, 'message', {
+            value: typeof message === 'string' && message ? message : details.message,
+            writable: true,
+            configurable: true,
+        });
+        Error.captureStackTrace?.(error, rebuildRegisteredError);
+        return error;
+    }
+    return undefined;
+};
+/**
+ * The error a non-2xx response from a remote addon becomes on this host.
+ *
+ * A 4xx naming an error registered here with the same status is rebuilt as
+ * that error, message included — the addon already chose to show it to its
+ * caller. Any other 4xx becomes the generic error for its status. A 5xx, or a
+ * status with no generic error, becomes {@link RemoteAddonFailedError}. The
+ * response body is never passed through: anything beyond the rebuilt message
+ * is logged here and goes no further.
+ *
+ * knowledge: decisions/security/remote-addon-errors-are-rebuilt-not-passed-through.md
+ */
+const remoteAddonResponseError = async (res, namespace, fnName, logger) => {
+    const body = await res.text().catch(() => '');
+    if (res.status >= 400 && res.status < 500) {
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch { }
+        const rebuilt = rebuildRegisteredError(parsed?.name, res.status, parsed?.message);
+        if (rebuilt) {
+            return rebuilt;
+        }
+        const GenericError = GENERIC_CLIENT_ERRORS[res.status];
+        if (GenericError) {
+            return new GenericError();
+        }
+    }
+    logger.error(`Remote addon '${namespace}:${fnName}' answered ${res.status}: ${body.slice(0, 1000)}`);
+    return new RemoteAddonFailedError(namespace, fnName);
+};
+export { AddonNotUsedError };
 export const resolveNamespace = (namespacedFunction) => {
     const colonIndex = namespacedFunction.indexOf(':');
     if (colonIndex === -1) {
@@ -131,6 +226,27 @@ const resolvePikkuFunction = (rpcName, packageName = null) => {
     }
     return { pikkuFuncId: rpcMeta, packageName: null };
 };
+/**
+ * A caller from outside names `fn@vN` because it was built against that
+ * version. Serving it the latest instead would hand it a contract it does not
+ * know, so a version this host no longer has is refused, not resolved to the
+ * base name the way an internal caller's is. An unversioned function is its
+ * own v1.
+ */
+const refuseUnknownVersion = (rpcName) => {
+    const { baseName, version } = parseVersionedId(rpcName);
+    if (version === null)
+        return;
+    const rpc = pikkuState(null, 'rpc', 'meta');
+    if (rpc[rpcName])
+        return;
+    const current = rpc[baseName];
+    if (!current)
+        return;
+    if (version === 1 && parseVersionedId(current).version === null)
+        return;
+    throw new RPCNotFoundError(rpcName, `RPC function not found: ${rpcName}. Version ${version} of '${baseName}' is no longer served here; update the SDK this call was built against.`);
+};
 /**
  * Marks an addon RPC name that could not be resolved. Module-private on purpose:
  * resolution failure must never be conflated with an `RPCNotFoundError` thrown by
@@ -157,22 +273,36 @@ export class ContextAwareRPCService {
         let resolvedAddon = null;
         if (funcName.includes(':')) {
             resolvedAddon = resolveNamespace(funcName);
+            if (resolvedAddon?.addonConfig.remote) {
+                // A remote addon's functions have no meta on this host. Its contract
+                // stands in for the addon's own `expose`, and the host enforces it:
+                // every forwarded call carries REMOTE_CONTRACT_HEADER.
+                if (!isAddonFunctionExposed(resolvedAddon.addonConfig.expose, parseVersionedId(resolvedAddon.function).baseName, true)) {
+                    throw new RPCNotFoundError(funcName);
+                }
+                return await this.rpc(funcName, data);
+            }
             if (resolvedAddon) {
                 functionMeta = pikkuState(resolvedAddon.package, 'function', 'meta')[resolvedAddon.function];
             }
         }
         else {
+            if (!this.packageName)
+                refuseUnknownVersion(funcName);
             const resolved = resolvePikkuFunction(funcName, this.packageName);
             functionMeta = pikkuState(resolved.packageName, 'function', 'meta')[resolved.pikkuFuncId];
         }
         if (!functionMeta) {
+            // Whether a function is in the remote contract is only known where its
+            // meta is, so a contract call never leaves this unit.
+            if (this.wire.http?.request?.header(REMOTE_CONTRACT_HEADER)) {
+                throw new RPCNotFoundError(funcName);
+            }
             // The addon runs in another deploy unit, which only carries the
-            // functions the analyzer found exposed. A wiring present here still
-            // gets to narrow what is forwarded.
+            // functions the analyzer found exposed. The wiring present here must
+            // still opt in to the function before it is forwarded.
             const refusedHere = resolvedAddon &&
-                (resolvedAddon.addonConfig.expose === false ||
-                    (Array.isArray(resolvedAddon.addonConfig.expose) &&
-                        !resolvedAddon.addonConfig.expose.includes(resolvedAddon.function)));
+                !isAddonFunctionExposed(resolvedAddon.addonConfig.expose, resolvedAddon.function, true);
             if (funcName.includes(':') &&
                 this.services.deploymentService &&
                 !refusedHere) {
@@ -186,6 +316,10 @@ export class ContextAwareRPCService {
         if (!exposed || functionMeta.scenarioStep) {
             throw new RPCNotFoundError(funcName);
         }
+        if (this.wire.http?.request?.header(REMOTE_CONTRACT_HEADER) &&
+            functionMeta.remote !== true) {
+            throw new RPCNotFoundError(funcName);
+        }
         return await this.rpc(funcName, data);
     }
     async rpc(funcName, data) {
@@ -225,18 +359,7 @@ export class ContextAwareRPCService {
         });
     }
     mapUsedAddon(funcName) {
-        const caller = this.wire.addonNamespace;
-        if (!caller)
-            return funcName;
-        const colon = funcName.indexOf(':');
-        const prefix = funcName.slice(0, colon);
-        if (prefix === caller)
-            return funcName;
-        const uses = pikkuState(null, 'addons', 'packages').get(caller)?.uses;
-        const mapped = uses?.[prefix];
-        if (mapped)
-            return `${mapped}${funcName.slice(colon)}`;
-        throw new AddonNotUsedError(caller, funcName);
+        return mapAddonCall(this.wire.addonNamespace, funcName);
     }
     /**
      * Resolution half of an addon RPC call: never executes anything, so an
@@ -323,33 +446,76 @@ export class ContextAwareRPCService {
         if (!serverUrl) {
             throw new RemoteAddonConfigError(namespace, 'serverUrl resolved empty');
         }
-        const remoteFn = cfg.remoteName ? cfg.remoteName(fnName) : fnName;
+        // The host serves `fn` as its own latest, which may be newer than the
+        // contract this consumer was built against, so a call always names a
+        // version: the caller's, or the newest in the SDK (registered by codegen).
+        const versionedFn = parseVersionedId(fnName).version !== null
+            ? fnName
+            : (pikkuState(cfg.package, 'rpc', 'meta')[fnName] ?? fnName);
+        // `remoteName` maps the base name; the version rides on the mapped name,
+        // so a lookup-table mapping still matches a versioned call.
+        const { baseName, version } = parseVersionedId(versionedFn);
+        const remoteFn = cfg.remoteName
+            ? `${cfg.remoteName(baseName)}${version !== null ? `@v${version}` : ''}`
+            : versionedFn;
         const token = await resolveRemoteAddonToken(cfg.remoteAuth, this.services, this.wire, namespace);
         const headers = {
             'content-type': 'application/json',
             accept: 'application/json',
         };
+        if (cfg.remoteHeaders) {
+            for (const [name, value] of Object.entries(await cfg.remoteHeaders(this.services, this.wire))) {
+                // Matched case-insensitively: `Authorization` next to `authorization`
+                // would reach the host as one combined value.
+                if (!RESERVED_REMOTE_HEADERS.has(name.toLowerCase())) {
+                    headers[name] = value;
+                }
+            }
+        }
+        headers[REMOTE_CONTRACT_HEADER] = '1';
         if (token) {
             headers.authorization = `Bearer ${token}`;
         }
         if (this.wire.traceId) {
             headers['x-request-id'] = this.wire.traceId;
         }
+        const timeoutMs = cfg.remoteTimeoutMs ?? DEFAULT_REMOTE_ADDON_TIMEOUT_MS;
         const base = serverUrl.replace(/\/+$/, '');
-        const res = await fetch(`${base}/remote/rpc/${encodeURIComponent(remoteFn)}`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify({ rpcName: remoteFn, data }),
-        });
+        let res;
+        try {
+            // The body the generated `POST /rpc/:rpcName` route reads, the same one
+            // the generated fetch client sends.
+            res = await fetch(`${base}/rpc/${encodeURIComponent(remoteFn)}`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ rpcName: remoteFn, data }),
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (e) {
+            if (e?.name === 'TimeoutError') {
+                throw new RemoteAddonTimeoutError(namespace, remoteFn, timeoutMs);
+            }
+            this.services.logger.error(`Remote addon '${namespace}:${remoteFn}' could not be reached: ${e instanceof Error ? e.message : e}`);
+            throw new RemoteAddonFailedError(namespace, remoteFn);
+        }
         if (!res.ok) {
-            const detail = (await res.text().catch(() => '')).slice(0, 300);
-            throw new RemoteAddonRequestError(namespace, remoteFn, res.status, detail);
+            throw await remoteAddonResponseError(res, namespace, remoteFn, this.services.logger);
         }
         if (res.status === 204) {
             return undefined;
         }
         const text = await res.text();
-        return (text ? JSON.parse(text) : undefined);
+        if (!text) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            this.services.logger.error(`Remote addon '${namespace}:${remoteFn}' answered ${res.status} with a body that is not JSON`);
+            throw new RemoteAddonFailedError(namespace, remoteFn);
+        }
     }
     async rpcWithWire(rpcName, data, wire) {
         const mergedWire = {
@@ -421,10 +587,10 @@ export class ContextAwareRPCService {
         }
         return createAgentRPC(this.wire, this.options);
     }
-    async remote(funcName, data) {
+    async mesh(funcName, data) {
         if (!this.services.deploymentService) {
-            throw new Error(`No DeploymentService configured for remote RPC: ${funcName}. ` +
-                `Set up a DeploymentService to enable remote function calls.`);
+            throw new Error(`No DeploymentService configured for mesh RPC: ${funcName}. ` +
+                `Set up a DeploymentService to enable mesh function calls.`);
         }
         const session = await resolveWireSession(this.wire);
         return this.services.deploymentService.invoke(funcName, data, session, this.wire.traceId);
@@ -437,7 +603,7 @@ export class ContextAwareRPCService {
  * `DeploymentService` when the function lives in another deployment unit.
  * `rpc.exposed` does the same but only reaches functions marked `expose: true`
  * (and, for addons, those the consuming app exposes), which is what the public
- * RPC endpoint uses. `rpc.remote` always goes through the `DeploymentService`.
+ * RPC endpoint uses. `rpc.mesh` always goes through the `DeploymentService`.
  * Calls carry the caller's wire, so the session and trace ID propagate. An addon
  * can only call the addons it lists in `uses`.
  *
@@ -473,7 +639,7 @@ class ContextRPCView {
     depth;
     global = false;
     invoke;
-    remote;
+    mesh;
     exposed;
     startWorkflow;
     rpcWithWire;
@@ -481,7 +647,7 @@ class ContextRPCView {
         this.serviceRPC = serviceRPC;
         this.depth = depth;
         this.invoke = serviceRPC.rpc.bind(serviceRPC);
-        this.remote = serviceRPC.remote.bind(serviceRPC);
+        this.mesh = serviceRPC.mesh.bind(serviceRPC);
         this.exposed = serviceRPC.rpcExposed.bind(serviceRPC);
         this.startWorkflow = serviceRPC.startWorkflow.bind(serviceRPC);
         this.rpcWithWire = serviceRPC.rpcWithWire.bind(serviceRPC);

package/dist/wirings/rpc/rpc-types.d.ts

@@ -1,12 +1,12 @@
 import type { CredentialOverrides } from '../credential/credential-overrides.js';
 import type { PikkuRawWire } from '../../types/core.types.js';
 import type { AgentInterruptResult } from '../agent/agent-interrupt.js';
-/** The `rpc` object on a function's wire. An app's generated types narrow `invoke`, `remote`, `startWorkflow` and `agent` to its own functions, workflows and agents; see {@link PikkuRPCService} for how each call is routed. */
-export type PikkuRPC<Invoke extends (...args: any[]) => any = (...args: any[]) => any, Remote extends (...args: any[]) => any = (...args: any[]) => any, startWorkflow extends (...args: any[]) => any = (...args: any[]) => any, AgentRun extends (...args: any[]) => any = (...args: any[]) => any, AgentStream extends (...args: any[]) => any = (...args: any[]) => any> = {
+/** The `rpc` object on a function's wire. An app's generated types narrow `invoke`, `mesh`, `startWorkflow` and `agent` to its own functions, workflows and agents; see {@link PikkuRPCService} for how each call is routed. */
+export type PikkuRPC<Invoke extends (...args: any[]) => any = (...args: any[]) => any, Mesh extends (...args: any[]) => any = (...args: any[]) => any, startWorkflow extends (...args: any[]) => any = (...args: any[]) => any, AgentRun extends (...args: any[]) => any = (...args: any[]) => any, AgentStream extends (...args: any[]) => any = (...args: any[]) => any> = {
     depth: number;
     global: boolean;
     invoke: Invoke;
-    remote: Remote;
+    mesh: Mesh;
     exposed: (name: string, data: any) => Promise<any>;
     /** Invoke an RPC with explicit wire fields merged over the caller's. */
     rpcWithWire: <In = any, Out = any>(rpcName: string, data: In, wire: PikkuRawWire) => Promise<Out>;
@@ -47,7 +47,7 @@ export interface ResolvedFunction {
         package: string;
         auth?: boolean;
         tags?: string[];
-        /** Set by the consuming app: which functions `rpc.exposed` may call */
+        /** Set by the consuming app: which of the addon's declared-exposed functions `rpc.exposed` may call */
         expose?: boolean | string[];
         rpcEndpoint?: string;
         secretOverrides?: Record<string, string>;
@@ -75,8 +75,11 @@ export interface ResolvedFunction {
         } | {
             secretId: string;
         } | {
-            resolve: (services: any, wire: any) => string | Promise<string>;
+            resolve: (services: any, wire: any) => string | null | Promise<string | null>;
         };
+        /** Maps the base fn name; a versioned call appends `@vN` after it. */
         remoteName?: (fn: string) => string;
+        remoteTimeoutMs?: number;
+        remoteHeaders?: (services: any, wire: any) => Record<string, string> | Promise<Record<string, string>>;
     };
 }

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

@@ -737,7 +737,7 @@ async function invokeGraphNodeRpc(workflowService, rpcService, runId, stepId, no
 export async function executeGraphStep(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName) {
     try {
         let result;
-        const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName];
+        const subWorkflowMeta = getWorkflowMeta(rpcName);
         const agentMeta = subWorkflowMeta
             ? undefined
             : pikkuState(null, 'agent', 'agentsMeta')[rpcName];
@@ -801,7 +801,7 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
     await workflowService.setStepRunning(stepState.stepId);
     try {
         let result;
-        const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName];
+        const subWorkflowMeta = getWorkflowMeta(rpcName);
         const agentMeta = subWorkflowMeta
             ? undefined
             : pikkuState(null, 'agent', 'agentsMeta')[rpcName];

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

@@ -691,8 +691,7 @@ export class PikkuWorkflowService {
             if (!run) {
                 throw new Error(`Workflow run not found: ${runId}`);
             }
-            const meta = pikkuState(null, 'workflows', 'meta');
-            const workflowMeta = meta[run.workflow];
+            const workflowMeta = resolveWorkflowMeta(run.workflow)?.meta;
             const isGraphWorkflow = workflowMeta?.source === 'graph';
             let graphNodeId;
             if (isGraphWorkflow && workflowMeta?.nodes) {
@@ -709,7 +708,7 @@ export class PikkuWorkflowService {
                 result = await executeGraphStep(this, rpcService, runId, stepState.stepId, graphNodeId, workflowMeta.nodes[graphNodeId].rpcName, data, run.workflow);
             }
             else {
-                if (meta[rpcName]) {
+                if (resolveWorkflowMeta(rpcName)) {
                     result = await startQueuedChildStep({
                         startWorkflow: (...args) => this.startWorkflow(...args),
                         setStepChildRunId: (...args) => this.setStepChildRunId(...args),
@@ -860,7 +859,7 @@ export class PikkuWorkflowService {
             if (resolvedStepOptions.virtualUser) {
                 return resolvedStepOptions.virtualUser.invoke(rpcName, data);
             }
-            if (pikkuState(null, 'workflows', 'meta')[rpcName]) {
+            if (resolveWorkflowMeta(rpcName)) {
                 return runInlineChildStep({
                     startWorkflow: (...args) => this.startWorkflow(...args),
                     setStepChildRunId: (...args) => this.setStepChildRunId(...args),

package/dist/wirings/workflow/workflow-compensation.js

@@ -2,6 +2,7 @@ import { DEFAULT_STEP_RETRIES, NO_COMPENSATE_STATE_PREFIX, WORKFLOW_TERMINAL_STA
 import { pikkuState } from '../../pikku-state.js';
 import { resolveNamespace } from '../rpc/rpc-runner.js';
 import { runningStepLease } from './workflow-step-lease.js';
+import { isWorkflowName } from './workflow-meta-resolver.js';
 import { planUnwind } from './workflow-unwind-plan.js';
 const ENTERABLE = new Set([
     'running',
@@ -177,8 +178,7 @@ export const functionHasCompensation = (rpcName) => {
             ?.compensate === true
         : false;
 };
-export const isChildWorkflowRecord = (record) => !!record.rpcName &&
-    pikkuState(null, 'workflows', 'meta')[record.rpcName] !== undefined;
+export const isChildWorkflowRecord = (record) => !!record.rpcName && isWorkflowName(record.rpcName);
 export const recordHasCompensation = (record) => isChildWorkflowRecord(record)
     ? !!record.childRunId
     : !!record.rpcName && functionHasCompensation(record.rpcName);

package/dist/wirings/workflow/workflow-meta-resolver.d.ts

@@ -9,3 +9,8 @@ export type ResolvedWorkflowMeta = {
  * `namespace:name` form — against the addon package that claims the namespace.
  */
 export declare const resolveWorkflowMeta: (name: string) => ResolvedWorkflowMeta | null;
+/**
+ * Whether a step's rpcName names a workflow — the app's, or an addon's by
+ * `namespace:name` — and so starts a child run rather than an RPC.
+ */
+export declare const isWorkflowName: (name: string) => boolean;

package/dist/wirings/workflow/workflow-meta-resolver.js

@@ -29,3 +29,8 @@ export const resolveWorkflowMeta = (name) => {
         resolvedName: localName,
     };
 };
+/**
+ * Whether a step's rpcName names a workflow — the app's, or an addon's by
+ * `namespace:name` — and so starts a child run rather than an RPC.
+ */
+export const isWorkflowName = (name) => resolveWorkflowMeta(name) !== null;

package/dist/wirings/workflow/workflow-queue-routing.js

@@ -1,6 +1,7 @@
 import { getSingletonServices, pikkuState } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
 import { DEFAULT_STEP_RETRIES, forwardStepName } from './workflow-constants.js';
+import { isWorkflowName } from './workflow-meta-resolver.js';
 const toKebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 export const resolveWorkflowConfig = () => {
     const workflow = getSingletonServices().config?.workflow;
@@ -54,8 +55,7 @@ export const stepDispatchTarget = async (rpcName, stepName, parentIsInline) => {
         }
         return 'queue';
     }
-    const isWorkflow = pikkuState(null, 'workflows', 'meta')[rpcName] !== undefined;
-    if (!isWorkflow || !hasQueue) {
+    if (!isWorkflowName(rpcName) || !hasQueue) {
         return 'inline';
     }
     return (await parentIsInline()) ? 'inline' : 'queue';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.145",
+  "version": "0.12.147",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -24,6 +24,7 @@
   },
   "sideEffects": [
     "./dist/errors/errors.js",
+    "./dist/wirings/addon/addon-reach.js",
     "./dist/wirings/addon/remote-addon-auth.js",
     "./dist/wirings/agent/agent-rpc.js",
     "./dist/wirings/rpc/rpc-runner.js",
@@ -49,7 +50,7 @@
     "./channel/local": "./dist/wirings/channel/local/index.js",
     "./channel/serverless": "./dist/wirings/channel/serverless/index.js",
     "./http": "./dist/wirings/http/index.js",
-    "./remote": "./dist/remote.js",
+    "./mesh": "./dist/mesh.js",
     "./queue": "./dist/wirings/queue/index.js",
     "./scheduler": "./dist/wirings/scheduler/index.js",
     "./trigger": "./dist/wirings/trigger/index.js",

package/dist/wirings/addon/define-screens.d.ts

@@ -1,34 +0,0 @@
-type AddonScreenBase = {
-    /** Where the screen mounts under the addon, e.g. `/` or `/:id`. */
-    path: string;
-    title: string;
-    /** Lists the screen in the host's navigation. */
-    nav?: boolean;
-    /** Required of the viewer to see the screen. The addon's functions must enforce the same scopes: hiding a screen is not access control. */
-    scopes?: string[];
-};
-/** A screen rendered by the host from the addon's source. */
-export type AddonComponentScreen = AddonScreenBase & {
-    component: () => Promise<{
-        default: unknown;
-    }>;
-};
-/** A static program the host serves in a sandboxed iframe. */
-export type AddonAppScreen = AddonScreenBase & {
-    /** Directory of the built program, relative to the addon package. */
-    app: string;
-};
-/** One screen an addon ships: either a component the host renders or a static app it serves in a sandboxed iframe. */
-export type AddonScreen = AddonComponentScreen | AddonAppScreen;
-/** The manifest passed to `defineScreens`: the addon's title, optional icon and its screens. */
-export type ScreensManifest = {
-    title: string;
-    icon?: string;
-    screens: AddonScreen[];
-};
-/**
- * Declares the screens an addon ships, which the host mounts when it is wired
- * with `ui: true`. Read statically by `pikku all`, so `path`, `title`, `nav`, `scopes` and `app` must be literals.
- */
-export declare const defineScreens: (manifest: ScreensManifest) => ScreensManifest;
-export {};

package/dist/wirings/addon/define-screens.js

@@ -1,5 +0,0 @@
-/**
- * Declares the screens an addon ships, which the host mounts when it is wired
- * with `ui: true`. Read statically by `pikku all`, so `path`, `title`, `nav`, `scopes` and `app` must be literals.
- */
-export const defineScreens = (manifest) => manifest;