@astrale-os/sdk 0.6.0-beta.42 → 0.6.0-beta.43

package/dist/application/query/recipe/recipe.d.ts

@@ -1,9 +1,8 @@
 /**
- * A recipe (spec § Recipes: the contract): an id, a `build` of one to eight stages of reads over
- * the Domain's handles, an optional `output` and the errors it declares. Stage n receives the
- * merged results of stages 1 to n - 1. A single stage returns one read or a record of facets read
- * together; each of several returns a record of facets. A stage cannot be a function facet inside one object literal (TS7031: its parameter
- * has no contextual type while the record's is inferred), so stages are a tuple.
+ * A recipe (spec § Recipes: the contract): an id, a `build` over the Domain's handles, an optional
+ * `output` and the errors it declares. `build` returns one read, a record of facets read together,
+ * or, when reads wait for others, `steps(first, (earlier) => next, …)`: two to eight records of
+ * facets, each function receiving the merged results of the steps before it.
  */
 import type { z } from 'zod';
 import type { DeclaredErrorDefinition } from '../../../platform/schema/error.js';
@@ -16,11 +15,11 @@ export type Facet = Read<unknown> | readonly Read<unknown>[] | undefined;
 export type Facets = {
     readonly [facet: string]: Facet;
 };
-/** What a single stage returns: one read, or a record of facets. */
+/** What `build` returns without steps, and the first step: one read, or a record of facets. */
 export type Built = Read<unknown> | Facets;
 /** A read gives its answer; a list of reads a list of answers; nothing gives `undefined`. */
 export type FacetResult<F> = F extends Read<infer T> ? T : F extends readonly Read<infer T>[] ? readonly T[] : F extends undefined ? undefined : never;
-/** The results of one stage; a page read, a recipe's single read, gives its `Page`. */
+/** The results of one step; a page read, a recipe's single read, gives its `Page`. */
 export type Results<B> = B extends Read<infer T> ? T : B extends PageRead<infer T> ? Page<T> : {
     readonly [K in keyof B]: FacetResult<B[K]>;
 };
@@ -31,14 +30,14 @@ type Flat<T> = T extends unknown ? {
     readonly [K in keyof T]: T[K];
 } : never;
 /**
- * A later stage's facets: none takes a name an earlier stage read, whose result the merge would
+ * A later step's facets: none takes a name an earlier step read, whose result the merge would
  * replace. An index signature (its `string` and `number` keys) names no facet in particular, so it
  * refuses none.
  */
 type Later<Earlier> = Facets & {
-    readonly [K in keyof Earlier as string extends K ? never : number extends K ? never : K]?: '✗ an earlier stage read this facet: name it otherwise';
+    readonly [K in keyof Earlier as string extends K ? never : number extends K ? never : K]?: '✗ an earlier step read this facet: name it otherwise';
 };
