@pikku/core 0.12.146 → 0.12.147

package/dist/function/function-runner.js

@@ -62,6 +62,13 @@ async function resolveSession(wire, singletonServices, sessionService) {
  * @param packageName - The addon package it belongs to; `null` for the app.
  */
 export const addFunction = (funcName, funcConfig, packageName = null) => {
+    if (funcConfig.disabled) {
+        throw new Error(`Function '${funcName}' is disabled` +
+            (typeof funcConfig.disabled === 'string'
+                ? ` (${funcConfig.disabled})`
+                : '') +
+            ' and cannot be registered.');
+    }
     pikkuState(packageName, 'function', 'functions').set(funcName, funcConfig);
 };
 export const getFunctionNames = (packageName = null) => {

package/dist/function/functions.types.d.ts

@@ -128,6 +128,14 @@ export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any,
     version?: number;
     /** Filters this function in and out of a build — see the `tags` option on `pikku all`. It has no effect at runtime. */
     tags?: string[];
+    /**
+     * Switches the function off: `true`, or a string saying why. The build
+     * leaves it out of every map, client and wiring, and refuses (PKU562)
+     * anything that still references it, so marking a function believed dead
+     * proves it. The source keeps type-checking; deleting the flag turns it
+     * back on.
+     */
+    disabled?: true | string;
     /** Makes the function callable from outside as `POST /rpc/<name>`. Without a session requirement, a permission or an addon gate, that means callable by anyone. */
     expose?: boolean;
     /**

package/dist/types/state.types.d.ts

@@ -15,7 +15,7 @@ import type { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler
 import type { CoreWorkflow, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
 import type { CoreFeature } from '../wirings/workflow/scenario.types.js';
 import type { CoreTrigger, CoreTriggerSource, TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.types.js';
-import type { CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
+import type { CreateConfig, CreateSingletonServices, CreateWireServices, CoreSingletonServices } from './core.types.js';
 import type { FunctionsMeta } from '../function/function-meta.types.js';
 import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../middleware/middleware.types.js';
 import type { CorePikkuChannelMiddleware } from '../wirings/channel/channel.types.js';
@@ -168,10 +168,11 @@ export interface PikkuPackageState {
         permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
     };
     package: {
+        /** Every package's own factories, each typed where it is defined. */
         factories: {
-            createConfig?: CreateConfig<CoreConfig>;
-            createSingletonServices?: CreateSingletonServices<CoreConfig, CoreSingletonServices>;
-            createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>;
+            createConfig?: CreateConfig<any>;
+            createSingletonServices?: CreateSingletonServices<any, any>;
+            createWireServices?: CreateWireServices<any, any, any>;
         } | null;
         singletonServices: CoreSingletonServices | null;
         /** The pikkuBetterAuth factory, self-registered when auth.ts is evaluated.

package/dist/wirings/addon/addon-reach.d.ts

@@ -1,3 +1,13 @@
+import { PikkuError } from '../../errors/error-handler.js';
 import type { PikkuRawWire } from '../../types/core.types.js';
 export declare const addonMayReach: (caller: string, funcName: string) => boolean;
 export declare const addonCallerOf: (wire: PikkuRawWire) => string | undefined;
+export declare class AddonNotUsedError extends PikkuError {
+    constructor(caller: string, target: string);
+}
+/**
+ * The name an addon's call resolves to on this host, through its `uses`.
+ *
+ * knowledge: decisions/security/an-addon-may-reach-only-itself-and-the-addons-it-uses.md
+ */
+export declare const mapAddonCall: (caller: string | undefined, funcName: string) => string;

package/dist/wirings/addon/addon-reach.js

@@ -1,4 +1,5 @@
 import { ForbiddenError } from '../../errors/errors.js';
+import { PikkuError, addError } from '../../errors/error-handler.js';
 import { ADDON_HEADER } from '../../middleware/addon-scope-cap.js';
 import { pikkuState } from '../../pikku-state.js';
 export const addonMayReach = (caller, funcName) => {
@@ -19,3 +20,31 @@ export const addonCallerOf = (wire) => {
     }
     return name;
 };
+export class AddonNotUsedError extends PikkuError {
+    constructor(caller, target) {
+        super(`Addon '${caller}' called '${target}' but does not list it in its wireAddon 'uses'.`);
+    }
+}
+addError(AddonNotUsedError, {
+    status: 403,
+    message: 'Addon called another addon it does not use.',
+});
+/**
+ * The name an addon's call resolves to on this host, through its `uses`.
+ *
+ * knowledge: decisions/security/an-addon-may-reach-only-itself-and-the-addons-it-uses.md
+ */
+export const mapAddonCall = (caller, funcName) => {
+    if (!caller)
+        return funcName;
+    const colon = funcName.indexOf(':');
+    if (colon === -1)
+        return funcName;
+    const prefix = funcName.slice(0, colon);
+    if (prefix === caller)
+        return funcName;
+    const mapped = pikkuState(null, 'addons', 'packages').get(caller)?.uses?.[prefix];
+    if (mapped)
+        return `${mapped}${funcName.slice(colon)}`;
+    throw new AddonNotUsedError(caller, funcName);
+};

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

@@ -1,7 +1,7 @@
 export { wireAddon } from './wire-addon.js';
 export type { WireAddonConfig } from './wire-addon.js';
-export { defineScreens } from './define-screens.js';
-export type { ScreensManifest, AddonScreen, AddonComponentScreen, AddonAppScreen, } from './define-screens.js';
+export { pikkuStudio } from './pikku-studio.js';
+export type { StudioManifest, StudioScreen, StudioComponentScreen, StudioAppScreen, StudioNav, } from './pikku-studio.js';
 export { wireRemoteAddon } from './wire-remote-addon.js';
 export type { WireRemoteAddonConfig, RemoteAddonAuth, } from './wire-remote-addon.js';
 export { resolveRemoteAddonToken, RemoteAddonAuthError, } from './remote-addon-auth.js';

package/dist/wirings/addon/index.js

@@ -1,4 +1,4 @@
 export { wireAddon } from './wire-addon.js';
-export { defineScreens } from './define-screens.js';
+export { pikkuStudio } from './pikku-studio.js';
 export { wireRemoteAddon } from './wire-remote-addon.js';
 export { resolveRemoteAddonToken, RemoteAddonAuthError, } from './remote-addon-auth.js';

package/dist/wirings/addon/pikku-studio.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Where an addon screen shows in Studio's navigation. Leave it out and the
+ * screen is routed but not listed.
+ */
+export type StudioNav = {
+    area: 'rail' | 'team' | 'project' | 'account';
+    /** The icon's name. */
+    icon: string;
+    order: number;
+    /** Names a function of the addon that returns a count shown on the entry. */
+    badge?: string;
+};
+type StudioScreenBase = {
+    /** The route path, under the prefix its `scope` gives it. */
+    path: string;
+    /** A message key in the addon's catalog, `messages/{locale}.json`. It is also the nav label. */
+    title: string;
+    nav?: StudioNav;
+    /** Takes over the core screen at the same path. Only first-party addons may use it. */
+    replaces?: boolean;
+    /** `'bare'` renders the screen without the shell. */
+    layout?: 'bare';
+    /** Hides the screen and its nav for viewers without access. The addon's functions must enforce the same scopes: hiding a screen is not access control. */
+    scopes?: string[];
+} & ({
+    /** `'studio'` gives `/<path>`, `'team'` gives `/<team>/<path>`. */
+    scope: 'studio' | 'team';
+    needsApp?: never;
+} | {
+    /** `/<team>/<project>[/<target>]/<path>`. */
+    scope: 'project';
+    /** The screen needs the project's app running. Defaults to `false`. */
+    needsApp?: boolean;
+});
+/** A screen rendered by the host from the addon's source. */
+export type StudioComponentScreen = StudioScreenBase & {
+    component: () => Promise<{
+        default: unknown;
+    }>;
+};
+/** A static program the host serves in a sandboxed iframe. */
+export type StudioAppScreen = StudioScreenBase & {
+    /** 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 StudioScreen = StudioComponentScreen | StudioAppScreen;
+/** The manifest passed to `pikkuStudio`: the addon's title, a message key, and its screens. */
+export type StudioManifest = {
+    title: string;
+    screens: StudioScreen[];
+};
+/**
+ * Declares the screens and nav an addon brings to Pikku Studio. Read
+ * statically by `pikku all`, so every field must be a literal. Titles are
+ * message keys in the addon's own catalog, `messages/{locale}.json`: a key
+ * missing from `messages/en.json` fails the build.
+ */
+export declare const pikkuStudio: (manifest: StudioManifest) => StudioManifest;
+export {};

package/dist/wirings/addon/pikku-studio.js

@@ -0,0 +1,7 @@
+/**
+ * Declares the screens and nav an addon brings to Pikku Studio. Read
+ * statically by `pikku all`, so every field must be a literal. Titles are
+ * message keys in the addon's own catalog, `messages/{locale}.json`: a key
+ * missing from `messages/en.json` fails the build.
+ */
+export const pikkuStudio = (manifest) => manifest;

package/dist/wirings/addon/wire-addon.d.ts

@@ -46,18 +46,22 @@ export type WireAddonConfig = {
     /** Filters this addon in and out of a build — see the `tags` option on `pikku all`. It has no effect at runtime. */
     tags?: string[];
     /**
-     * Mounts the screens the addon ships (see `defineScreens`) in the host under
-     * `/addons/<name>`. Without it the addon's screens are ignored. The package
-     * must declare at least one, or `pikku all` rejects the wiring.
+     * Mounts the screens the addon ships (see `pikkuStudio`) in the host, each at
+     * the path its `scope` gives it. Without it the addon's screens are ignored.
+     * The package must declare at least one, or `pikku all` rejects the wiring.
      */
     ui?: boolean;
     /** Required of every function in the addon, on top of the function's own. */
     scopes?: string[];
     /**
-     * The other addons this one may call, as `{ '<package>': '<name>' }`: the
-     * package it was written against, and the name that package is wired under
-     * in this app. The addon calls `'<package>:<function>'`; anything it did not
-     * list is refused, whatever else the app has wired.
+     * The other addons this one may call, as `{ '<alias>': '<name>' }`: the name
+     * the addon calls another by, and the name that addon is wired under in this
+     * app — by `wireAddon` or `wireRemoteAddon`, either serves. The alias is the
+     * one the addon's package.json declares under `pikku.uses`
+     * (`{ "stripe": "@acme/addon-stripe@^1.0.0" }`), or, for an addon that lists
+     * plain names, the package name itself. The addon calls
+     * `'<alias>:<function>'`; anything it did not declare, or this app did not
+     * map, is refused, whatever else the app has wired.
      */
     uses?: Record<string, string>;
     /** Points a secret the addon reads at a different key in this deployment, so two instances can hold different credentials. */

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

@@ -1,4 +1,5 @@
 import { pikkuState } from '../../pikku-state.js';
+import { mapAddonCall } from '../addon/addon-reach.js';
 import { runAgent, resumeAgentSync } from './agent-runner.js';
 import { streamAgent, resumeAgent, interruptAgent } from './agent-stream.js';
 import { wrapChannelWithAGUI } from './agent-agui.js';
@@ -31,10 +32,10 @@ export const createAgentRPC = (wire, options) => {
         }),
     });
     return {
-        run: async (agentName, input) => asRunResult(await runAgent(agentName, input, params())),
+        run: async (agentName, input) => asRunResult(await runAgent(mapAddonCall(wire.addonNamespace, agentName), input, params())),
         stream: async (agentName, input, streamOptions) => {
             let currentRunId;
-            await streamAgent(agentName, input, wrapChannelWithAGUI(streamingChannel(), {
+            await streamAgent(mapAddonCall(wire.addonNamespace, agentName), input, wrapChannelWithAGUI(streamingChannel(), {
                 threadId: input.threadId,
                 getRunId: () => currentRunId,
             }), params(), undefined, {
@@ -49,7 +50,9 @@ export const createAgentRPC = (wire, options) => {
             await resumeAgent({ runId, ...input }, wrapChannelWithAGUI(streamingChannel(), { runId }), params(), streamOptions);
         },
         interrupt: async (runId, reason) => interruptAgent({ runId, ...(reason ? { reason } : {}) }, { sessionService: options.sessionService }),
-        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAgentSync(runId, approvals, { sessionService: options.sessionService }, expectedAgentName)),
+        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAgentSync(runId, approvals, { sessionService: options.sessionService }, expectedAgentName === undefined
+            ? undefined
+            : mapAddonCall(wire.addonNamespace, expectedAgentName))),
     };
 };
 /**

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

@@ -1,3 +1,4 @@
+import { AddonNotUsedError } from '../addon/addon-reach.js';
 import type { CoreServices, PikkuRawWire } from '../../types/core.types.js';
 import type { SessionService } from '../../services/user-session-service.js';
 import type { CoreUserSession } from '../../types/core.types.js';
@@ -29,9 +30,7 @@ export declare class RemoteAddonFailedError extends PikkuError {
 export declare class RemoteAddonTimeoutError extends PikkuError {
     constructor(namespace: string, fnName: string, timeoutMs: number);
 }
-export declare class AddonNotUsedError extends PikkuError {
-    constructor(caller: string, target: string);
-}
+export { AddonNotUsedError };
 export declare const resolveNamespace: (namespacedFunction: string) => ResolvedFunction | null;
 export declare class ContextAwareRPCService {
     private services;

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';
@@ -166,15 +166,7 @@ const remoteAddonResponseError = async (res, namespace, fnName, logger) => {
     logger.error(`Remote addon '${namespace}:${fnName}' answered ${res.status}: ${body.slice(0, 1000)}`);
     return new RemoteAddonFailedError(namespace, fnName);
 };
-export class AddonNotUsedError extends PikkuError {
-    constructor(caller, target) {
-        super(`Addon '${caller}' called '${target}' but does not list it in its wireAddon 'uses'.`);
-    }
-}
-addError(AddonNotUsedError, {
-    status: 403,
-    message: 'Addon called another addon it does not use.',
-});
+export { AddonNotUsedError };
 export const resolveNamespace = (namespacedFunction) => {
     const colonIndex = namespacedFunction.indexOf(':');
     if (colonIndex === -1) {
@@ -367,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

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.146",
+  "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",

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;