@ultimat3/action 1.0.0

package/src/client.ts

@@ -0,0 +1,150 @@
+/**
+ * Projection 3: the typed RPC client. Types come from the action map, paths from
+ * the same pure derivation the server uses, so a renamed or mistyped action is a
+ * compile error in a Solid component — not a 404 at runtime.
+ */
+import { UltimateError } from '@ultimat3/core';
+import type { InferInput, InferOutput, StandardSchemaV1 } from '@ultimat3/schema';
+import type { Action } from './action';
+import { ContractDriftError, RpcFailedError } from './errors';
+import { BUILD_ID_HEADER, IDEMPOTENCY_HEADER } from './http';
+import { derivePath } from './naming';
+import { isJsonObject } from './stable';
+
+/**
+ * Loose constraint on purpose: a map of concrete `Action<In, Out>` values must be
+ * assignable to it, while `Client<T>` still recovers each action's exact schemas.
+ */
+export interface ActionLike {
+  readonly kind: 'action';
+  readonly name: string;
+}
+
+export type ActionMap = Record<string, ActionLike>;
+
+export interface CallOptions {
+  readonly idempotencyKey?: string;
+  readonly signal?: AbortSignal;
+}
+
+/** `api.publishPost({ postId })` with both sides of the schema inferred. */
+export type Client<TActions extends ActionMap> = {
+  readonly [K in keyof TActions]: TActions[K] extends Action<infer TIn, infer TOut>
+    ? ClientMethod<TIn, TOut>
+    : never;
+};
+
+export type ClientMethod<TIn extends StandardSchemaV1, TOut extends StandardSchemaV1> = (
+  input: InferInput<TIn>,
+  options?: CallOptions,
+) => Promise<InferOutput<TOut>>;
+
+export type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+
+export interface ClientOptions {
+  readonly baseUrl: string;
+  readonly fetch?: FetchLike;
+  /** Sent on every call; a differing server build id raises X_CONTRACT_DRIFT. */
+  readonly buildId?: string;
+  readonly headers?: Readonly<Record<string, string>>;
+}
+
+/**
+ * The typed client for a whole action map: `rpc<Api['actions']>({ baseUrl })`. One blessed
+ * name — there is no `createClient` twin to choose between.
+ */
+export function rpc<TActions extends ActionMap>(options: ClientOptions): Client<TActions> {
+  const proxy = new Proxy(
+    {},
+    {
+      get(_target, property: string | symbol) {
+        if (typeof property !== 'string') return undefined;
+        return clientMethodFor(property, options);
+      },
+    },
+  );
+  // The proxy realizes the mapped type structurally; TS cannot check a Proxy.
+  return proxy as Client<TActions>;
+}
+
+/**
+ * One action's method — what `rpc` proxies to and what `action.client()` returns.
+ * Both spellings are the same call, so a per-action client can never drift from the
+ * map-wide one.
+ */
+export function clientMethodFor<TInput extends StandardSchemaV1, TOutput extends StandardSchemaV1>(
+  name: string,
+  options: ClientOptions,
+): ClientMethod<TInput, TOutput> {
+  const doFetch: FetchLike = options.fetch ?? ((input, init) => fetch(input, init));
+  const base = options.baseUrl.replace(/\/+$/, '');
+  // Erased at the wire seam; the response type is this action's by construction.
+  return (input, callOptions = {}) =>
+    call(doFetch, base, options, name, input, callOptions) as Promise<InferOutput<TOutput>>;
+}
+
+async function call(
+  doFetch: FetchLike,
+  base: string,
+  options: ClientOptions,
+  name: string,
+  input: unknown,
+  callOptions: CallOptions,
+): Promise<unknown> {
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    ...options.headers,
+  };
+  if (options.buildId !== undefined) headers[BUILD_ID_HEADER] = options.buildId;
+  if (callOptions.idempotencyKey !== undefined) {
+    headers[IDEMPOTENCY_HEADER] = callOptions.idempotencyKey;
+  }
+
+  const init: RequestInit = {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(input ?? {}),
+    ...(callOptions.signal === undefined ? {} : { signal: callOptions.signal }),
+  };
+  const response = await doFetch(`${base}${derivePath(name).path}`, init);
+  assertSameBuild(options.buildId, response.headers.get(BUILD_ID_HEADER), name);
+  if (!response.ok) throw await toUltimateError(response, name);
+  if (response.status === 204) return undefined;
+  const body: unknown = await response.json();
+  return body;
+}
+
+/**
+ * Version skew is a contract problem, not a network problem: the client holds
+ * types from build A while build B answers. Fail loudly so the shell reloads.
+ */
+function assertSameBuild(
+  clientBuild: string | undefined,
+  serverBuild: string | null,
+  name: string,
+): void {
+  if (clientBuild === undefined || serverBuild === null) return;
+  if (clientBuild === serverBuild) return;
+  throw new ContractDriftError(
+    `client build ${clientBuild} called ${name} on server build ${serverBuild}`,
+    'reload the page to pick up the new client bundle',
+  );
+}
+
+/** `application/problem+json` back into the same error the server threw. */
+async function toUltimateError(response: Response, name: string): Promise<UltimateError> {
+  const body: unknown = await response.json().catch(() => null);
+  if (isJsonObject(body) && typeof body['code'] === 'string') {
+    return new UltimateError({
+      code: body['code'],
+      cause: stringOr(body['cause'] ?? body['detail'], `${name} failed with ${response.status}`),
+      fix: stringOr(body['fix'], `x actions describe ${name} --json`),
+      docs: stringOr(body['docs'], `https://ultimate.dev/errors/${body['code']}`),
+    });
+  }
+  return new RpcFailedError(name, response.status);
+}
+
+function stringOr(value: unknown, fallback: string): string {
+  return typeof value === 'string' && value.length > 0 ? value : fallback;
+}