-/** The results of the stages so far, merged. */
+/** The results of the steps so far, merged. */
 export type Merged<B1, B2, B3 = {}, B4 = {}, B5 = {}, B6 = {}, B7 = {}, B8 = {}> = Flat<Results<B1> & Results<B2> & Results<B3> & Results<B4> & Results<B5> & Results<B6> & Results<B7> & Results<B8>>;
 /** The errors a recipe declares, by UPPER_SNAKE code: at most 32. */
 export type Errors = {
@@ -85,7 +84,6 @@ export type PageRecipe<Id extends string = string, Input = unknown, Output = unk
 export type InputOf<R> = R extends Recipe<string, infer I, unknown, Errors> ? I : never;
 /** The output a recipe answers. */
 export type OutputOf<R> = R extends Recipe<string, unknown, infer O, Errors> ? O : never;
-type Stage<S, I, Earlier, B> = (earlier: Earlier, input: I, d: Handles<S>) => B;
 type Output<S, Results, I, O, E extends Errors> = (results: Results, input: I, context: OutputContext<S, E>) => O;
 /**
  * Whether a type is portable JSON as far as its type can tell: a function, or an object that
@@ -97,38 +95,40 @@ type Portable<T, Depth extends readonly unknown[] = []> = unknown extends T ? tr
 }[keyof T] extends true ? true : false;
 /** `output` returns portable JSON, checked by type (spec § API reference: Recipes). */
 type PortableOutput<O> = [Portable<O>] extends [true] ? unknown : '✗ output returns portable JSON: no function, Promise, Date, Map or other object with methods';
-/** `defineQuery<Schema>()`'s v7 forms: a string id first. */
+/** What `steps(…)` returns: the merged results of its steps, for `output`. */
+export interface Stepped<out R> {
+    readonly '~stepped': R;
+}
+/** The results of what `build` returns: a read's, a page's, a record of facets', or the steps'. */
+export type BuiltResults<B> = B extends Stepped<infer R> ? R : Results<B>;
+/**
+ * `build`'s third parameter: reads that wait for others. The first step is a record of facets;
+ * each next one a function of the merged results of the steps before it, returning a record of
+ * facets none of them read. Two to eight steps, one overload per count, so a call's error is its
+ * own count's.
+ */
+export interface Steps {
+    <B1 extends Facets, B2 extends Later<Results<B1>>>(first: B1, second: (earlier: Results<B1>) => B2): Stepped<Merged<B1, B2>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3): Stepped<Merged<B1, B2, B3>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>, B4 extends Later<Merged<B1, B2, B3>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3, fourth: (earlier: Merged<B1, B2, B3>) => B4): Stepped<Merged<B1, B2, B3, B4>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>, B4 extends Later<Merged<B1, B2, B3>>, B5 extends Later<Merged<B1, B2, B3, B4>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3, fourth: (earlier: Merged<B1, B2, B3>) => B4, fifth: (earlier: Merged<B1, B2, B3, B4>) => B5): Stepped<Merged<B1, B2, B3, B4, B5>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>, B4 extends Later<Merged<B1, B2, B3>>, B5 extends Later<Merged<B1, B2, B3, B4>>, B6 extends Later<Merged<B1, B2, B3, B4, B5>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3, fourth: (earlier: Merged<B1, B2, B3>) => B4, fifth: (earlier: Merged<B1, B2, B3, B4>) => B5, sixth: (earlier: Merged<B1, B2, B3, B4, B5>) => B6): Stepped<Merged<B1, B2, B3, B4, B5, B6>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>, B4 extends Later<Merged<B1, B2, B3>>, B5 extends Later<Merged<B1, B2, B3, B4>>, B6 extends Later<Merged<B1, B2, B3, B4, B5>>, B7 extends Later<Merged<B1, B2, B3, B4, B5, B6>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3, fourth: (earlier: Merged<B1, B2, B3>) => B4, fifth: (earlier: Merged<B1, B2, B3, B4>) => B5, sixth: (earlier: Merged<B1, B2, B3, B4, B5>) => B6, seventh: (earlier: Merged<B1, B2, B3, B4, B5, B6>) => B7): Stepped<Merged<B1, B2, B3, B4, B5, B6, B7>>;
+    <B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>>, B4 extends Later<Merged<B1, B2, B3>>, B5 extends Later<Merged<B1, B2, B3, B4>>, B6 extends Later<Merged<B1, B2, B3, B4, B5>>, B7 extends Later<Merged<B1, B2, B3, B4, B5, B6>>, B8 extends Later<Merged<B1, B2, B3, B4, B5, B6, B7>>>(first: B1, second: (earlier: Results<B1>) => B2, third: (earlier: Merged<B1, B2>) => B3, fourth: (earlier: Merged<B1, B2, B3>) => B4, fifth: (earlier: Merged<B1, B2, B3, B4>) => B5, sixth: (earlier: Merged<B1, B2, B3, B4, B5>) => B6, seventh: (earlier: Merged<B1, B2, B3, B4, B5, B6>) => B7, eighth: (earlier: Merged<B1, B2, B3, B4, B5, B6, B7>) => B8): Stepped<Merged<B1, B2, B3, B4, B5, B6, B7, B8>>;
+}
+/** `defineQuery<Schema>()`'s v7 form: a string id first. */
 export interface RecipeDefinitions<S> {
     /**
-     * One stage: one read, a record of facets, or a page as its single read, whose `output` keeps
-     * the page shape (the cursor stays the Kernel's). The page is not an overload of its own: a
-     * callback keeps the contextual type of the first overload tried. Its type is spelled out, not
+     * `build` returns one read, a record of facets, `steps(…)`, or a page as its single read, whose
+     * `output` keeps the page shape (the cursor stays the Kernel's). Its type is spelled out, not
      * `PageRecipe`: a Domain's exported declarations then name only `Recipe`.
      */
-    <const Id extends string, I, B extends Built | PageRead<unknown>, O = Results<B>, E extends Errors = {}>(id: Id, spec: {
-        readonly build: (input: I, d: Handles<S>) => B;
-        readonly output?: Output<S, Results<B>, I, O & PageShape<B>, E> & PortableOutput<O>;
+    <const Id extends string, I, B extends Built | PageRead<unknown> | Stepped<unknown>, O = BuiltResults<B>, E extends Errors = {}>(id: Id, spec: {
+        readonly build: (input: I, d: Handles<S>, steps: Steps) => B;
+        readonly output?: Output<S, BuiltResults<B>, I, O & PageShape<B>, E> & PortableOutput<O>;
         readonly errors?: E;
     }): B extends PageRead<infer T> ? Recipe<Id, I, O, E> & {
         readonly '~page'?: T;
     } : Recipe<Id, I, O, E>;
-    /**
-     * Two to eight stages, each returning a record of facets: stage n receives the merged results of
-     * stages 1 to n - 1, and names facets none of them read.
-     */
-    <const Id extends string, I, B1 extends Facets, B2 extends Later<Results<B1>>, B3 extends Later<Merged<B1, B2>> = {}, B4 extends Later<Merged<B1, B2, B3>> = {}, B5 extends Later<Merged<B1, B2, B3, B4>> = {}, B6 extends Later<Merged<B1, B2, B3, B4, B5>> = {}, B7 extends Later<Merged<B1, B2, B3, B4, B5, B6>> = {}, B8 extends Later<Merged<B1, B2, B3, B4, B5, B6, B7>> = {}, O = Merged<B1, B2, B3, B4, B5, B6, B7, B8>, E extends Errors = {}>(id: Id, spec: {
-        readonly build: readonly [
-            (input: I, d: Handles<S>) => B1,
-            Stage<S, I, Results<B1>, B2>,
-            Stage<S, I, Merged<B1, B2>, B3>?,
-            Stage<S, I, Merged<B1, B2, B3>, B4>?,
-            Stage<S, I, Merged<B1, B2, B3, B4>, B5>?,
-            Stage<S, I, Merged<B1, B2, B3, B4, B5>, B6>?,
-            Stage<S, I, Merged<B1, B2, B3, B4, B5, B6>, B7>?,
-            Stage<S, I, Merged<B1, B2, B3, B4, B5, B6, B7>, B8>?
-        ];
-        readonly output?: Output<S, Merged<B1, B2, B3, B4, B5, B6, B7, B8>, I, O, E> & PortableOutput<O>;
-        readonly errors?: E;
-    }): Recipe<Id, I, O, E>;
 }
 export {};

package/dist/deployment/build/build.d.ts

@@ -7,12 +7,19 @@ export interface Build<Schema extends schema.DomainSchema = schema.DomainSchema,
     readonly schema: BuildSchema<Schema>;
     readonly runtime: RuntimeValue;
     readonly callables: readonly Key.Callable[];
-    readonly requirements: release.Requirements;
+    readonly requirements: BuildRequirements;
     readonly routes: routes.Plan;
     readonly frontend?: FrontendCompilation;
     /** What the release manifest shows of the application: its icon. */
     readonly presentation?: BuildPresentation;
 }
+/**
+ * What a build requires of the Instance. The SDK declares capabilities in the legacy shape only
+ * (`functions`, `classes`, `authority`, `core`), never roles or scopes.
+ */
+export interface BuildRequirements extends release.Requirements {
+    readonly capabilities: release.LegacyCapabilityRequirements;
+}
 export interface BuildPresentation {
     /** One self-contained inline SVG. */
     readonly icon?: string;

package/dist/deployment/build/material.js

@@ -58,6 +58,9 @@ export function restoreBuild(input, runtime) {
     }
     const registry = bindRuntime(domain, runtime, input.callables);
     const requirements = admitRequirements(input.requirements);
+    // A build declares its capabilities in the legacy shape only: never roles or scopes.
+    if ('roles' in requirements.capabilities || 'scopes' in requirements.capabilities)
+        invalid();
     validateRequirements(decoded.root, decoded.closure, requirements);
     const plan = admitRoutePlan(input.routes, domain);
     const compiled = deepFreeze(input.schema.compiled);

package/dist/platform/schema/kernel-compiled.d.ts

@@ -1,2 +1,2 @@
-/** Generated from the Kernel Schema of @astrale-os/kernel-core 1.0.0-beta.23, reduced to its Classes. Regenerate with pnpm sync:kernel-schema. */
+/** Generated from the Kernel Schema of @astrale-os/kernel-core 1.0.0-beta.24, reduced to its Classes. Regenerate with pnpm sync:kernel-schema. */
 export declare const kernelCompiledSchema: string;