@astrale-os/sdk 0.6.0-beta.35 → 0.6.0-beta.37

package/dist/application/workflow/durable.d.ts

@@ -1,11 +1,14 @@
 import type { IssuerId } from '../../platform/auth/index.js';
-import type { BoundClientSession, ExecutionOutcome, ExecutionRef } from '../../platform/client/session/index.js';
+import type { ExecutionOutcome, ExecutionRef } from '../../platform/client/session/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
 import type { CallableInputOf, Domain, ResolvedMethod } from '../../platform/schema/index.js';
 import type { Value } from '../../platform/value/index.js';
+import type { DomainCapabilities, DomainKernelSessions } from '../action/index.js';
+import type { HandlerDependencies } from '../dependency/index.js';
 import type { DeclaredErrorFactory, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
+import type { Integrations, ReplayableIntegrationClients } from '../integration/index.js';
 import type { Mutation, MutationExecutor } from '../mutation/index.js';
-import type { QueryExecutor } from '../query/index.js';
+import type { QueryDefinition } from '../query/index.js';
 /** A callable whose Schema declares `execution: { durable: true }`. */
 export interface DurableCallable {
     readonly execution: {
@@ -31,31 +34,46 @@ export interface DurableExecution {
     readonly receiver?: NodeId;
 }
 /**
- * The Domain's own authority inside one Step. Kernel access exists only here, so every Kernel call
- * belongs to a journaled Step and a replay never repeats it.
+ * What one Step holds: the capabilities of an Action, acting as the Domain alone. Kernel access
+ * exists only here, so every Kernel call belongs to a journaled Step and a replay never repeats it.
+ * Every key below comes from one sequence derived from the Execution, the Step and the position of
+ * the call, which restarts with each attempt: a retried Step sends the same keys again.
  */
-export interface DurableStepAuthority<DomainValue extends Domain = Domain> {
+export interface DurableStepAuthority<DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> extends DomainCapabilities<DomainValue, 'self'> {
     /**
      * Kernel Session acting as the Domain. Each `invoke` of a durable callable without an explicit
-     * `idempotencyKey` carries one derived from the Execution, the Step and its position, so a
-     * retried Step reaches the same durable child Execution. An `invoke` of any other callable
-     * carries no key, which the Kernel would refuse, and runs again when the Step is retried.
+     * `idempotencyKey` carries the next derived key, so a retried Step reaches the same durable child
+     * Execution. An `invoke` of any other callable carries no key, which the Kernel would refuse, and
+     * runs again when the Step is retried.
      */
-    readonly kernel: BoundClientSession;
-    readonly query: QueryExecutor<DomainValue>;
+    readonly kernel: DomainKernelSessions<'self'>;
+    /** Dependency invokers acting as the Domain, keyed like `kernel.invoke`. */
+    readonly dependencies: HandlerDependencies<DomainValue, 'self'>;
     /**
-     * Each Mutation carries a key derived from the Execution, the Step and its position. The Kernel
-     * commits a receipt with the write and answers a retried Step with its first result.
+     * Each Mutation carries the next derived key. The Kernel commits a receipt with the write and
+     * answers a retried Step with its first result.
      */
     readonly mutate: MutationExecutor<DomainValue>;
+    /**
+     * Operations a retried Step may attempt again. A keyed operation of source `execution` receives
+     * the next derived key as its idempotency key. An operation whose decision may be `unsafe` is
+     * absent, and refused before its Provider runs if its decision is `unsafe` anyway.
+     */
+    readonly integrations: ReplayableIntegrationClients<Definitions>;
 }
-export interface DurableStep<DomainValue extends Domain = Domain> {
+export interface DurableStep<DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> {
     /**
      * Run `execute` once and journal its portable output; a replay returns the journaled output. A
-     * Step may run again when its outcome was not journaled: its Mutations and durable calls are
-     * answered from their keys, and any other effect must be idempotent.
+     * Step may run again when its outcome was not journaled: its Mutations, durable calls and keyed
+     * Integration operations are answered from their keys, and any other effect must be idempotent.
      */
-    run<Output>(id: string, execute: (authority: DurableStepAuthority<DomainValue>) => Output | Promise<Output>): Promise<Output>;
+    run<Output>(id: string, execute: (authority: DurableStepAuthority<DomainValue, Definitions>) => Output | Promise<Output>): Promise<Output>;
+    /**
+     * One journaled Query. A replay returns the result of its first run, so a later Step that depends
+     * on it resends the same request whenever it is retried.
+     */
+    query<Output>(id: string, query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
+    query<Input, Output>(id: string, query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
     /**
      * One journaled Mutation. A Step replayed after its commit receives the result of that commit
      * from the Kernel's receipt instead of writing again.
@@ -67,18 +85,35 @@ type DurableSelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown,
 } : {
     readonly self?: never;
 };
+/** What a bounded wait for a signal ended with: the signal's value, or its timeout. */
+export type SignalOutcome<Signal extends Value = Value> = {
+    readonly kind: 'signal';
+    readonly value: Signal;
+} | {
+    readonly kind: 'timeout';
+};
 /** Context of a durable Workflow: engine-journaled, acting as its Domain. */
-export type DurableWorkflowContext<Callable, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = {
+export type DurableWorkflowContext<Callable, DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> = {
     readonly domain: DomainValue;
     readonly input: CallableInputOf<Callable>;
     readonly execution: DurableExecution;
     /** Construct one implementation-declared safe business error for `throw error(...)`. */
     readonly error: DeclaredErrorFactory<Errors>;
-    readonly step: DurableStep<DomainValue>;
+    readonly step: DurableStep<DomainValue, Definitions>;
     /** Durable timer kept by the engine, even while the Domain is idle or down. */
     sleep(durationMs: number): Promise<void>;
-    /** Resolve once `Execution.signal({ name, value })` delivers `name`, before or during the wait. */
-    promise<Signal extends Value = Value>(name: string): Promise<Signal>;
+    /**
+     * Wait for the value `Execution.signal({ name, value })` delivers once under `name`, whether it
+     * was sent before or during the wait.
+     */
+    awaitSignal<Signal extends Value = Value>(name: string): Promise<Signal>;
+    /**
+     * Wait at most `timeoutMs` for the signal `name`. The engine journals which came first, so a
+     * replay answers the same. A signal sent after the timeout is kept for a later wait.
+     */
+    awaitSignal<Signal extends Value = Value>(name: string, options: {
+        readonly timeoutMs: number;
+    }): Promise<SignalOutcome<Signal>>;
     /** Whether `error` is the engine's cooperative cancellation, which the Workflow may compensate. */
     cancelled(error: unknown): boolean;
     /** Wait durably for another Execution to end, by journaled polling of its `result`. */

package/dist/application/workflow/index.d.ts

@@ -1,6 +1,6 @@
 export { defineWorkflow, isWorkflow } from './define.js';
 export type { InlineWorkflowContext, WorkflowContext } from './context.js';
-export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableWorkflowContext, } from './durable.js';
+export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableWorkflowContext, SignalOutcome, } from './durable.js';
 export type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowCallable, WorkflowDefinition, WorkflowOptions, } from './workflow.js';
 export * as step from './step/index.js';
 export * as runner from './runner/index.js';

package/dist/execution/cache/cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Disposable entries one deployment keeps across its requests, and across its isolates where the
+ * platform shares them. An entry may vanish at any time and never outlives its expiry. A reader
+ * treats a failed or late read as a miss, so nothing that must persist or be coordinated belongs
+ * here: every consumer stays correct when the cache keeps nothing.
+ */
+export interface DeploymentCache {
+    /** The value kept under `key`, or undefined when it expired, vanished or was never kept. */
+    get(key: string): Promise<string | undefined>;
+    /**
+     * Keep `value` under `key` until `expiresAt` (Unix milliseconds) at the latest. The cache may
+     * drop it sooner, or not keep it at all.
+     */
+    put(key: string, value: string, expiresAt: number): Promise<void>;
+}
+/** Capture a caller-supplied cache, receiver-bound, after checking its shape. */
+export declare function deploymentCache(input: DeploymentCache): DeploymentCache;

package/dist/execution/cache/cache.js

@@ -0,0 +1,11 @@
+/** Capture a caller-supplied cache, receiver-bound, after checking its shape. */
+export function deploymentCache(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        typeof input.get !== 'function' ||
+        typeof input.put !== 'function') {
+        throw new TypeError('Deployment cache is invalid.');
+    }
+    return Object.freeze({ get: input.get.bind(input), put: input.put.bind(input) });
+}

package/dist/execution/cache/index.d.ts

@@ -0,0 +1,2 @@
+export { deploymentCache, type DeploymentCache } from './cache.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, type MemoryCacheOptions } from './memory.js';

package/dist/execution/cache/index.js

@@ -0,0 +1,2 @@
+export { deploymentCache } from './cache.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache } from './memory.js';

package/dist/execution/cache/memory.d.ts

@@ -0,0 +1,13 @@
+import type { DeploymentCache } from './cache.js';
+/** Entries one memory cache keeps by default before it evicts the least recently used. */
+export declare const DEFAULT_MEMORY_CACHE_ENTRIES = 1024;
+export interface MemoryCacheOptions {
+    /** Most entries kept at once; the least recently used is evicted first. */
+    readonly maximumEntries?: number;
+}
+/**
+ * A deployment cache held in this process or isolate: bounded, least recently used first out, and
+ * an entry is gone at its expiry. It keeps values only, never a pending operation, so no request
+ * waits on another's I/O.
+ */
+export declare function memoryCache(options?: MemoryCacheOptions, now?: () => number): DeploymentCache;

package/dist/execution/cache/memory.js

@@ -0,0 +1,48 @@
+/** Entries one memory cache keeps by default before it evicts the least recently used. */
+export const DEFAULT_MEMORY_CACHE_ENTRIES = 1_024;
+/**
+ * A deployment cache held in this process or isolate: bounded, least recently used first out, and
+ * an entry is gone at its expiry. It keeps values only, never a pending operation, so no request
+ * waits on another's I/O.
+ */
+export function memoryCache(options = {}, now = Date.now) {
+    if (options === null || typeof options !== 'object' || Array.isArray(options))
+        invalid();
+    const maximum = options.maximumEntries ?? DEFAULT_MEMORY_CACHE_ENTRIES;
+    if (!Number.isSafeInteger(maximum) || maximum < 1) {
+        throw new TypeError('Memory cache maximumEntries must be a positive integer.');
+    }
+    const entries = new Map();
+    return Object.freeze({
+        async get(key) {
+            if (typeof key !== 'string')
+                invalid();
+            const entry = entries.get(key);
+            if (entry === undefined)
+                return undefined;
+            entries.delete(key);
+            if (entry.expiresAt <= now())
+                return undefined;
+            entries.set(key, entry);
+            return entry.value;
+        },
+        async put(key, value, expiresAt) {
+            if (typeof key !== 'string' || typeof value !== 'string' || !Number.isFinite(expiresAt)) {
+                invalid();
+            }
+            entries.delete(key);
+            if (expiresAt <= now())
+                return;
+            while (entries.size >= maximum) {
+                const oldest = entries.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                entries.delete(oldest);
+            }
+            entries.set(key, Object.freeze({ value, expiresAt }));
+        },
+    });
+}
+function invalid() {
+    throw new TypeError('Memory cache input is invalid.');
+}

package/dist/execution/identity/authentication.js

@@ -56,10 +56,10 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
         throw protocolError('AUTH_INVALID', 'Credential is invalid.');
     }
     const expressions = callbackIdentities(established.delegation.credential);
-    const session = (expression) => callbackSession(expectedKernel, expression, established.verified, execution, configuration);
+    const session = (expression, validUntil) => callbackSession(expectedKernel, expression, validUntil, execution, configuration);
     const sessions = Object.freeze({
-        caller: session(expressions.caller),
-        self: session(expressions.self),
+        caller: session(expressions.caller, established.validUntil),
+        self: session(expressions.self, established.verified.exp),
     });
     const graph = Object.freeze({
         caller: bindSession(sessions.caller, execution),
@@ -111,13 +111,18 @@ export function executorSession(kernel, executionId, execution, configuration) {
     admitEndpoint(invocationUrl(admitted), configuration.policy);
     return callbackSession(admitted, selfIdentity, undefined, execution, configuration, executionId);
 }
-function callbackSession(kernel, expression, carrier, execution, configuration, executionId) {
-    const resolveCallback = createCallbackCredentialResolver(configuration.signing, configuration.issuer, configuration.subject, kernel, expression, carrier, execution, executionId);
+/**
+ * A Session whose callbacks carry `expression`, none outliving the execution or `validUntil`, the
+ * earliest expiry in Unix seconds of the credentials they derive from.
+ */
+function callbackSession(kernel, expression, validUntil, execution, configuration, executionId) {
+    const resolveCallback = createCallbackCredentialResolver(configuration.signing, configuration.issuer, configuration.subject, kernel, expression, validUntil, execution, executionId);
+    const expiresAt = Math.min(execution.deadline, (validUntil ?? Number.POSITIVE_INFINITY) * 1_000);
     return new ClientSession({
         kernel,
         fetch: boundedFetch(configuration.fetch, execution.signal),
         auth: {
-            ttlSeconds: Math.min(callbackTtl(execution.deadline), maximumCallbackDelegationTtlSeconds),
+            ttlSeconds: Math.min(callbackTtl(expiresAt), maximumCallbackDelegationTtlSeconds),
             async resolve(_call, signal) {
                 const callback = await resolveCallback(signal);
                 signal.throwIfAborted();
@@ -159,6 +164,7 @@ async function establishCaller(input, audience, verification, execution, policy)
         }
         return Object.freeze({
             verified: context.verified,
+            validUntil: Math.min(context.verified.exp ?? Number.POSITIVE_INFINITY, proof.verified.exp ?? Number.POSITIVE_INFINITY),
             delegation: carried,
             caller: Object.freeze({
                 kind: 'authenticated',

package/dist/execution/identity/callback.d.ts

@@ -1,4 +1,4 @@
-import type { IssuerId, UnresolvedIdentityExpr, VerifiedCredential } from '../../platform/auth/index.js';
+import type { IssuerId, UnresolvedIdentityExpr } from '../../platform/auth/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
 import type { SigningMaterial } from './signing.js';
 export declare const maximumCallbackTtlSeconds = 120;
@@ -29,17 +29,16 @@ export declare function signDomainCallback(signing: SigningMaterial, issuer: Iss
     readonly deadline: number;
     readonly signal: AbortSignal;
 }): Promise<string>;
-export declare function signCallback(signing: SigningMaterial, issuer: IssuerId, subject: string, audience: IssuerId, expression: UnresolvedIdentityExpr, carrier: VerifiedCredential, execution: {
-    readonly deadline: number;
-    readonly signal: AbortSignal;
-}): Promise<string>;
 /**
- * Reuse one exact callback authority partition, refreshing only near its bounded expiry. Without a
- * carrier the callback is the Domain's own authority, bounded by the execution alone. An
+ * Reuse one exact callback authority partition, refreshing only near its bounded expiry. No callback
+ * outlives `validUntil`, the earliest expiry in Unix seconds of the credentials it derives from: the
+ * Kernel folds each of them into the callback's validity, so a longer callback could not carry its
+ * delegation. Without it the callback is the Domain's own authority, bounded by the execution alone.
+ * Once that authority can no longer carry a callback, the call ends as DEADLINE_EXCEEDED. An
  * `executionId` is the durable Execution a step's executor credential names in `EXECUTION_CLAIM`;
  * no caller-bound callback names one.
  */
-export declare function createCallbackCredentialResolver(signing: SigningMaterial, issuer: IssuerId, subject: string, audience: IssuerId, expression: UnresolvedIdentityExpr, carrier: VerifiedCredential | undefined, execution: {
+export declare function createCallbackCredentialResolver(signing: SigningMaterial, issuer: IssuerId, subject: string, audience: IssuerId, expression: UnresolvedIdentityExpr, validUntil: number | undefined, execution: {
     readonly deadline: number;
     readonly signal: AbortSignal;
 }, executionId?: NodeId): (signal: AbortSignal) => Promise<SignedCallback>;

package/dist/execution/identity/callback.js

@@ -17,18 +17,17 @@ export function callbackIdentities(nested) {
 export async function signDomainCallback(signing, issuer, subject, audience, execution) {
     return (await sign(signing, issuer, subject, audience, selfIdentity, execution)).credential;
 }
-export async function signCallback(signing, issuer, subject, audience, expression, carrier, execution) {
-    const maximum = carrier.exp ?? Number.POSITIVE_INFINITY;
-    return (await sign(signing, issuer, subject, audience, expression, execution, maximum)).credential;
-}
 /**
- * Reuse one exact callback authority partition, refreshing only near its bounded expiry. Without a
- * carrier the callback is the Domain's own authority, bounded by the execution alone. An
+ * Reuse one exact callback authority partition, refreshing only near its bounded expiry. No callback
+ * outlives `validUntil`, the earliest expiry in Unix seconds of the credentials it derives from: the
+ * Kernel folds each of them into the callback's validity, so a longer callback could not carry its
+ * delegation. Without it the callback is the Domain's own authority, bounded by the execution alone.
+ * Once that authority can no longer carry a callback, the call ends as DEADLINE_EXCEEDED. An
  * `executionId` is the durable Execution a step's executor credential names in `EXECUTION_CLAIM`;
  * no caller-bound callback names one.
  */
-export function createCallbackCredentialResolver(signing, issuer, subject, audience, expression, carrier, execution, executionId) {
-    const maximum = carrier?.exp ?? Number.POSITIVE_INFINITY;
+export function createCallbackCredentialResolver(signing, issuer, subject, audience, expression, validUntil, execution, executionId) {
+    const maximum = validUntil ?? Number.POSITIVE_INFINITY;
     let cached;
     let pending;
     return async (signal) => {
@@ -42,9 +41,8 @@ export function createCallbackCredentialResolver(signing, issuer, subject, audie
         if (pending === undefined) {
             const current = sign(signing, issuer, subject, audience, expression, execution, maximum, executionId).then((signed) => {
                 const delegateTtlSeconds = Math.min(maximumCallbackDelegationTtlSeconds, signed.expiresAt - signed.issuedAt - CALLBACK_DELEGATION_SKEW_SECONDS);
-                if (delegateTtlSeconds < 1) {
-                    throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-                }
+                if (delegateTtlSeconds < 1)
+                    throw exhausted(execution, maximum);
                 return (cached = Object.freeze({
                     credential: signed.credential,
                     expiresAt: signed.expiresAt,
@@ -69,9 +67,8 @@ async function sign(signing, issuer, subject, audience, expression, execution, m
     requireLive(execution);
     const now = Math.floor(Date.now() / 1_000);
     const expiresAt = Math.min(maximum, Math.floor(execution.deadline / 1_000), now + maximumCallbackTtlSeconds);
-    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
-        throw protocolError('AUTH_INVALID', 'Credential is invalid.');
-    }
+    if (!Number.isFinite(expiresAt) || expiresAt <= now)
+        throw exhausted(execution, maximum);
     const credential = await withSignal(new SignJWT({
         grant: { v: 1, expr: expression },
         ...(executionId === undefined ? {} : { [EXECUTION_CLAIM]: executionId }),
@@ -89,6 +86,12 @@ async function sign(signing, issuer, subject, audience, expression, execution, m
     requireLive(execution);
     return Object.freeze({ credential, issuedAt: now, expiresAt });
 }
+/** The authority a callback derives from ends before the callback could serve a call. */
+function exhausted(execution, maximum) {
+    return protocolError('DEADLINE_EXCEEDED', maximum * 1_000 < execution.deadline
+        ? 'Caller authority has expired.'
+        : 'Invocation deadline was exceeded.');
+}
 function withSignal(operation, signal) {
     if (signal.aborted)
         return Promise.reject(signal.reason);

package/dist/execution/index.d.ts

@@ -1,5 +1,6 @@
 export { serve } from './serve.js';
 export type { ExecutionContext, ServedDomain, ServeInput } from './serve.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, type DeploymentCache, type MemoryCacheOptions, } from './cache/index.js';
 export { createIdentity, maximumExchangeTtl, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
 export type { DurableEngine, DurableServing, DurableServingProvider } from './workflows/index.js';
 export { isCanonicalDurableRequest } from './workflows/route.js';

package/dist/execution/index.js

@@ -1,3 +1,4 @@
 export { serve } from './serve.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, } from './cache/index.js';
 export { createIdentity, maximumExchangeTtl, } from './identity/index.js';
 export { isCanonicalDurableRequest } from './workflows/route.js';

package/dist/execution/invocation/admission/age.d.ts

@@ -0,0 +1,57 @@
+import type * as invocation from '@astrale-os/kernel-protocol/invocation';
+import type { RuntimeRegistry } from '../../../application/runtime/index.js';
+import type { DeploymentCache } from '../../cache/index.js';
+import type { Admission, InvocationTarget } from './target.js';
+/**
+ * How long reading a kept admission may take before the call asks its Kernel instead. Reads of a
+ * shared platform cache answer in single-digit milliseconds; `Function.admit` costs tens.
+ */
+export declare const ADMISSION_RECALL_TIMEOUT_MS = 30;
+/** The callables a call can be admitted to, when one of them declares an admission age. */
+export interface AdmissionScope {
+    /** Keys of the implementations the call target names: an admission to any other is not kept. */
+    readonly callables: ReadonlySet<string>;
+    /** The input fields their Policies read, the only part of the input an admission depends on. */
+    readonly fields: readonly string[];
+}
+/**
+ * Whose admission one call asks for: the source Kernel, the release this deployment serves, and
+ * the caller its credential proved, verified here before any kept admission is read.
+ */
+export interface AdmissionPartition {
+    readonly kernel: string;
+    readonly release: string;
+    /** Absent for a call that carries no credential. */
+    readonly caller?: {
+        readonly principal: string;
+        readonly identity: string;
+    };
+}
+/**
+ * The scope of a call whose target names, before the graph is read, implementations of which one
+ * declares an admission age. Undefined otherwise: a target that names no local implementation (a
+ * callable Node id, a path ending in a traversal), only callables without an age, or a durable
+ * Workflow, which runs only as a Kernel Execution. The Path language dispatches exactly, so a named
+ * target selects one declaration; the fields are still the union over every implementation named.
+ */
+export declare function admissionScope(registry: RuntimeRegistry, call: invocation.Call): AdmissionScope | undefined;
+/** Whether any implementation of this registry declares an admission age. */
+export declare function declaresAdmissionAge(registry: RuntimeRegistry): boolean;
+/**
+ * The cache key of one call's admission: a SHA-256 over the source Kernel, the served release, the
+ * verified principal and caller, the canonical call target (receiver included) and the input
+ * projected on the fields its Policy reads. A missing field differs from `null`, object keys are
+ * sorted at every depth, and no other part of the input enters the key.
+ */
+export declare function admissionKey(scope: AdmissionScope, partition: AdmissionPartition, call: invocation.Call): Promise<string>;
+/**
+ * The target of an admission this deployment kept under `key`, while it is younger than the age it
+ * carried. A missing, expired, malformed, out-of-scope, failed or late read is a miss.
+ */
+export declare function recallAdmission(cache: DeploymentCache, key: string, scope: AdmissionScope): Promise<InvocationTarget | undefined>;
+/**
+ * Keep a successful admission that carries an age, until `sentAt` plus that age, `sentAt` being when
+ * `Function.admit` was asked. Written in the background: the call never waits on the cache, and a
+ * cache that fails to keep it only costs a later call its admission round trip.
+ */
+export declare function keepAdmission(cache: DeploymentCache, key: string, scope: AdmissionScope, admitted: Admission, sentAt: number, background: (task: () => PromiseLike<unknown>) => void): void;