package/src/contract-test.ts

@@ -0,0 +1,116 @@
+/**
+ * Projection 6: the tests. `x g action` emits these three assertions for every
+ * new action, so an action that skips validation, skips authz, or never reaches
+ * the spec fails CI on the day it is written.
+ */
+
+import type { Ctx } from '@ultimat3/core';
+import { createContext, isUltimateError } from '@ultimat3/core';
+import type { AnyAction } from './action';
+import { ContractDriftError } from './errors';
+import { actionName, invoke } from './invoke';
+import { derivePath } from './naming';
+import { buildOpenApi } from './openapi';
+
+export interface ContractTest {
+  readonly name: string;
+  run(): Promise<void>;
+}
+
+export interface ContractTestOptions {
+  /** Value the input schema must reject. `null` fails every object schema. */
+  readonly garbage?: unknown;
+  readonly ctx?: Ctx;
+}
+
+/** A context whose actor is core's anonymous actor — what a signed-out caller has. */
+export function anonymousCtx(): Ctx {
+  return createContext({});
+}
+
+export function contractTestsFor(
+  target: AnyAction,
+  options: ContractTestOptions = {},
+): readonly ContractTest[] {
+  const name = actionName(target);
+  const garbage = 'garbage' in options ? options.garbage : null;
+  const ctx = options.ctx ?? anonymousCtx();
+
+  return [
+    {
+      name: `${name}: input schema rejects garbage`,
+      run: async () => {
+        await expectThrow(
+          () => invoke(target, garbage, { ctx, surface: 'http' }),
+          'X_INPUT_INVALID',
+          `${name} accepted ${JSON.stringify(garbage) ?? 'undefined'} as input`,
+          `tighten \`input:\` in the ${name} definition`,
+        );
+      },
+    },
+    {
+      name: `${name}: policy denies an anonymous actor`,
+      run: async () => {
+        await expectThrow(
+          () => invoke(target, emptyInput(), { ctx, surface: 'http' }),
+          null,
+          `${name} ran for an actor of null`,
+          `make the ${name} policy require an authenticated actor`,
+        );
+      },
+    },
+    {
+      name: `${name}: OpenAPI document contains its operation`,
+      run: async () => {
+        const document = buildOpenApi({ actions: [target] });
+        const path = derivePath(name).path;
+        if (document.paths[path] === undefined) {
+          throw new ContractDriftError(
+            `OpenAPI document has no entry for ${path}`,
+            'x verify --contract',
+          );
+        }
+      },
+    },
+  ];
+}
+
+/**
+ * The generated policy test. Emitted as source (not executed here) because the
+ * app owns which actors it considers privileged.
+ */
+export function policyTestStubFor(target: AnyAction): string {
+  const name = actionName(target);
+  return `import { contractTestsFor } from '@ultimat3/action';
+import { ${name} } from './actions';
+
+// Fill in: arrange a foreign actor, expect the policy to deny.
+// The contract tests below are framework-generated and always included.
+for (const contract of contractTestsFor(${name})) {
+  test(contract.name, async () => {
+    await contract.run();
+  });
+}
+`;
+}
+
+/** An input the schema may still reject — only the policy assertion depends on it. */
+function emptyInput(): unknown {
+  return {};
+}
+
+async function expectThrow(
+  run: () => Promise<unknown>,
+  code: string | null,
+  cause: string,
+  fix: string,
+): Promise<void> {
+  try {
+    await run();
+  } catch (error) {
+    if (!isUltimateError(error)) throw error;
+    if (code === null || error.code === code) return;
+    throw new ContractDriftError(`${cause} (got ${error.code}, expected ${code})`, fix);
+  }
+  throw new ContractDriftError(cause, fix);
+}

