primitive-functions 0.2.0-alpha.4 → 0.2.0-alpha.5

package/index.d.ts

@@ -23,12 +23,41 @@ export interface FunctionUser {
   email: string | null;
 }
 
-/** What started this invocation. */
+/**
+ * What started this invocation. Narrow on `kind`.
+ *
+ * The same union the runtime builds (`src/server-functions/trigger-descriptor.ts`),
+ * held identical by `tests/api/spec/function-trigger-declarations-3281.test.ts`:
+ * a field the fire path sets is declared here, and nothing is declared here
+ * that the fire path does not set.
+ */
 export type FunctionTrigger =
+  /** An HTTP invocation: the caller is `ctx.user`. */
   | { kind: "http" }
-  | { kind: "webhook"; [key: string]: unknown }
-  | { kind: "cron"; [key: string]: unknown }
-  | { kind: "database"; databaseId: string; databaseType: string; [key: string]: unknown }
+  /** A verified webhook delivery to the function's own key. */
+  | {
+      kind: "webhook";
+      /** The webhook key, which is the function key. */
+      webhookKey: string;
+      /** The platform's webhook row the delivery log lives under. */
+      webhookId: string;
+      /** The provider's event id (`X-Webhook-Event-Id`), when it sent one. */
+      externalEventId: string | null;
+    }
+  /** A cron entry firing, scheduled or from the `cron-triggers test` diagnostic. */
+  | {
+      kind: "cron";
+      /** The `[[function.triggers.cron]]` entry's `name`. */
+      name: string;
+      /** The platform's cron row. */
+      triggerId: string;
+      /** ISO 8601. The instant the fire was scheduled for; a diagnostic fire's is "now". */
+      scheduledFor: string;
+      /** Present, and true, only on the diagnostic fire: nothing was scheduled. */
+      manual?: true;
+    }
+  /** A write to a watched database type. */
+  | { kind: "database"; databaseId: string; databaseType: string }
   /**
    * A DSL workflow's `workflow.call` step reached this function (#3288).
    *
@@ -37,7 +66,15 @@ export type FunctionTrigger =
    * taking this variant with it. `workflowKey` names the PARENT workflow, and
    * `runId`/`stepId` locate the step inside its run.
    */
