Version 1.0.0-alpha.1senaste
Kapitel 2.22
Körtidsmiljön för insticksprogram
SDK-modulerna (programutvecklingspaket) som ert insticksprogram körs på, från räckviddsvakten och databasstaketet till UNO-utskick, läsning av rutten för AI (artificiell intelligens) och licenskontroller. Därefter testning mot en riktig databas, registrering av era färdigheter och introduktion.
Denna sida har översatts av AI från det engelska originalet. Om något är oklart är den engelska sidan referensen. Läs denna sida på engelska

Körtidsdelen av SDK:t (software development kit) är en uppsättning moduler under @adverant-nexus/plugin-sdk/runtime/*, plus testhjälpare under testing/*. Ni importerar dem; ni återimplementerar dem inte. Det är hela tanken, och det krävdes en avvisad granskning för att jag skulle ta det på allvar: granskarens kommentar om min första plugins handskrivna räckviddskontroll var en enda rad: "SDK:t har redan detta, och er godtar en utmaningstoken för MFA (flerfaktorsautentisering) som en session".
Det här kapitlet följer ett anrop genom en körande plugin, på det sätt som fullservicemallen kopplar ihop det: räckviddsvakten, databasstaketet, den enda tillåtna gränsövergången, utskick via UNO, avläsningen av rutten för AI (artificiell intelligens) och licenskontrollerna. Därefter behandlas testning, registrering av era manifestfärdigheter och introduktionsstegen.
Räckvidd: en vakt per ramverk
Varje /api-rutt bär räckviddsvakten. Den verifierar innehavartoken, härleder de tre axlarna (klientorganisation, ägare, enhet) ur den, avvisar en anropskropp som namnger en klientorganisation, tillämpar ruttens rättighet från manifestets register och låter först därefter hanteraren köra. SDK:t levererar en adapter per ramverk, samtliga från @adverant-nexus/plugin-sdk/runtime/scope och samtliga med samma alternativ.
| Ramverk | Adapter |
|---|---|
| Express | scopeMiddleware |
| Fastify | requireScope, som en preHandler |
| Next | withScope, som omsluter hanteraren; en Next-hanterare får inte veta sin rutt, så withScope tar den som ett tredje argument |
Här är mallens Express-koppling, nedbantad. Verifieraren tillhör SDK:t och håller token till identitetstjänstens sessionsformat: endast HS256; iss, exp, iat och jti krävs; en livstid på högst en timme; och ingen MFA-utmanings-, imiterings- eller OAuth-resurstoken (den öppna standarden för delegerad auktorisering) släpps in som en session.
import { platformAccessTokenVerifier } from "@adverant-nexus/plugin-sdk/runtime/platform-token";
import { scopeMiddleware } from "@adverant-nexus/plugin-sdk/runtime/scope";
const requireScope = scopeMiddleware({
verify: platformAccessTokenVerifier(config.PLATFORM_JWT_SECRET),
rights: { manifest },
});
router.get("/api/projects", requireScope, async (req, res) => {
res.json({ projects: await db.listProjects(scopeOf(req)) });
});Rättighetsvakten tillämpar en rutts rättighet i fyra steg. En roll i rättighetens never-lista avvisar med AUTHORITY_EXCEEDED och orden i barred, och ingen plats häver det. En roll i roles släpper in, tillsammans med en aktiv plats när rättigheten anger seat: true. I annat fall släpper en aktiv plats som bär rättigheten in. I annat fall avvisas anropet med AUTHORITY_EXCEEDED, med angivande av de personer som skulle kunna bevilja en plats. Ge vakten ett lager (rights: { manifest, store: { pool, schema } }) så läser den platser under anroparens egen räckvidd; en rättighet som namnger en licence behöver även en licensläsare, vilket behandlas nedan.
Inuti en hanterare är scopeOf(req) det enda sättet att läsa den härledda räckvidden, och den kastar ett undantag om vakten inte kördes. En vakt som registrerats på ett prefix och som körs innan någon rutt har matchats svarar 500 MIDDLEWARE_ORDERING_ERROR; en rutt som er kod registrerar men som manifestet inte deklarerar svarar 500 UNHANDLED_ERROR. Båda är felsäkra genom att neka.
Mallens /internal-rutter, som plattformen anropar, använder den andra ordningen. Tjänstevakten kontrollerar X-Service-Key i konstant tid och hämtar klientorganisationen från plattformens X-Organization-ID, samt avvisar MISSING_SERVICE_KEY, INVALID_SERVICE_KEY eller MISSING_ORG_ID_HEADER. För plattformens signerade token per anrop har SDK:t requireService (Fastify) och serviceMiddleware (Express), som även kontrollerar vilken färdighet och rutt som token utfärdades för och avvisar en token som används två gånger.
Databasstaketet: tenantFence och withScopedTx
Varje sats mot en räckviddsstyrd tabell bygger upp staketet och körs inuti en räckviddsstyrd transaktion:
import { withScopedTx } from "@adverant-nexus/plugin-sdk/runtime/db";
import { tenantFence } from "@adverant-nexus/plugin-sdk/runtime/fence";
async function listProjects(scope: ResolvedScope) {
// Projects are owner-private inside the organisation, so the owner axis is passed explicitly.
const f = tenantFence(scope, { alias: "p", owner: scope.owner });
const r = await withScopedTx(pool, scope, { schema: SCHEMA }, (db) =>
db.query(`SELECT p.* FROM anomaly_review.reviews p WHERE ${f.where} ORDER BY p.created_at DESC`, f.params),
);
return r.rows;
}tenantFence(scope, options) bygger predikatet och dess parametrar från en härledd räckvidd. Skicka med owner för personliga tabeller; utelämna det för organisationsartefakter där ägare anger ursprung. När satsen redan har parametrar talar startIndex om för staketet varifrån numreringen ska börja. En infogning tar aldrig axlarna som indata: den skriver scope.tenant, scope.owner och scope.unit från räckvidden.
withScopedTx binder alla tre axlarna för en transaktion genom schemats enda bindningsfunktion och kör därefter er callback. En andra bindning i samma transaktion utlöser SCOPE_ALREADY_BOUND (500: er kod band två gånger; anroparen gjorde inget fel). En frånvarande eller nollställd klientorganisation eller ägare utlöser SCOPE_PREDICATE_INVALID (403). Inställningen är transaktionslokal, så en poolad anslutning kan inte föra med sig en klientorganisation in i nästa anrop.
Två syskonfunktioner täcker de fall som inte är en persons anrop. withTenantScopedTx binder klientorganisation och enhet utan ägare, för rader som en maskin läser (enhetsregistret), och avvisar en räckvidd som bär en ägare. maintenanceScope(reason) tvingar en organisationsövergripande åtgärd att uttryckligen ange vad den är innan ägarens transaktion öppnas. Kodstaketet och tvingande säkerhet på radnivå är två mekanismer för samma lag; startkontrollen vägrar lyssna tills databasen bevisar att den andra håller (DB_ROLE_BYPASSES_ISOLATION i annat fall).
Varje avvisning är en rad
Mallen installerar ytterligare en mellanprogramvara, en gång, mellan body-tolken och routrarna: avvisningsliggaren.
import { recordRefusals } from "@adverant-nexus/plugin-sdk/runtime/refusal-ledger";
app.use(express.json({ limit: "256kb" }));
app.use(recordRefusals({ pool, schema: SCHEMA }));Den omsluter svaret så att varje avvisning en person läser, oavsett om den kommer från rättighetsvakten, en hanterare eller ett lager, skrivs till ert schemas refusal-tabell inuti den personens egen räckviddsstyrda transaktion innan anropskroppen skickas. En anonym 401 skriver ingenting. Om raden inte kan skrivas blir svaret UNHANDLED_ERROR: ett "nej" som produkten inte kan bokföra skickas inte som om det hade bokförts. Starten kör assertRefusalLedger för att kontrollera att tabellen kan ta emot liggarens rad, och ett lager kan anropa noteSubject({ recordId, isDemo }) så att varje avvisning namnger den post den gällde. När en kund frågar varför någon blev avvisad i tisdags är svaret en databasfråga, inte en gissning.
Den enda korsningen: ett registrerat skrivskyddat tillstånd
När en av era kunder utför arbete åt en annan och den andra får granska det, finns det en enda sanktionerad väg över gränsen. Organisationen som innehar raderna registrerar ett medgivande. Läsarens organisation släpper in en person genom en plats som bär rättigheten granted.read, vilken måste namnge owner och admin i never. Läsningen körs som en sjätte databasroll, läsplatsen, som endast kan välja de tabeller som databases[].granted räknar upp:
const r = await withSeatTx({ app: appPool, seat: seatPool }, seatsOf(req), { holder, grantId }, { schema: "anomaly_review" }, (db) => {
const f = grantFence(db.seat, { alias: "r" });
return db.query(`SELECT r.review_id FROM anomaly_review.reviews r WHERE ${f.where}`, f.params);
});
if (!r.ok) return res.status(r.status).json(r.refusal);withSeatTx skriver titten i läsarens egen klientorganisation först och binder därefter läsplatsen till medgivandet, vilket skriver titten i innehavarens klientorganisation. Databasens egen policy kontrollerar att medgivandet namnger läsarens organisation, täcker tabellen, har börjat, inte har upphört och inte har återkallats, samt att denna transaktion skrev sin titt. En läsning som hoppar över titten ser ingenting. Vid start kontrollerar assertSeatAtBoot(seatPool, schema) att poolen som öppnats från seat.url verkligen är platsen och ingenting mer, och avvisar med DB_SEAT_ROLE_INVALID i annat fall.
Utskick genom UNO
All beräkning går genom en enda klient, byggd i en enda fil, med en sluten tillåtelselista:
import { UnoClient } from "@adverant-nexus/plugin-sdk/runtime/uno";
/** The namespaced job types this surface may dispatch. Closed; edit in code. */
export const DISPATCHABLE = Object.freeze([`${manifest.name}.sentiment_score`] as const);
export function createUno(deps: UnoDeps): UnoClient {
return new UnoClient({
baseUrl: deps.dispatchUrl,
serviceKey: deps.serviceKey,
callerService: manifest.name,
dispatchable: DISPATCHABLE,
});
}Tillåtelselistan är medvetet en konstant på modulnivå. Om en operatör kunde utöka den via konfigurationen skulle rutten bli en utskicksproxy för hela registret. Mallens eget test verifierar att listan namnger exakt de jobbtyper som manifestet kompileras till.
Kuvertet
Ett utskick bär sex fält i sin obligatoriska kärna. Klienten fyller i klientorganisation och aktör från den verifierade räckvidden, aldrig från anropet:
| Fält | Vad den innehåller |
|---|---|
jobType |
Den namnrymdsindelade jobbtypen, <plugin name>.<skill id> |
organizationId |
Klientorganisationen, från räckvidden |
userId |
Aktören, från räckvidden, för revision och fakturering |
inputParams |
Färdighetens indata. Den bär aldrig ett klientorganisations-id; en som gör det avvisas vid utskick |
priority |
critical, high, normal eller low |
pluginId |
Ert manifest name. Varje utskick deklarerar sin ursprungliga plugin |
Valfria fält inkluderar correlationId (ett UUID (universellt unik identifierare), annars skapas ett nytt) och callbackUrl, som en plugin_queue-färdighet behöver så att arbetaren vet var den ska skicka sitt resultat.
const accepted = await uno.dispatch(scope, {
jobType: DISPATCHABLE[0],
inputParams: { text: text.body },
priority: "normal",
pluginId: manifest.name,
correlationId: crypto.randomUUID(),
});
if (!accepted.ok) return res.status(statusFor(accepted.refusal.code)).json(accepted.refusal);
res.status(202).json(accepted.value);202, därefter avfrågning
Varje utskick läggs i kö. Svaret är alltid 202 med identifierare (jobId, runId, traceId, status), aldrig ett resultat. Resultatet kommer från avfrågning av jobbet eller från er callback. uno.peek(jobId, { scope }) läser det en gång och awaitJob frågar av tills en slutstatus nås; båda skickar klientorganisationen från den verifierade räckvidden, och båda kontrollerar den returnerade radens organization_id mot anroparens klientorganisation på er sida av nätverksanropet, och avvisar en avvikelse med SCOPE_REFUSED.
Läs körraden med dess egen stavning. Utskickssvaret anger jobId; raden anger job_id, organization_id och plugin_id. Resultat- och felkolumnerna är result, error, error_code och error_troubleshooting. completed och failed är slutgiltiga. timed_out, cancelled och system_failure kommer från rensaren och ett sent resultat kan fortfarande korrigera dem. En klient som behandlar någon av dessa som otolkbara avvisar rader som plattformen skriver varje dag.
Godkännandespärren
En manifestfärdighet som deklarerar approval spärras vid utskick. 202 anger då status: "awaiting_approval" och bär ett waitpointId, med den anledning som manifestet angav. Körningen förblir spärrad tills en namngiven person fattar beslut om den. uno.approve och uno.resolveWaitpoint skickar klientorganisationen och anroparen som aktör, och ett beslut av någon annan än den verifierade anroparen avvisas. Ett godkännande släpper jobbet en gång och kör utskickskontrollerna igen; ett avslag avslutar det med failed. Ett andra beslut avvisas, och likaså ett beslut efter att spärren har löpt ut. Om er produkt kräver att godkännaren är en annan person än förslagsställaren, genomdriv det i den rutt som fattar beslutet: plattformen registrerar båda.
Rendera ett spärrat jobb som spärrat. Säg inte till en person att deras klick släppte det förrän körraden anger det.
AI: önskemål på färdighetsraden och en läsning
Er plugin anropar aldrig en modell. När en manifestfärdighet behöver en (llm_only eller tool_using, på tillitsnivå core eller verified), uttrycker ni preferenser på dess registerrad, och routern beslutar utifrån organisationens egen pool:
{
"execution_config_skill": {
"preferredProvider": "gemini",
"capabilityProfile": { "needsToolUse": true, "dataResidency": "eu_only" }
}
}preferredProvider och preferredModel är önskemål som routern endast tillgodoser när organisationen har den leverantören aktiverad och försedd med autentiseringsuppgifter. capabilityProfile filtrerar och väljer aldrig; dess dataResidency (eu_only, us_only eller any) är ett hårt villkor som routern antingen uppfyller eller avvisar. Att utelämna samtliga är oftast rätt. modelOverride finns för den sällsynta färdighet som behöver en exakt modell, och den gör önskemålen bredvid den verkningslösa; jag skulle undvika den såvida inte färdigheten är meningslös på alla andra modeller.
När ert gränssnitt behöver visa vilken modell routern skulle använda, läs av den, förutsäg den inte:
import { createAIRouteClient } from "@adverant-nexus/plugin-sdk/runtime/ai-route";createAIRouteClient(...).effectiveRoute() är den enda sanktionerade avläsningen av AI Provider Router. Den tar gatewayens adress, anroparens egen innehavartoken och er plattforms slug, och skickar inget AI-anrop. Den svarar med leverantören och modellen, de leverantörer som policyn tillåter samt huruvida den valda slutpunkten kör local eller external. När rutten inte är användbar svarar den med routerns avvisning i ord (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE eller NO_MODEL_FOR_ROLE_AND_PROVIDER, med åtgärdsförslaget), aldrig en standardmodell. Visa den avvisningen för personen; det är den egna organisationens konfiguration som talar.
Licenskontroller
Tre mekanismer kontrollerar licensiering, på tre detaljnivåer.
En rättighet som namnger en licens. Den enklaste. I manifestet bär en rättighet licence: "<feature>", och vakten frågar identitetstjänsten huruvida organisationens licens bär den, med anroparens egen token, innan någon roll läses. Bygg vakten med en läsare:
import { createLicenceReader } from "@adverant-nexus/plugin-sdk/runtime/licence";
const requireScope = scopeMiddleware({
verify,
rights: { manifest, store: { pool, schema: SCHEMA }, licence: createLicenceReader({ baseUrl: config.NEXUS_AUTH_URL }) },
});En licens som inte bär funktionen avvisar alla med LICENCE_LOCKED, namnger vad som bär den och anger att organisationens ägare och administratörer kan slå på den. En licens som inte kan läsas avvisar med UNHANDLED_ERROR: en låst funktion levereras aldrig för att licensen var onåbar. Svar sparas i minnet i 30 sekunder per organisation och funktion.
Produktspärren. createProductGate({ baseUrl, product }) från runtime/product-gate frågar behörighetskontrollen huruvida anroparens organisation överhuvudtaget innehar er produkt, och dess middleware() körs efter räckviddsvakten. Ett negativt utslag är ENTITLEMENT_DENIED; en kontroll som inte kan nås är ENTITLEMENT_UNREACHABLE, och spärren behandlar aldrig det ena som det andra.
Själva licensdokumentet. Kod som måste besluta på egen hand utifrån den signerade licensen, såsom den slutna modulen i ett domänpaket, använder verifyLicenceDocument(docText, opts) från runtime/licence-document. Det är en ren funktion: inget nätverksanrop, ingen miljövariabel, ingen fil. Den kontrollerar båda signaturerna mot de tillitsrötter som bygget bär och svarar med ett tillstånd (VALID, WARN, GRACE, RESTRICT, TERMINATE eller ABSENT) tillsammans med medgivandena, tilläggen och domänpaketen. licenceAllows(verdict, featureGroup, action, tenantId?) anger därefter huruvida ni får utföra use eller provision under en grupp. RESTRICT tillåter use och besvarar provision med LICENCE_LOCKED, så att pågående arbete fortsätter och inget nytt startar.
Testning
Mallens tester visar mönstret; detta är verktygen bakom det.
Räckviddsattrapper. Bygg testdubbeln för den härledda räckvidden en gång, i test/scope-fakes.ts, och injicera den överallt, inklusive i de frånvarande fallen: ingen enhet, ingen token, en token med en nollställd organisation. Avvisningsvägarna är produkten.
En attrapp för utskickstransport. UnoClient tar fetch, now och sleep, så att ett enhetstest aldrig rör nätverket. Verifiera kuvertets fält, 202-formen, avfrågningen till en slutgiltig rad med dess organization_id samt att en rad för en annan klientorganisation förkastas.
En riktig Postgres. En falsk frågefunktion bevisar en SQL-sträng. Den kan inte bevisa att tvingande säkerhet på radnivå håller eller att filerna tillämpas i ordning som migreraren. testing/ephemeral-postgres startar en tillfällig server och kör samma nexus-migrate som produktionen kör:
import { EPHEMERAL_REMEDY, migrated, startEphemeralPostgres } from "@adverant-nexus/plugin-sdk/testing/ephemeral-postgres";
const pg = await startEphemeralPostgres(); // null off CI: skip each case by name with EPHEMERAL_REMEDY
const db = migrated(pg!, "plugin_test", { root }); // provision as the superuser, then every file as the migrator
// connect as db.appUrl and run the boot checks the server runsUtanför CI (kontinuerlig integration) hoppar en maskin utan Postgres-server över varje databasfall vid namn med åtgärdsförslaget, aldrig grönt. I CI gör samma frånvaro att sviten underkänns (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), eftersom ett överhoppat test av säkerhet på radnivå är en grön spärr som inte mätte någonting. Servern väntar i upp till 180 sekunder på att starta, och en övervakningsprocess stoppar den när testprocessen försvinner.
Isoleringsriggen. runIsolationHarness(target) från testing/isolation-harness läser varje rutt som er app monterar och angriper var och en som en annan organisations administratör och som en kollega. Därefter angriper den igen med kodstaketet borttaget, databasstaketet borttaget och båda borttagna. En rutt är PROVEN endast när angreppet misslyckas med endera staketet på plats och når offrets data när båda är borttagna, så att ni vet att testet överhuvudtaget kan se en läcka. Den skickar varje rutts deklarerade fråga och exempelkropp, så att en rutt som avvisar ett tomt anrop ändå nås. Lås ledgerOf(report) i ett test och underkänn vid defectsOf(report).
Registrering: från manifest till färdighetsregister
Era manifestfärdigheter når färdighetsregistret via en enda väg:
manifest.skills[] → compileRegistry(manifest) → POST /api/v1/plugins/sync
compileRegistry omvandlar ett validerat manifest till nexus.plugin-sync/v1-kroppen. Mallen gör det vid import, så att ett ogiltigt manifest gör att bygget underkänns:
import { compileRegistry, definePlugin } from "@adverant-nexus/plugin-sdk";
export const manifest = definePlugin(raw);
export const registryPayload = compileRegistry(manifest);{
"contract": "nexus.plugin-sync/v1",
"pluginId": "anomaly-review",
"version": "0.3.0",
"skills": [ { "job_type": "anomaly-review.excursion_summary", "tier": "host_callback", "classification": "tenant" } ]
}Synkroniseringen är deklarativ: skicka hela färdighetsuppsättningen varje gång, så inaktiveras en utelämnad färdighet med sin historik bevarad. Den är strikt: ett okänt fält, ett fält från en annan nivå eller ett null avvisas, alla överträdelser returneras tillsammans i ett 400 SYNC_CONTRACT_VIOLATION, och ingenting skrivs så länge det finns någon. Och den skriver en registerrad per färdighet, nycklad på den namnrymdsindelade jobbtypen, med varje kolumn som utskickaren läser, så att färdigheten är körbar i samma ögonblick som synkroniseringen svarar 200.
Pluginen är den autentiserade anroparen, aldrig ett fält i anropskroppen. Anropa synkroniseringen från er plugins egen arbetslast över mTLS (ömsesidig TLS: Transport Layer Security med ett certifikat i båda ändar). Skills Engine läser er arbetslasts klientcertifikat, vars SPIFFE-identitet (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) namnger namnrymden och tjänstekontot, och slår upp den plugin och ägarorganisation som registrerats för den namnrymden. Kroppens pluginId måste stämma överens; det är en kontroll, inte en väljare. Varje rad skrivs med den pluginen och organisationen.
| Status | Kod | Betydelse |
|---|---|---|
| 200 | {contract, pluginId, version, created, updated, unchanged, disabled, skills} |
|
| 400 | SYNC_CONTRACT_VIOLATION |
Varje överträdelse listad i violations[]; ingenting skrivet |
| 401 | UNAUTHORIZED |
Felaktig eller saknad tjänstenyckel |
| 401 | CALLER_IDENTITY_UNVERIFIED |
Ingen läsbar klientidentitet |
| 403 | DELIVERY_IDENTITY_MISSING |
Den anropande namnrymden tillhör ingen plugin |
| 403 | PLUGIN_ID_MISMATCH |
Anropskroppen namnger en annan plugin |
| 409 | REGISTRY_CONFLICT |
En jobbtyp ägs på annat håll eller registrerades utanför synkroniseringen; ingenting skrivet |
Låt ert driftsättningssteg misslyckas vid varje annan status än 200. Ingen annan status innebär att era färdigheter är registrerade.
Introduktion
Introduktionen körs som tio ordnade steg, där vart och ett kan köras om, avbrytas eller rullas tillbaka på egen hand:
- Klona kodförrådet och validera det.
- Tolka manifestet.
- Skanna det efter säkerhetsproblem.
- Bygg avbildningen.
- Skicka upp den till installationens register.
- Konfigurera dess domännamn.
- Driftsätt den via installationens lanseringskanaler.
- Vänta på hälsokontrollen.
- Registrera pluginen.
- Meddela utvecklaren.
Före driftsättning körs fem efterlevnadskontroller mot manifestet och den byggda avbildningen: manifestet kan tolkas och bär sina obligatoriska fält; varje deklarerad rutt är en verklig registrerad rutt; pluginen äger sitt schema och skriver ingenting utanför det; resursanspråk är deklarerade och inom gränserna; och avbildningen har en fungerande hälsohanterare. En plugin som registrerar sig själv vid start kör samma kontrakt under sin egen auktoritet, så att kontrollerna blir dess CI i stället för pipelinens. Att hoppa över en förkortar inte introduktionen; det flyttar felet till körtiden.
Varumärkesprofileringen i ert manifest levereras utan autentisering per domän, eftersom inloggningssidan behöver den innan någon har autentiseringsuppgifter. Behandla allt i branding som offentligt.
GATE_CANNOT_BE_SKIPPED.Vad körtidsmiljön inte gör åt er
Körtidsmiljön håller gränsen för isolering, utskick och modellåtkomst. Den gör inte er produktlogik korrekt, och den gör inte en långsam fråga snabb: varje sats körs inuti en bunden transaktion med de tidsgränser som ert manifests db-block deklarerar, och en sats som överskrider statementTimeoutMs avbryts i stället för att inväntas. Dimensionera era frågor för det. Och godkännandespärren, läsplatsen och licensläsaren lägger alla till en tur-och-retur-resa eller en transaktion. I min plugin för avvikelsegranskning lade licenskontrollen till några millisekunder per anrop tills dess 30-sekundersminne värmts upp, vilket var ett rimligt pris för att aldrig leverera en låst funktion.