package/src/define-api.ts

@@ -0,0 +1,138 @@
+/**
+ * The API registry: one call that turns an app's primitive modules into the registered,
+ * projectable API surface. `apps/web/api/index.ts` calls it and nothing else, so importing
+ * that module IS the boot — and the value it returns is also the type the RPC client is
+ * shaped from, which is why there is no second list of names to keep in step.
+ */
+
+import { type PrimitiveKind, primitiveRegistrar, type RegisteredPrimitive } from '@ultimat3/core';
+import { registerActions } from './registry';
+
+/** A module namespace: `import * as postActions from './actions'`. */
+export type ApiModule = Readonly<Record<string, unknown>>;
+
+/** One module, or several — a feature per entry, never a list of name strings. */
+export type ApiModules = ApiModule | readonly ApiModule[];
+
+export interface ApiDef {
+  readonly actions?: ApiModules;
+  /** A mutator IS an action; it registers as one, on the same authz path. */
+  readonly mutators?: ApiModules;
+  readonly queries?: ApiModules;
+  /** `llm()` returns an action, so a model call registers exactly like every other one. */
+  readonly llm?: ApiModules;
+  /** The export name becomes the durable queue key — a job row names the handle, not a counter. */
+  readonly jobs?: ApiModules;
+  /** A task only enqueues jobs; handing it over here is what names its cron after its export. */
+  readonly tasks?: ApiModules;
+}
+
+type Get<TDef, TKey extends string> = TKey extends keyof TDef ? TDef[TKey] : undefined;
+
+/**
+ * The exports a registrar would take, and only those. A feature module legitimately exports its
+ * own helpers next to its primitives; carrying one into `Api['actions']` would offer the client a
+ * method the server never registered and no surface can project.
+ */
+type Registered<TModule, TKind extends string> = {
+  readonly [K in keyof TModule as TModule[K] extends { readonly kind: TKind }
+    ? K
+    : never]: TModule[K];
+};
+
+/**
+ * Intersect a tuple of module namespaces. `{ createPost } & { inviteMember }` is the map the
+ * typed client indexes, so `rpc<Api['actions']>()` knows every action without a codegen step.
+ */
+type Merge<TModules, TKind extends string> = [TModules] extends [undefined]
+  ? EmptyModule
+  : TModules extends readonly [infer THead, ...infer TRest]
+    ? Registered<THead, TKind> & Merge<TRest, TKind>
+    : TModules extends readonly []
+      ? EmptyModule
+      : Registered<TModules, TKind>;
+
+type EmptyModule = Readonly<Record<never, never>>;
+
+/** What `defineApi` returns: the registered primitives, merged and keyed by export name. */
+export interface Api<TDef extends ApiDef> {
+  readonly actions: Merge<Get<TDef, 'actions'>, 'action'> &
+    Merge<Get<TDef, 'mutators'>, 'action'> &
+    Merge<Get<TDef, 'llm'>, 'action'>;
+  readonly queries: Merge<Get<TDef, 'queries'>, 'query'>;
+  readonly jobs: Merge<Get<TDef, 'jobs'>, 'job'>;
+  readonly tasks: Merge<Get<TDef, 'tasks'>, 'task'>;
+}
+
+/**
+ * Register every primitive the app exposes, in one call.
+ *
+ * ```ts
+ * export const api = defineApi({
+ *   actions: [postActions, orgActions],
+ *   mutators: [postMutators],
+ *   queries: [postQueries],
+ * });
+ * ```
+ *
+ * Names come from export names, so two features exporting one name collide here with
+ * `X_ACTION_DUPLICATE` instead of merging silently. Actions, mutators and `llm()` calls all
+ * land in the action registry — they are the same primitive. Queries, jobs and tasks reach
+ * their own registries through core's registrar table, because `@ultimat3/query` and
+ * `@ultimat3/jobs` are on this tier and importing either sideways is a build error.
+ */
+export function defineApi<const TDef extends ApiDef>(def: TDef): Api<TDef> {
+  const actionModules = [
+    ...moduleList(def.actions),
+    ...moduleList(def.mutators),
+    ...moduleList(def.llm),
+  ];
+
+  const actions: RegisteredPrimitive[] = [];
+  for (const module of actionModules) actions.push(...registerActions(module));
+
+  const queries = registerThrough('query', moduleList(def.queries));
+  // Jobs before tasks: a task's descriptor lists the jobs it enqueues by name, so registering
+  // the other way round would read the queue keys one boot step before they were assigned.
+  const jobs = registerThrough('job', moduleList(def.jobs));
+  const tasks = registerThrough('task', moduleList(def.tasks));
+
+  return Object.freeze({
+    actions: byRegisteredName(actions),
+    queries: byRegisteredName(queries),
+    jobs: byRegisteredName(jobs),
+    tasks: byRegisteredName(tasks),
+  }) as Api<TDef>;
+}
+
+/**
+ * Hand `modules` to the package that owns `kind`, through core's registrar table. Resolved only
+ * when there is something to register: a missing registrar with modules in hand must be an
+ * error, never a silent skip that drops every primitive of that kind.
+ */
+function registerThrough(
+  kind: PrimitiveKind,
+  modules: readonly ApiModule[],
+): readonly RegisteredPrimitive[] {
+  if (modules.length === 0) return [];
+  const register = primitiveRegistrar(kind);
+  const registered: RegisteredPrimitive[] = [];
+  for (const module of modules) registered.push(...register(module));
+  return registered;
+}
+
+function moduleList(modules: ApiModules | undefined): readonly ApiModule[] {
+  if (modules === undefined) return [];
+  return Array.isArray(modules) ? modules : [modules as ApiModule];
+}
+
+/**
+ * Keyed by the name registration stamped, read back off the registrar's own results — never off
+ * the module's exports. Copying every export would seat a feature's helper in `api.actions` under
+ * a name no surface serves, and the last module exporting that name would win in silence.
+ */
+function byRegisteredName(primitives: readonly RegisteredPrimitive[]): ApiModule {
+  const map: Record<string, RegisteredPrimitive> = {};
+  for (const primitive of primitives) map[primitive.name] = primitive;
+  return Object.freeze(map);
+}