-  | { kind: "workflow"; workflowKey: string; runId: string; stepId: string };
+  | { kind: "workflow"; workflowKey: string; runId: string; stepId: string }
+  /**
+   * Another function started this one with `ctx.functions.start` (#3280).
+   *
+   * `functionKey` names the PARENT, and `runId` its run — null when the
+   * parent was a request invocation over HTTP, which writes no run row, or a
+   * database-change fire, which writes none either.
+   */
+  | { kind: "function"; functionKey: string; runId: string | null };
 
 /** The result shape of an operation that answers in response headers. */
 export interface HeaderResult {
@@ -57,7 +94,7 @@ export interface PrimitivePlatformError extends Error {
 
 /**
  * The typed HTTP profile, generated from the platform's OpenAPI document. Its
- * namespaces mirror the operation ids: analytics, blobBuckets, channels, collections, configVars, connections, databaseTypeConfigs, databases, documents, email, functions, gemini, groups, integrations, iterations, llm, locks, notifications, prompts, resourceMetadata, secrets, users.
+ * namespaces mirror the operation ids: analytics, blobBuckets, channels, collections, configVars, connections, databaseTypeConfigs, databases, documents, email, functions, gemini, groups, integrations, llm, locks, notifications, prompts, resourceMetadata, secrets, users.
  * Methods take one options object carrying the operation's path parameters,
  * query parameters, request headers (under their wire names) and `body`.
  *
@@ -65,11 +102,13 @@ export interface PrimitivePlatformError extends Error {
  * type-checks is a method the platform publishes — and a missing path
  * parameter or a missing required header is a compile error rather than a
  * `TypeError` at invoke time. Every call runs with the app's own SYSTEM
- * authority (#3279): the invocation gate was the authorization. The three
- * namespaces the gateway does not admit (`functions`, `iterations`,
- * `databaseTypeConfigs`) are still declared: they exist, they answer the
- * gateway's structured denial, and hiding them would make a route's
- * availability look like a typo.
+ * authority (#3279): the invocation gate was the authorization. The two
+ * namespaces the gateway does not admit are still declared: they exist, they
+ * answer the gateway's structured denial, and hiding them would make a route's
+ * availability look like a typo. Those are `databaseTypeConfigs` whole, and
+ * `functions` except for `functions.start` — the nested-start door #3280
+ * admits by name, which `ctx.functions.start` calls. `functions.invoke`
+ * stays refused: same-run composition is an import.
  */
 export interface FunctionApi {
   "analytics": {
@@ -145,6 +184,10 @@ export interface FunctionApi {
     "searchUsers"(args?: {
       "q"?: string | number | boolean;
       "limit"?: string | number | boolean;
+      "signupDay"?: string | number | boolean;
+      "signupStartDay"?: string | number | boolean;
+      "signupEndDay"?: string | number | boolean;
+      "offset"?: string | number | boolean;
       "current_timestamp"?: string | number | boolean;
       "_bust"?: string | number | boolean;
     }): Promise<any>;
@@ -600,7 +643,7 @@ export interface FunctionApi {
       "query"(args: {
         "databaseId": string | number;
         body: unknown;
-      }): Promise<any>;
+      }): Promise<{ items: any[]; hasMore: boolean; nextCursor?: string; prevCursor?: string }>;
       /** `databases.records.registerIndex` — POST /databases/{databaseId}/records/index/register. Database records: index/register (requires manager-or-higher on the database, or an app-admin/owner role) */
       "registerIndex"(args: {
         "databaseId": string | number;
@@ -968,11 +1011,22 @@ export interface FunctionApi {
     }): Promise<any>;
   };
   "functions": {
-    /** `functions.invoke` — POST /functions/{functionKey}. Invoke a server function: a synchronous one returns its result, a durable one starts a run */
+    /** `functions.invoke` — POST /functions/{functionKey}. Invoke a server function: a request function returns its result, a task function starts a run */
     "invoke"(args: {
       "functionKey": string | number;
       body?: unknown;
     }): Promise<any>;
+    /** `functions.logs` — GET /functions/{functionKey}/logs. List a server function's invocation logs, newest first */
+    "logs"(args: {
+      "functionKey": string | number;
+      "limit"?: string | number | boolean;
+      "cursor"?: string | number | boolean;
+    }): Promise<any>;
+    /** `functions.start` — POST /functions/{functionKey}/start. Start a task function from inside another server function */
+    "start"(args: {
+      "functionKey": string | number;
+      body?: unknown;
+    }): Promise<any>;
   };
   "gemini": {
     /** `gemini.countTokens` — POST /gemini/count-tokens. Count tokens for a Gemini request */
@@ -1080,18 +1134,6 @@ export interface FunctionApi {
       "integrationKey": string | number;
     }): Promise<any>;
   };
-  "iterations": {
-    /** `iterations.get` — GET /iterations/{iterationName}. Get details for a single iteration */
-    "get"(args: {
-      "iterationName": string | number;
-    }): Promise<any>;
-    /** `iterations.list` — GET /iterations. List iteration runs */
-    "list"(args?: Record<string, never>): Promise<any>;
-    /** `iterations.reset` — POST /iterations/{iterationName}/reset. Reset a terminal iteration so the next trigger runs fresh */
-    "reset"(args: {
-      "iterationName": string | number;
-    }): Promise<any>;
-  };
   "llm": {
     /** `llm.chat` — POST /llm/chat. Run an LLM chat completion */
     "chat"(args: {
@@ -1267,6 +1309,46 @@ export type DatabaseModels<K extends string> = K extends keyof DatabaseSchemas
   ? DatabaseSchemas[K]
   : Record<string, Record<string, unknown>>;
 
+/**
+ * The app's functions, key by key — EMPTY here and filled by the declaration
+ * `primitive config push` writes into the config tree's `functions/`
+ * directory (`primitive-function-types.d.ts`): each key's declared input and
+ * output types (from its `inputSchema` and `outputSchema`) and its mode. It
+ * is what types `defineFunction("<key>", handler)`.
+ */
+export interface FunctionSchemas {}
+
+/**
+ * The keys `defineFunction(key, handler)` accepts: every key the augmentation
+ * declares once a tree has pushed, so a key the tree does not declare is a
+ * compile error — and `string` before that, the `DatabaseTypeKeys` rule, so an
+ * unaugmented tree keeps compiling.
+ */
+export type FunctionKeys = [keyof FunctionSchemas] extends [never]
+  ? string
+  : keyof FunctionSchemas & string;
+
+/** A declared function's input type, or `any` when nothing is declared. */
+export type FunctionInput<K extends string> = K extends keyof FunctionSchemas
+  ? FunctionSchemas[K] extends { input: infer I }
+    ? I
+    : any
+  : any;
+
+/** A declared function's output type, or `any` when nothing is declared. */
+export type FunctionOutput<K extends string> = K extends keyof FunctionSchemas
+  ? FunctionSchemas[K] extends { output: infer O }
+    ? O
+    : any
+  : any;
+
+/** A declared function's mode, fixed at generation time. */
+export type FunctionMode<K extends string> = K extends keyof FunctionSchemas
+  ? FunctionSchemas[K] extends { mode: infer M }
+    ? M
+    : "request" | "task"
+  : "request" | "task";
+
 /**
  * The model names one database type addresses — its own, or any name at all
  * for a type that declares no schema (the DO is schemaless, so a grant on such
@@ -1311,7 +1393,14 @@ export type ModelBatchOperation<TRow> = {
 };
 
 export interface DatabaseModelHandle<TRow> {
-  query(body?: ModelScopedBody): Promise<{ data: TRow[]; hasMore?: boolean; nextCursor?: string }>;
+  /**
+   * One page of this model's rows, in the decided envelope — `{ items,
+   * hasMore, nextCursor? }` (#3287), the same shape `ctx.doc(...)`,
+   * `ctx.users.list` and the client library answer. The route's own wire
+   * shape is unchanged; the SDK is where the one name lives, so shared paging
+   * code can be written once.
+   */
+  query(body?: ModelScopedBody): Promise<{ items: TRow[]; hasMore: boolean; nextCursor?: string }>;
   count(body?: ModelScopedBody): Promise<any>;
   aggregate(body: ModelScopedBody): Promise<any>;
   save(body: ModelScopedBody<{ id?: string; data: Partial<TRow>; [key: string]: unknown }>): Promise<any>;
@@ -1343,6 +1432,50 @@ export interface DatabaseHandle<TModels> {
   runOperation(name: string, params?: Record<string, unknown>): Promise<any>;
 }
 
+/**
+ * The app's DOCUMENT models — EMPTY here and filled by the declaration
+ * `primitive config push` writes into the config tree's `functions/` directory
+ * (`primitive-document-types.d.ts`, from the project's `models/models.toml`).
+ * A project with no document schema gets the open form and still compiles.
+ */
+export interface DocumentSchemas {}
+
+/** The model names `ctx.doc(id).model()` accepts — every declared one, or `string` before a push. */
+export type DocumentModelNames = [keyof DocumentSchemas] extends [never]
+  ? string
+  : keyof DocumentSchemas & string;
+
+/** A document model's row shape, or an open record for an undeclared schema. */
+export type DocumentModelRow<M extends string> = M extends keyof DocumentSchemas
+  ? DocumentSchemas[M]
+  : Record<string, unknown>;
+
+/** The options a document model read takes: a filter object (or its JSON), a page size, a cursor. */
+export interface DocumentQueryOptions {
+  filter?: Record<string, unknown> | string;
+  limit?: number;
+  cursor?: string;
+}
+
+/**
+ * One document model, bound to its document and its model name — a thin
+ * binding over `ctx.api.documents.records.*` with the route's own shapes.
+ */
+export interface DocumentModelHandle<TRow> {
+  query(options?: DocumentQueryOptions): Promise<{ items: TRow[]; hasMore: boolean; nextCursor?: string }>;
+  count(options?: { filter?: Record<string, unknown> | string }): Promise<{ count: number }>;
+  aggregate(body: Record<string, unknown>): Promise<any>;
+  save(body: { id: string; data: Partial<TRow>; options?: Record<string, unknown> }): Promise<{ record: TRow }>;
+  patch(recordId: string, body: { data: Partial<TRow>; options?: Record<string, unknown> }): Promise<{ record: TRow }>;
+  delete(recordId: string): Promise<{ deleted: boolean }>;
+}
+
+/** A document, addressed once; its models are typed from `DocumentSchemas`. */
+export interface DocumentHandle {
+  documentId: string;
+  model<M extends DocumentModelNames>(modelName: M): DocumentModelHandle<DocumentModelRow<M>>;
+}
+
 /**
  * One call through a granted integration — #3183.
  *
@@ -1421,6 +1554,67 @@ export interface ChannelGrantResult {
   expiresAt: number;
 }
 
+/** Where to start and how big a page to take — #3280. */
+export interface UserPageOptions {
+  /** Page size. Capped by the route at 100. */
+  limit?: number;
+  /** The `nextCursor` of the page before this one. */
+  cursor?: string;
+}
+
+/** One user on the roster, as the platform's own users route reports them. */
+export interface UserPageItem {
+  userId: string;
+  email: string | null;
+  name: string | null;
+  avatarUrl: string | null;
+  role: string;
+  addedAt: string | null;
+  status: string;
+  disabledAt: string | null;
+  [key: string]: unknown;
+}
+
+/** The decided paged envelope, the same shape every paged read answers. */
+export interface UserPage {
+  items: UserPageItem[];
+  hasMore: boolean;
+  /** Absent on the last page. */
+  nextCursor?: string;
+}
+
+/** How a nested start is keyed and labelled — #3280. */
+export interface FunctionStartOptions {
+  /**
+   * Idempotency key, scoped to the tree's root initiator and the resolved
+   * context document: a repeat replays the run that already exists rather than
+   * starting a second. At most 100 characters.
+   */
+  runKey?: string;
+  /**
+   * The document the child's run is keyed under. Defaults through the
+   * inheritance rule: the parent run's context, else the root caller's root
+   * document, else `fn:<the root function's id>`. At most 100 characters.
+   */
+  contextDocId?: string;
+  /** Caller metadata, at most 1 KB encoded. */
+  meta?: Record<string, unknown>;
+}
+
+/** The start envelope, the same one a workflow start answers with — #3280. */
+export interface FunctionStartResult {
+  /** Poll this on the platform's run-status route. */
+  runId: string;
+  runKey: string;
+  instanceId: string;
+  status: string;
+  /**
+   * True when `runKey` already named a run in this tree, which this envelope
+   * describes. That is what makes a run key a singleton.
+   */
+  existing?: boolean;
+}
+
 export interface FunctionContext {
   /** The HTTP caller, or null for a webhook, cron or database-change fire. */
   user: FunctionUser | null;
@@ -1435,6 +1629,13 @@ export interface FunctionContext {
     databaseId: string,
     databaseType: K
   ): DatabaseHandle<DatabaseModels<K>>;
+  /**
+   * A typed handle over one document's record models, typed from the
+   * project's `models/models.toml` — `ctx.db`'s shape for documents. It
+   * confers nothing: every call is a `documents.records.*` operation on the
+   * same authority.
+   */
+  doc(documentId: string): DocumentHandle;
   /**
    * Outbound HTTP, through a granted integration and nowhere else (#3183).
    *
@@ -1451,6 +1652,26 @@ export interface FunctionContext {
       request?: IntegrationCallRequest
     ): Promise<IntegrationCallResult>;
   };
+  /**
+   * Start a TASK function from inside this one — #3280.
+   *
+   * The one nested door, and it is a START. A request function is code and
+   * code composes by being IMPORTED, so there is no synchronous nested
+   * invocation to reach for; a request-mode callee answers
+   * `FUNCTION_MODE_MISMATCH`.
+   *
+   * The callee's `access` gate is not consulted — this function's own gate was
+   * the authorization — and every run in the tree is keyed by whoever started
+   * it, so the member who invoked the root polls and terminates them all.
+   * Nesting is bounded at four levels.
+   */
+  functions: {
+    start(
+      functionKey: string,
+      input?: unknown,
+      options?: FunctionStartOptions
+    ): Promise<FunctionStartResult>;
+  };
   /**
    * Run one of the app's prompts, under a `prompt:<key>` grant (#3183).
    *
@@ -1485,6 +1706,24 @@ export interface FunctionContext {
    * error.
    */
   users: {
+    /**
+     * One page of the app's users — #3280.
+     *
+     * On the APP's system authority, whoever invoked the function: a member
+     * who passes this function's gate reads whatever roster it chooses to
+     * expose, so say who may in the function's own `access` expression.
+     * `limit` is capped by the route at 100.
+     */
+    list(options?: UserPageOptions): Promise<UserPage>;
+    /**
+     * Every page of the app's users, in order — #3280.
+     *
+     * FOR A REQUEST FUNCTION AND A SINGLE-SLICE LOOP. A durable loop must take
+     * its pages inside `step.do` with an EXPLICIT cursor: a memoized step does
+     * not advance an iterator on resume, so an iteration across a sleep would
+     * replay pages it had already taken.
+     */
+    iterate(options?: UserPageOptions): AsyncIterable<UserPage>;
     send(userId: string, payload: unknown): Promise<SendResult>;
   };
   /** The same frame to ONE connection, under a `connections:send` grant. */
@@ -1537,29 +1776,49 @@ export interface FunctionStep {
 export declare const SDK_STUB_VERSION: string;
 
 /**
- * Declare a server function's handler.
- *
- * Both authoring styles reach the platform bootstrap identically — a plain
- * default export taking `(input, ctx, step)` runs exactly as a wrapped one
- * does — so this is a typing and intent marker, not a different calling
- * convention.
+ * The handler a function exports, typed for one declared key.
  *
- * `step` is the third argument in BOTH modes (#3186). A durable run gets the
- * engine's live `WorkflowStep`; a synchronous one gets a passthrough shim
+ * `step` is the third argument in BOTH modes (#3186). A task run gets the
+ * engine's live `WorkflowStep`; a request invocation gets a passthrough shim
  * (`do` runs the body, `sleep` resolves at once, `waitForEvent` throws a
- * named error), so a durable-authored body can be exercised synchronously.
+ * named error), so a task-authored body can be exercised as a request.
  */
+export type FunctionHandler<TInput, TOutput> = (
+  input: TInput,
+  ctx: FunctionContext,
+  step: FunctionStep
+) => Promise<TOutput>;
+
+/**
+ * Declare a server function's handler, typed from its declaration.
+ *
+ * The KEYED form, `defineFunction("<key>", handler)`, is typed from the
+ * `FunctionSchemas` augmentation `primitive config push` writes beside the
+ * sources: `input` is the key's declared input, the return is checked against
+ * its declared output, and a key the tree does not declare is a compile error.
+ * `config push` also refuses an entry whose key names another file's. In a
+ * tree that has not pushed yet the key is any string and both types are `any`.
+ *
+ * The UNKEYED form is what it always was: author-declared generics. Both
+ * styles reach the platform bootstrap identically — a plain default export
+ * taking `(input, ctx, step)` runs exactly as a wrapped one does — so this is
+ * a typing and intent marker, not a different calling convention.
+ */
+export declare function defineFunction<K extends FunctionKeys>(
+  key: K,
+  handler: (
+    input: FunctionInput<K>,
+    ctx: FunctionContext,
+    step: FunctionStep
+  ) => FunctionOutput<K> | Promise<FunctionOutput<K>>
+): FunctionHandler<FunctionInput<K>, FunctionOutput<K>> & { functionKey: K };
 export declare function defineFunction<TInput = unknown, TOutput = unknown>(
   handler: (
     input: TInput,
     ctx: FunctionContext,
     step: FunctionStep
   ) => TOutput | Promise<TOutput>
-): (
-  input: TInput,
-  ctx: FunctionContext,
-  step: FunctionStep
-) => Promise<TOutput>;
+): FunctionHandler<TInput, TOutput>;
 
 /**
  * One declared parameter of a registered query.
@@ -1568,13 +1827,64 @@ export declare function defineFunction<TInput = unknown, TOutput = unknown>(
  * the platform injects the invocation's user and refuses a call that supplies
  * the parameter itself.
  */
+/** The scalar parameter types, and an array parameter's element types. */
+export type QueryScalarParamType = "string" | "number" | "boolean" | "any";
+
 export interface QueryParamSpec {
-  type?: "string" | "number" | "boolean" | "any" | "$caller";
+  type?: QueryScalarParamType | "$caller" | "array";
+  /** For `type: "array"` — the element type; absent means any element. */
+  items?: { type: QueryScalarParamType };
   caller?: boolean;
   optional?: boolean;
   default?: unknown;
 }
 
+/** A scalar parameter type's TypeScript type. */
+export type QueryScalarValue<T> = T extends "string"
+  ? string
+  : T extends "number"
+    ? number
+    : T extends "boolean"
+      ? boolean
+      : T extends "$caller"
+        ? string
+        : any;
+
+/** The value `run` receives for one declared parameter. */
+export type QueryParamValue<S> = S extends { caller: true }
+  ? string
+  : S extends { type: "array"; items: { type: infer I } }
+    ? QueryScalarValue<I>[]
+    : S extends { type: "array" }
+      ? unknown[]
+      : S extends { type: infer T }
+        ? QueryScalarValue<T>
+        : any;
+
+type QueryOptionalKeys<P> = {
+  [K in keyof P]: P[K] extends { optional: true } ? K : never;
+}[keyof P];
+
+/**
+ * `run`'s `params`, typed from the declaration: scalars as their scalar,
+ * `$caller` as a string, an array as `T[]`, an `optional: true` parameter
+ * as an optional key (a parameter with a default is always present). An
+ * undeclared name is a compile error.
+ */
+export type QueryParams<P> = {
+  [K in Exclude<keyof P, QueryOptionalKeys<P>>]: QueryParamValue<P[K]>;
+} & {
+  [K in QueryOptionalKeys<P>]?: QueryParamValue<P[K]>;
+};
+
+/** A registration's definition with its parameters DECLARED, so `run` is typed from them. */
+export interface TypedQueryDefinition<TDb, TSpec extends Record<string, QueryParamSpec>, TResult> {
+  models: string[];
+  params?: TSpec;
+  cache?: { ttlMs: number };
+  run: (db: TDb, params: QueryParams<TSpec>) => TResult | Promise<TResult>;
+}
+
 export interface QueryDefinition<TDb, TParams, TResult> {
   /** The models this query touches. Caching is off unless the run matches. */
   models: string[];
@@ -1599,7 +1909,23 @@ export interface QueryDefinition<TDb, TParams, TResult> {
  *
  * Register at MODULE scope: a registration made inside the handler still works
  * for direct calls but is invisible to `config push`'s manifest.
+ *
+ * `run`'s `params` are TYPED from the declaration (the first overload,
+ * inferred with a `const` type parameter): a scalar as its scalar, `$caller`
+ * as a string, `{ type: "array", items: { type: "string" } }` as `string[]`,
+ * an `optional: true` parameter as an optional key; an undeclared name inside
+ * `run` is a compile error. A declared default is coerced to the declared
+ * type at registration, so `run` receives what the declaration promises. The
+ * second overload keeps an explicit `TParams`.
  */
+export declare function defineQuery<
+  const TSpec extends Record<string, QueryParamSpec>,
+  TDb = DatabaseHandle<any>,
+  TResult = any
+>(
+  name: string,
+  definition: TypedQueryDefinition<TDb, TSpec, TResult>
+): (db: TDb, params?: Record<string, unknown>) => Promise<TResult>;
 export declare function defineQuery<
   TDb = DatabaseHandle<any>,
   TParams = Record<string, any>,
@@ -1610,6 +1936,14 @@ export declare function defineQuery<
 ): (db: TDb, params?: Record<string, unknown>) => Promise<TResult>;
 
 /** The same, for a registration that writes. A mutation is never cached. */
+export declare function defineMutation<
+  const TSpec extends Record<string, QueryParamSpec>,
+  TDb = DatabaseHandle<any>,
+  TResult = any
+>(
+  name: string,
+  definition: TypedQueryDefinition<TDb, TSpec, TResult>
+): (db: TDb, params?: Record<string, unknown>) => Promise<TResult>;
 export declare function defineMutation<
   TDb = DatabaseHandle<any>,
   TParams = Record<string, any>,

package/index.js

@@ -24,10 +24,12 @@ const NOT_PROVIDED =
 export const SDK_STUB_VERSION = "0.0.1";
 
 /**
- * Declare a function's handler. The platform copy returns the handler wrapped
- * with its invocation context; this one refuses, loudly.
+ * Declare a function's handler — `defineFunction(handler)` or the keyed
+ * `defineFunction("<key>", handler)`. The platform copy returns the handler
+ * wrapped with its invocation context; this one refuses, loudly, whichever
+ * shape it is called with.
  */
-export function defineFunction() {
+export function defineFunction(_keyOrHandler, _maybeHandler) {
   throw new Error(NOT_PROVIDED);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primitive-functions",
-  "version": "0.2.0-alpha.4",
+  "version": "0.2.0-alpha.5",
   "description": "The module a Primitive server function imports. Supplied by the platform at invoke time; reserved here so the name is ours before the runtime lands.",
   "license": "UNLICENSED",
   "author": "Primitive LLC",