@onetype/stack-api-kit 1.0.0

package/dist/api-BZrn0c9T.d.ts

@@ -0,0 +1,654 @@
+import { z } from 'zod';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+
+/** Anything declared carries a sentence saying what it is for. */
+type Described = {
+    describe: string;
+};
+/** A declaration whose payload is checked before it reaches anyone. */
+type Schematic = Described & {
+    schema: z.ZodType;
+};
+/** What a plugin may do, named so a project can grant it. */
+type Permission = Described;
+/** An event a plugin publishes. Delivered after the work it announces. */
+type Event = Schematic;
+/**
+ * What a listener does when an event arrives.
+ *
+ * `payload` is `unknown`, never `never`: a handler typed `(payload: never)`
+ * accepts any annotation its author writes, because of contravariance, so the
+ * compiler endorses a claim about a completely different schema.
+ */
+type Listener<Context, Payload = unknown> = Described & {
+    handle: (payload: Payload, ctx: Context) => void | Promise<void>;
+};
+/** A point where a plugin may refuse what is about to happen. */
+type Hook = Schematic;
+/** What a participant answers: nothing to allow, a reason to refuse. */
+type Participant<Context, Payload = unknown> = Described & {
+    handle: (payload: Payload, ctx: Context) => string | undefined | Promise<string | undefined>;
+};
+/** Something a plugin can be asked to do, behind the permissions it names. */
+type Command<Context, Input extends z.ZodType = z.ZodType> = Schematic & {
+    schema: Input;
+    requires?: readonly string[];
+    run: (input: z.infer<Input>, ctx: Context) => void | Promise<void>;
+};
+/** The verbs a route may answer. */
+type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/**
+ * One endpoint.
+ *
+ * `input` and `output` are both required, and neither is optional sugar.
+ * `input` is the only thing a handler ever reads: what arrived unparsed does
+ * not reach it. `output` is a whitelist of what may leave, so a column added
+ * to a table tomorrow does not appear in a response by itself.
+ */
+type Route<Context, Input extends z.ZodType = z.ZodType> = Described & {
+    method: Method;
+    path: string;
+    input: Input;
+    output: z.ZodType;
+    requires?: readonly string[];
+    /**
+     * Whether an unauthenticated caller may reach this.
+     *
+     * Absent means no. A route is closed until it says otherwise, so
+     * forgetting to think about it fails shut.
+     */
+    public?: boolean;
+    /** Requests per window for one caller, when this route needs its own. */
+    limit?: {
+        requests: number;
+        seconds: number;
+    };
+    /**
+     * Request headers this route reads, lowercase.
+     *
+     * Named rather than handed the lot: a handler that can read any header
+     * can read the cookie carrying the session, and a log of its input then
+     * carries a credential. What is not named does not arrive.
+     */
+    reads?: readonly string[];
+    /**
+     * What answers the request.
+     *
+     * `input` is what the route's own schema parsed, so a handler reads its
+     * fields without a cast: nothing that failed the schema reaches here.
+     * Return a value for a 200, or an `Answered` to say the status and
+     * headers as well.
+     */
+    handle: (input: z.infer<Input>, ctx: Context) => unknown | Promise<unknown>;
+};
+/**
+ * A listener, participant or command, whatever payload it was written for.
+ *
+ * Each is written against the schema it answers and stored beside others
+ * written against different ones, so a list holds "some listener" rather than
+ * one shape. Sound because the kernel parses before it calls.
+ */
+type Heard<Context> = Described & {
+    handle: (payload: never, ctx: Context) => void | Promise<void>;
+};
+type Joined<Context> = Described & {
+    handle: (payload: never, ctx: Context) => string | undefined | Promise<string | undefined>;
+};
+type Run<Context> = Schematic & {
+    requires?: readonly string[];
+    run: (input: never, ctx: Context) => void | Promise<void>;
+};
+/**
+ * One route, whatever its input schema.
+ *
+ * A route is written against its own schema and stored beside routes written
+ * against others, so what a list holds is "some route", not one shape. This
+ * says that without reaching for `any`.
+ */
+type Endpoint<Context> = Omit<Route<Context, z.ZodType>, "input" | "handle"> & {
+    input: z.ZodType;
+    handle: (input: never, ctx: Context) => unknown | Promise<unknown>;
+};
+/** Where a plugin's lines go. The project decides. */
+type Logger = {
+    debug: (line: string, about?: Readonly<Record<string, unknown>>) => void;
+    info: (line: string, about?: Readonly<Record<string, unknown>>) => void;
+    warn: (line: string, about?: Readonly<Record<string, unknown>>) => void;
+    error: (line: string, about?: Readonly<Record<string, unknown>>) => void;
+};
+/** Who is calling, as whatever the project decided that means. */
+type Caller = {
+    /** Stable identity, or undefined when nobody is signed in. */
+    id: string | undefined;
+    /** What this caller may do. The project fills it; the kernel enforces it. */
+    permissions: readonly string[];
+    /** What the project attached: a tenant, a role, a session. Opaque here. */
+    claims: Readonly<Record<string, unknown>>;
+};
+/** One outbound call, to a host the plugin declared. */
+type Outbound = {
+    method: Method;
+    url: string;
+    body?: unknown;
+    headers?: Readonly<Record<string, string>> | undefined;
+    signal?: AbortSignal | undefined;
+};
+/** What every plugin function receives. */
+type Context<Config = unknown, Services = unknown, Db = unknown> = {
+    name: string;
+    config: Config;
+    services: Services;
+    log: Logger;
+    /**
+     * What time it is, in milliseconds.
+     *
+     * Reached through the context rather than `Date.now()` so a test can pin
+     * it: what happens tomorrow is otherwise only testable by moving the
+     * machine's clock, which every other test in the process then shares.
+     */
+    now: () => number;
+    /** Who is calling. Absent outside a request, as in setup. */
+    caller: Caller | undefined;
+    /**
+     * The request headers this route declared in `reads`, lowercase.
+     *
+     * Empty outside a request, and empty for anything the route did not
+     * name.
+     */
+    headers: Readonly<Record<string, string>>;
+    /**
+     * This plugin's own tables.
+     *
+     * The handle carries only what this plugin declared, so a query naming
+     * another plugin's table does not compile. The connection underneath is
+     * shared, so the boundary is the compiler's rather than the database's.
+     */
+    db: Db;
+    /**
+     * Runs one query outside a transaction, in its turn.
+     *
+     * A query issued while another request's transaction is parked on an
+     * await joins that transaction and dies with its rollback, having told
+     * its caller it succeeded. Reads are safe without this; a write is not.
+     */
+    write: <Made>(run: () => Promise<Made>) => Promise<Made>;
+    /**
+     * Runs work in one transaction, rolled back if it throws.
+     *
+     * The callback is handed a context of its own, not just a handle: what it
+     * emits waits for the commit, and a `tx` inside it joins this one
+     * rather than opening a second. A caller that used the outer `ctx` would
+     * be writing outside the transaction it just opened.
+     */
+    tx: <Made>(run: (ctx: Context<Config, Services, Db>) => Promise<Made>) => Promise<Made>;
+    /** Calls a host this plugin declared in `outbound`. */
+    fetch: (call: Outbound) => Promise<unknown>;
+    events: {
+        /**
+         * Announces what happened. Inside a transaction it waits and is sent
+         * after the commit: an event about work that rolled back is a lie.
+         */
+        emit: (event: string, payload: unknown) => void;
+    };
+    hooks: {
+        /** Runs a hook and answers the first refusal, or undefined. */
+        run: (hook: string, payload: unknown) => Promise<string | undefined>;
+    };
+    permissions: {
+        has: (permission: string) => boolean;
+        all: (permissions: readonly string[]) => boolean;
+        /** What the project attached to this caller, unread by the kernel. */
+        claims: () => Readonly<Record<string, unknown>>;
+    };
+    commands: {
+        run: (command: string, input: unknown) => Promise<void>;
+        /**
+         * Runs one later, in seconds from now.
+         *
+         * Only a command this plugin declares, and it runs with no caller:
+         * whatever it needs to know about whose work it is travels in the
+         * input, exactly as an event's payload does.
+         *
+         * Asked for inside a transaction, it is written by that transaction
+         * and rolls back with it. A command that throws is tried again.
+         */
+        later: (command: string, input: unknown, inSeconds: number) => void;
+    };
+    /**
+     * Takes ownership of something that outlives a request.
+     *
+     * Services are built per request, because one holding a caller would
+     * answer the next request as the previous one. A connection is the
+     * opposite: opened once in `setup`, used by every request, closed in
+     * `teardown`. This is where it lives, one per plugin, and no plugin
+     * reaches another's.
+     */
+    owns: <Owned>(owned: Owned) => Owned;
+    /** What this plugin took ownership of, or undefined before `setup` did. */
+    owned: <Owned>() => Owned | undefined;
+    /**
+     * What narrows every read of a table this plugin declared a `scope` for.
+     *
+     * Answers the caller's value for the declared claim, refusing when there
+     * is none. Nothing makes a query call this: one that forgets reads every
+     * scope's rows and compiles, which is why every scoped read is tested
+     * with a stranger's id.
+     *
+     * ```ts
+     * .where(and(eq(items.id, id), ctx.scoped("items")))
+     * ```
+     */
+    scoped: <Condition = unknown>(table: string) => Condition;
+    /**
+     * The row's scope column, filled from the caller.
+     *
+     * A condition narrows a read, and an insert has no condition: without
+     * this, a caller in one tenant can write a row stamped with another's.
+     * Spread it over what you are writing so the column is not yours to
+     * remember, or to get wrong.
+     *
+     * ```ts
+     * .values({ ...row, ...ctx.stamped("items") })
+     * ```
+     */
+    stamped: (table: string) => Readonly<Record<string, string>>;
+    /**
+     * The same plugin, acting for the scope this names.
+     *
+     * A listener runs on nobody's behalf, so `scoped` and `stamped` refuse
+     * there, and every method they reach refuses with them. This says whose
+     * work the payload announced, so the ordinary path works instead of a
+     * second unscoped one written beside it.
+     *
+     * ```ts
+     * handle: (gone, ctx) => Orders.dropFor(ctx.forScope(gone.shopId), gone.id)
+     * ```
+     *
+     * Refused where a caller already exists: inside a request the scope is
+     * decided by who is asking, and choosing another there is how a caller
+     * reaches rows that are not theirs.
+     */
+    forScope: (claim: string) => Context<Config, Services, Db>;
+    /** Another plugin's services, by name. Only what `dependsOn` names. */
+    use: <Reached>(plugin: string) => Reached;
+};
+/**
+ * Blocks inference at this position.
+ *
+ * Services is inferred from what `services` returns and from nowhere else. A
+ * callback taking a context would otherwise be a second inference site, and
+ * two candidates for one parameter resolve to unknown.
+ */
+type Given<Made> = NoInfer<Made>;
+/** Everything a plugin declares about itself. */
+type Definition<Schema extends z.ZodType = z.ZodType, Services = unknown, Db = unknown> = Described & {
+    version: string;
+    dependsOn?: readonly string[];
+    config?: Schema;
+    permissions?: Readonly<Record<string, Permission>>;
+    /** This plugin's tables, in its own namespace. Nobody else reads them. */
+    tables?: Readonly<Record<string, unknown>>;
+    /**
+     * Which claim decides whose rows these are, and where each table carries
+     * it.
+     *
+     * The kit knows nothing about tenants: it does not know what one is, what
+     * the claim means, or whether a project has any. What it knows, once this
+     * is declared, is that a read of a named table without that column is a
+     * read of somebody else's rows, so `ctx.db` stops handing one out and
+     * `ctx.scoped` hands out the query already narrowed.
+     *
+     * Declaring it also decides the failure: a caller carrying no such claim
+     * is refused rather than defaulted, because a default tenant is
+     * everybody's tenant.
+     */
+    scope?: {
+        describe: string;
+        claim: string;
+        tables: Readonly<Record<string, string>>;
+    };
+    /** Where its migrations live, run in dependency order before setup. */
+    migrations?: string;
+    /** Hosts this plugin may call. Anything else is refused before it dials. */
+    outbound?: readonly string[];
+    services?: (ctx: Context<z.infer<Schema>, never, Db>) => Services;
+    /**
+     * The endpoints this plugin answers.
+     *
+     * Each route carries its own input schema, so `handle` reads what that
+     * schema parsed rather than `unknown`. A handler taking a narrower input
+     * is sound here precisely because the kernel parses before it calls: what
+     * failed the schema never arrives.
+     */
+    routes?: readonly Endpoint<Context<z.infer<Schema>, Given<Services>, Db>>[];
+    emits?: Readonly<Record<string, Event>>;
+    listens?: Readonly<Record<string, Heard<Context<z.infer<Schema>, Given<Services>, Db>>>>;
+    hooks?: Readonly<Record<string, Hook>>;
+    participates?: Readonly<Record<string, Joined<Context<z.infer<Schema>, Given<Services>, Db>>>>;
+    commands?: Readonly<Record<string, Run<Context<z.infer<Schema>, Given<Services>, Db>>>>;
+    setup?: (ctx: Context<z.infer<Schema>, Given<Services>, Db>) => void | Promise<void>;
+    teardown?: (ctx: Context<z.infer<Schema>, Given<Services>, Db>) => void | Promise<void>;
+};
+/** A plugin: its name, and what it declared. */
+type Plugin = {
+    name: string;
+    definition: Definition;
+};
+
+type Failure = {
+    event: string;
+    plugin: string;
+    error: unknown;
+    at: number;
+};
+
+/** What decides whether one caller has any budget left on one route. */
+type Budget = {
+    take: (key: string, window: {
+        requests: number;
+        seconds: number;
+    }) => {
+        allowed: boolean;
+        resetsIn: number;
+    };
+};
+/** One request, as it reaches the kernel. */
+type Incoming = {
+    method: Method;
+    path: string;
+    input: unknown;
+    caller?: Caller | undefined;
+    /** The request's headers, lowercase. A route sees only what it declared. */
+    headers?: Readonly<Record<string, string>> | undefined;
+    /**
+     * Where it came from, when nobody is signed in: an address, a key, or
+     * whatever the project counts anonymous callers by. Only a rate limit
+     * reads it.
+     */
+    from?: string | undefined;
+};
+/** What the kernel answers: a status, and a body already safe to send. */
+type Outgoing = {
+    status: number;
+    body: unknown;
+    headers?: Readonly<Record<string, string>>;
+};
+
+/**
+ * What the kernel needs to reach storage.
+ *
+ * A shape rather than a driver: the kernel never imports a database, so a
+ * project chooses one and a test passes its own. Narrower than what
+ * `database()` returns, which also opens, migrates and closes: the kernel
+ * needs none of that and should not be able to do it.
+ */
+type Storage = {
+    /** One plugin's own handle. What it holds is the project's business. */
+    of: (plugin: string) => unknown;
+    /** Runs work in one transaction, rolled back if it throws. */
+    tx: <Made>(plugin: string, run: (db: unknown) => Promise<Made>) => Promise<Made>;
+    /**
+     * Runs work that is not in a transaction, but never during someone
+     * else's. Optional, so a project may pass a store that needs no such
+     * ordering.
+     */
+    write?: <Made>(run: () => Promise<Made>) => Promise<Made>;
+    /** Whether a transaction is open right now. For diagnosis. */
+    inTransaction?: () => boolean;
+};
+/** One event, as it waits to be delivered. */
+type Announcement = {
+    id: string;
+    plugin: string;
+    name: string;
+    payload: unknown;
+};
+/**
+ * Where events wait, so one is never lost between a commit and its delivery.
+ *
+ * Without this, an event lives only in memory: the work commits, the process
+ * dies, and the listener is never called by anything. Nobody is told, because
+ * the emitter was told nothing to begin with.
+ *
+ * `keep` runs inside the emitting transaction, so an event is written exactly
+ * when the work it announces is, and rolled back with it. `sent` runs after
+ * delivery. Anything still kept at startup was interrupted, and `waiting`
+ * hands it back to be delivered again.
+ *
+ * Delivery is therefore at least once, never exactly once: a listener that
+ * writes must be able to run twice on one event without doubling anything.
+ */
+type Outbox = {
+    /** Writes events inside the transaction that emitted them. */
+    keep: (db: unknown, announcements: readonly Announcement[]) => void;
+    /** Marks one delivered. */
+    sent: (id: string) => Promise<void>;
+    /** What was kept but never marked sent. Read once, at startup. */
+    waiting: () => Promise<readonly Announcement[]>;
+};
+/** One command waiting for its moment. */
+type Scheduled = {
+    id: string;
+    plugin: string;
+    command: string;
+    input: unknown;
+    at: number;
+    attempts: number;
+};
+/**
+ * Where work waits until it is time.
+ *
+ * The kernel has no clock of its own and no timer: it asks `due` on a beat
+ * the project set, runs what it is handed, and says how it went. Everything
+ * that has to survive a restart lives in the database, so a process that
+ * stops between taking a job and finishing it leaves the job takeable again.
+ *
+ * `take` is what makes one process pick up a job and not another: it must
+ * claim and return in one step, or two processes run the same work.
+ */
+type Schedule = {
+    /** Writes one, inside the transaction that asked for it when there is one. */
+    keep: (db: unknown, job: Scheduled) => void;
+    /** Claims what is due, at most `limit`, marking each taken. */
+    take: (now: number, limit: number) => Promise<readonly Scheduled[]>;
+    /** It ran. Forget it. */
+    done: (id: string) => Promise<void>;
+    /** It threw. Put it back for `at`, having counted the attempt. */
+    failed: (id: string, at: number) => Promise<void>;
+    /** It threw too many times. Stop trying. */
+    gaveUp: (id: string) => Promise<void>;
+};
+/**
+ * How a scope becomes a condition the database understands.
+ *
+ * The kernel imports no driver, so it cannot build one: it knows which table
+ * and which value, and the project turns that into whatever its store speaks.
+ */
+type Narrowing = (table: string, column: string, value: string) => unknown;
+/** What the kernel needs to call another server. */
+type Dialer = (call: Outbound) => Promise<unknown>;
+
+/** Where a line goes. The project decides; a plugin never writes directly. */
+type Log = (level: "debug" | "info" | "warn" | "error", plugin: string, line: string, about?: Readonly<Record<string, unknown>>) => void;
+/** What a project gives the kernel. */
+type Options = {
+    plugins: readonly Plugin[];
+    config?: Readonly<Record<string, unknown>>;
+    db?: Storage;
+    dial?: Dialer;
+    log?: Log;
+    /**
+     * What counts requests against a route's declared budget.
+     *
+     * Omit it and a `limit` is inert, which is why `start` says so rather
+     * than letting a declared budget quietly enforce nothing.
+     */
+    budget?: Budget;
+    /**
+     * Where events wait between the transaction that emitted them and the
+     * listener that hears them.
+     *
+     * Without one, an event that is emitted lives only in memory: the work
+     * commits, the process stops, and nothing ever calls the listener. With
+     * one, delivery is at least once, so a listener that writes must survive
+     * being called twice.
+     */
+    outbox?: Outbox;
+    /**
+     * What the current time is, in milliseconds.
+     *
+     * A test pins it to make tomorrow reachable without moving the machine's
+     * clock, which every other test in the process would then share.
+     */
+    now?: () => number;
+    /**
+     * Where work waits until it is time, and how often to look.
+     *
+     * Without one, `ctx.commands.later` refuses: a plugin that can ask for
+     * later work in a deployment that cannot run it would be told nothing.
+     */
+    schedule?: Schedule;
+    /** How often to ask the schedule what is due, in milliseconds. */
+    beat?: number;
+    /**
+     * How many times a scheduled command may throw before it is abandoned.
+     *
+     * Eight by default, which is roughly four minutes of backing off. A job
+     * that has failed that often is failing on something a retry will not
+     * fix, and the line saying it gave up is worth more than the ninth try.
+     */
+    attempts?: number;
+    /**
+     * How a declared scope becomes a condition the store understands.
+     *
+     * The kernel imports no driver, so a project that declares a scope also
+     * says how to narrow by it.
+     */
+    narrow?: Narrowing;
+    /**
+     * How long a hook participant has to answer, in milliseconds.
+     *
+     * A participant that never answers holds the request open, and a throw is
+     * already a refusal, so silence is treated as one too.
+     */
+    patience?: number;
+};
+/** A route, and the plugin it came from. */
+type Registered = {
+    plugin: string;
+    method: Method;
+    path: string;
+    describe: string;
+    requires: readonly string[];
+    public: boolean;
+    limit: {
+        requests: number;
+        seconds: number;
+    } | undefined;
+    /** The request headers this route declared it reads, lowercase. */
+    reads: readonly string[];
+};
+/** What a project holds after createKernel. */
+type Kernel = {
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    started: () => boolean;
+    routes: () => readonly Registered[];
+    handle: (incoming: Incoming) => Promise<Outgoing>;
+    context: (plugin: string, caller?: Caller) => Context;
+    events: {
+        failures: () => readonly Failure[];
+    };
+    /**
+     * Runs whatever the schedule says is due, once, and waits for it.
+     *
+     * What the beat does on a timer, asked for. A test moves its clock and
+     * calls this instead of waiting a real second for an interval it does not
+     * control.
+     */
+    due: () => Promise<void>;
+    run: (command: string, input: unknown, caller?: Caller) => Promise<void>;
+};
+/**
+ * Builds a kernel from what the plugins declared.
+ *
+ * Nothing runs here: `start` validates first, and either brings up every
+ * plugin or throws. A half-started kernel behaves according to where it
+ * stopped, which is not a state anyone can reason about.
+ */
+declare function createKernel(options: Options): Kernel;
+
+/** What opening a database needs to know. */
+type Opening = {
+    /** A path, or ":memory:" for one that lives as long as the process. */
+    file: string;
+    /** How long a writer waits for another to finish, in milliseconds. */
+    busyMs?: number;
+    /** Whether to keep the write-ahead log. Off for :memory:, which has none. */
+    wal?: boolean;
+};
+
+/** Where one plugin keeps its migrations. */
+type Source = {
+    plugin: string;
+    from: string;
+};
+/** One migration file, as it sits on disk. */
+type Step = {
+    plugin: string;
+    name: string;
+    sql: string;
+    hash: string;
+};
+/** What went wrong, in a sentence naming the file. */
+declare class MigrationFault extends Error {
+    readonly plugin: string;
+    readonly step: string | undefined;
+    constructor(message: string, plugin: string, step?: string);
+}
+
+type Tables = Readonly<Record<string, unknown>>;
+type Handle = ReturnType<typeof drizzle>;
+
+/** What building a store needs: where the file is, and who owns what. */
+type Settings = Opening & {
+    tables: Readonly<Record<string, Tables>>;
+};
+/**
+ * What a project holds after opening a database.
+ *
+ * Wider than the kernel's `Storage`: this one also migrates and closes, which
+ * a plugin has no business doing and the kernel never asks for.
+ */
+/**
+ * What `start` needs of a database, whichever one it is.
+ *
+ * Wider than the kernel's `Storage`: this one also migrates and closes, which
+ * a plugin has no business doing and the kernel never asks for. `of` answers
+ * `unknown` because the kit does not know what database it was given; a
+ * plugin names the shape it expects through `definePlugin.over`.
+ */
+type Store<Handed = unknown> = {
+    of: (plugin: string) => Handed;
+    /** An outbox in this same database, when the store can hold one. */
+    outbox?: () => Outbox;
+    /** A schedule in this same database, for work asked for later. */
+    schedule?: () => Schedule;
+    /** How a declared scope becomes a condition over the tables it was given. */
+    narrowing?: () => Narrowing;
+    tx: <Made>(plugin: string, run: (db: unknown) => Promise<Made>) => Promise<Made>;
+    write: <Made>(run: () => Promise<Made>) => Promise<Made>;
+    inTransaction: () => boolean;
+    migrate: (sources: readonly Source[]) => Step[];
+    close: () => void;
+};
+
+/**
+ * Opens a database and holds one handle per plugin over it.
+ *
+ * Built by the project rather than reached for: two stores can exist in one
+ * process without seeing each other, which is what a test needs.
+ */
+declare function database(settings: Settings): Store<Handle>;
+
+export { type Announcement as A, type Budget as B, type Context as C, type Definition as D, type Endpoint as E, type Failure as F, type Handle as H, type Incoming as I, type Joined as J, type Kernel as K, type Listener as L, type Method as M, type Narrowing as N, type Outbox as O, type Participant as P, type Route as R, type Schedule as S, type Tables as T, type Command as a, type Plugin as b, type Caller as c, type Outbound as d, type Store as e, type Opening as f, type Dialer as g, type Logger as h, type Described as i, type Event as j, type Heard as k, type Hook as l, type Log as m, MigrationFault as n, type Options as o, type Outgoing as p, type Permission as q, type Registered as r, type Run as s, type Scheduled as t, type Schematic as u, type Source as v, type Step as w, type Storage as x, createKernel as y, database as z };