package/src/errors.ts

@@ -0,0 +1,195 @@
+/**
+ * Every failure @ultimat3/action can produce, one subclass per stable code so
+ * callers `instanceof` a specific failure instead of string-matching a message.
+ */
+import { assertNever, registerErrorCodes, UltimateError } from '@ultimat3/core';
+import type { SurfaceDenial } from '@ultimat3/policy';
+
+const docs = (code: string): string => `https://ultimate.dev/errors/${code}`;
+
+/**
+ * Titles for the framework-wide code table — every one of them owned by this package.
+ * `X_INPUT_INVALID` and `X_RPC_FAILED` are action's: an action is where an input schema is
+ * enforced and where the typed client speaks, and `@ultimat3/query` only throws them.
+ * Authz codes are absent on purpose — `ActionDeniedError` re-uses the policy decision's code.
+ */
+const OWNED_TITLES: Readonly<Record<string, string>> = {
+  X_ACTION_DUPLICATE: 'two actions are registered under one name',
+  X_ACTION_FOREIGN: 'a value that is not an action was projected as one',
+  X_ACTION_POLICY_MISSING: 'an action was registered without a policy',
+  X_ACTION_UNREGISTERED: 'an action was projected before it was registered',
+  X_CONTRACT_DRIFT: 'client and server disagree about the contract',
+  X_IDEMPOTENCY_CONFLICT: 'idempotency key reused with a different payload or still in flight',
+  X_INPUT_INVALID: 'input failed schema validation',
+  X_OUTPUT_INVALID: 'a handler returned a value its output schema rejects',
+  X_RPC_FAILED: 'an RPC call failed without a problem+json body',
+};
+
+// One unconditional call: a presence guard would turn "another package claims one of these codes"
+// from an X_ERROR_CODE_DUPLICATE at import into whichever module loaded first deciding the title.
+registerErrorCodes(
+  Object.fromEntries(Object.entries(OWNED_TITLES).map(([code, title]) => [code, { title }])),
+);
+
+/** Thrown when a projection needs a name the action does not have yet. */
+export class ActionUnregisteredError extends UltimateError {
+  constructor() {
+    super({
+      code: 'X_ACTION_UNREGISTERED',
+      cause: 'an action was projected before it was registered, so it has no name',
+      fix: "call registerActions(await import('./actions')) at boot, before mounting routes",
+      docs: docs('X_ACTION_UNREGISTERED'),
+    });
+  }
+}
+
+/**
+ * Thrown when a projection is handed something that never came out of `action()`.
+ * The declaration is private to `invoke.ts`, so an object that merely looks like
+ * an action has no handler to run and no policy to evaluate — refusing it here is
+ * how "there is one execution path" stays true at runtime, not just in the types.
+ */
+export class ActionForeignError extends UltimateError {
+  constructor(name: string) {
+    super({
+      code: 'X_ACTION_FOREIGN',
+      cause: `"${name === '' ? 'anonymous' : name}" is not an action built by action()`,
+      fix: "declare it as `export const name = action({ input, output, policy, handle })` from '@ultimat3/action'",
+      docs: docs('X_ACTION_FOREIGN'),
+    });
+  }
+}
+
+export function denialCode(denial: SurfaceDenial): string {
+  switch (denial.surface) {
+    case 'http':
+      return denial.problem.code;
+    case 'live':
+    case 'job':
+      return denial.code;
+    case 'mcp':
+      return denial.content[0]?.text.split(':')[0] ?? 'X_FORBIDDEN';
+    default:
+      return assertNever(denial);
+  }
+}
+
+export function denialReason(denial: SurfaceDenial): string {
+  switch (denial.surface) {
+    case 'http':
+      return denial.problem.detail;
+    case 'live':
+    case 'job':
+      return denial.reason;
+    case 'mcp':
+      return denial.content[0]?.text ?? 'denied';
+    default:
+      return assertNever(denial);
+  }
+}
+
+/**
+ * An authz denial, thrown by `guard()`. The code and reason come from the policy
+ * decision — this package never invents an authz code — and the surface-shaped
+ * denial rides along for projections that render it themselves.
+ */
+export class ActionDeniedError extends UltimateError {
+  readonly denial: SurfaceDenial;
+
+  constructor(action: string, denial: SurfaceDenial) {
+    const code = denialCode(denial);
+    super({
+      code,
+      cause: `${action} denied: ${denialReason(denial)}`,
+      fix: `x policy explain ${action} --json   # shows which clause decided and why`,
+      docs: docs(code),
+    });
+    this.denial = denial;
+  }
+}
+
+export class ActionDuplicateError extends UltimateError {
+  constructor(name: string) {
+    super({
+      code: 'X_ACTION_DUPLICATE',
+      cause: `two actions are registered under the name "${name}"`,
+      fix: `rename one export — action names are globally unique: x actions list --json`,
+      docs: docs('X_ACTION_DUPLICATE'),
+    });
+  }
+}
+
+export class ActionPolicyMissingError extends UltimateError {
+  constructor(name: string) {
+    super({
+      code: 'X_ACTION_POLICY_MISSING',
+      cause: `action "${name}" was registered without a policy`,
+      fix: `add \`policy: can('${name}')\` to the action definition in the file that exports it`,
+      docs: docs('X_ACTION_POLICY_MISSING'),
+    });
+  }
+}
+
+export class InputInvalidError extends UltimateError {
+  constructor(name: string, detail: string) {
+    super({
+      code: 'X_INPUT_INVALID',
+      cause: `input for action "${name}" failed validation: ${detail}`,
+      fix: `x actions describe ${name} --json  # prints the expected input schema`,
+      docs: docs('X_INPUT_INVALID'),
+    });
+  }
+}
+
+/**
+ * The mirror of `InputInvalidError`, and a server bug rather than a caller's:
+ * the handler produced something its own `output` schema rejects, so the client,
+ * the OpenAPI response and the MCP `outputSchema` would all have been lied to.
+ */
+export class OutputInvalidError extends UltimateError {
+  constructor(name: string, detail: string) {
+    super({
+      code: 'X_OUTPUT_INVALID',
+      cause: `action "${name}" returned a value its output schema rejects: ${detail}`,
+      fix: `x actions describe ${name} --json  # compare the handler's return against \`output:\``,
+      docs: docs('X_OUTPUT_INVALID'),
+    });
+  }
+}
+
+export type IdempotencyConflictReason = 'payload-mismatch' | 'in-flight';
+
+export class IdempotencyConflictError extends UltimateError {
+  constructor(key: string, reason: IdempotencyConflictReason) {
+    super({
+      code: 'X_IDEMPOTENCY_CONFLICT',
+      cause:
+        reason === 'payload-mismatch'
+          ? `idempotency key "${key}" was already used with a different payload`
+          : `idempotency key "${key}" is still in flight from an earlier request`,
+      fix:
+        reason === 'payload-mismatch'
+          ? 'send a fresh Idempotency-Key header for a different payload'
+          : 'retry the same Idempotency-Key after the first request settles',
+      docs: docs('X_IDEMPOTENCY_CONFLICT'),
+    });
+  }
+}
+
+/** The client got a non-`problem+json` failure — a proxy, not our server, answered. */
+export class RpcFailedError extends UltimateError {
+  constructor(name: string, status: number) {
+    super({
+      code: 'X_RPC_FAILED',
+      cause: `${name} returned HTTP ${status} without a problem+json body`,
+      fix: `check the gateway in front of the app, then: x actions describe ${name} --json`,
+      docs: docs('X_RPC_FAILED'),
+    });
+  }
+}
+
+export class ContractDriftError extends UltimateError {
+  constructor(cause: string, fix: string) {
+    super({ code: 'X_CONTRACT_DRIFT', cause, fix, docs: docs('X_CONTRACT_DRIFT') });
+  }
+}

package/src/facade.ts

@@ -0,0 +1,42 @@
+/**
+ * The fluent surface: every projection reachable as a method on the action itself,
+ * `publishPost.tool()` rather than `toMcpTool(publishPost)`, and every declared
+ * field lifted off `def` so app code never reaches through `.def`. The projection
+ * functions stay exported for the framework's own call sites — this file only
+ * binds them to the action, it never re-implements one.
+ */
+
+import type { InferOutput, StandardSchemaV1 } from '@ultimat3/schema';
+import type { Action, ActionDef, ActionFacade } from './action';
+import { clientMethodFor } from './client';
+import { contractTestsFor } from './contract-test';
+import { toOpenApiOperation } from './http';
+import { actionName, invoke } from './invoke';
+import { toJobHandle } from './job-handle';
+import { toMcpTool } from './mcp-tool';
+
+/**
+ * `self` is a thunk on purpose: the façade is attached while the action is still
+ * being assembled, so every method resolves the action when it is called, not now.
+ */
+export function facadeFor<TInput extends StandardSchemaV1, TOutput extends StandardSchemaV1>(
+  def: ActionDef<TInput, TOutput>,
+  self: () => Action<TInput, TOutput>,
+): ActionFacade<TInput, TOutput> {
+  return {
+    input: def.input,
+    output: def.output,
+    policy: def.policy,
+    ...(def.mcp === undefined ? {} : { mcp: def.mcp }),
+    // `.as()` is impersonation on the one execution path: `invoke` keeps the
+    // surrounding context whole and swaps only the actor. Erased at the seam;
+    // the output type is this action's by construction.
+    as: (actor, input, options) =>
+      invoke(self(), input, { ...options, actor }) as Promise<InferOutput<TOutput>>,
+    tool: () => toMcpTool(self()),
+    openapi: () => toOpenApiOperation(self()),
+    client: (options) => clientMethodFor(actionName(self()), options),
+    job: () => toJobHandle(self()),
+    contract: (options) => contractTestsFor(self(), options),
+  };
+}