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

package/dist/execution/invocation/capabilities/bind.js

@@ -1,9 +1,9 @@
-import { mutationRecipeSpecOf } from '../../../application/mutation/define.js';
+import { mutationSpecOf } from '../../../application/mutation/define.js';
 import { executeMutation } from '../../../application/mutation/execution/execute.js';
 import { bindMutation } from '../../../application/mutation/execution/executor.js';
+import { querySpecOf } from '../../../application/query/defined/define.js';
 import { bindQuery } from '../../../application/query/execution/executor.js';
-import { runQueryRecipe } from '../../../application/query/execution/recipe.js';
-import { recipeSpecOf } from '../../../application/query/recipe/define.js';
+import { runQuery } from '../../../application/query/execution/run.js';
 import { bindDependencies } from '../dependency/index.js';
 export function bindCapabilities(domain, sessions, declared) {
     const graph = bindGraph(sessions, domain);
@@ -13,17 +13,17 @@ export function bindCapabilities(domain, sessions, declared) {
         dependencies: bindDependencies(domain, sessions),
         graph,
         query: async (definition, input, options) => {
-            if (mutationRecipeSpecOf(definition) !== undefined)
+            if (mutationSpecOf(definition) !== undefined)
                 throw new TypeError(`Mutation ${definition.id} writes: call it with mutate, not query.`);
-            if (recipeSpecOf(definition) === undefined)
+            if (querySpecOf(definition) === undefined)
                 return graphUnder(options).query(definition, input);
             if (options === undefined)
-                throw new TypeError(`Recipe ${definition.id} is called with { as: 'executor' | 'caller' }.`);
+                throw new TypeError(`Query ${definition.id} is called with { as: 'executor' | 'caller' }.`);
             const { size, after } = options;
-            return runQueryRecipe(sessions[authorityOf(sessions, options)], domain, definition, input, { ...(size === undefined ? {} : { size }), ...(after === undefined ? {} : { after }) }, declared);
+            return runQuery(sessions[authorityOf(sessions, options)], domain, definition, input, { ...(size === undefined ? {} : { size }), ...(after === undefined ? {} : { after }) }, declared);
         },
         mutate: async (definition, input, options) => {
-            if (mutationRecipeSpecOf(definition) === undefined)
+            if (mutationSpecOf(definition) === undefined)
                 return graphUnder(options).mutate(definition, input);
             if (options === undefined)
                 throw new TypeError(`Mutation ${definition.id} is called with { as: 'executor' | 'caller' }.`);

package/dist/execution/invocation/dispatch/action.js

@@ -1,5 +1,5 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../../application/error/index.js';
-import { protocolError, reportUndeclaredRecipeError } from '../result/index.js';
+import { protocolError, reportUndeclaredDefinedError } from '../result/index.js';
 export async function action(selected, context) {
     const complete = Object.freeze({
         ...context,
@@ -11,7 +11,7 @@ export async function action(selected, context) {
     catch (cause) {
         const declared = declaredErrorOf(cause, selected.definition);
         if (declared === undefined) {
-            reportUndeclaredRecipeError(cause, selected.address);
+            reportUndeclaredDefinedError(cause, selected.address);
             throw cause;
         }
         throw protocolError(declared.family, declared.message, {

package/dist/execution/invocation/dispatch/workflow.js

@@ -1,5 +1,5 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../../application/error/index.js';
-import { protocolError, reportUndeclaredRecipeError } from '../result/index.js';
+import { protocolError, reportUndeclaredDefinedError } from '../result/index.js';
 export async function workflow(selected, context, runner) {
     const complete = Object.freeze({
         ...context,
@@ -11,7 +11,7 @@ export async function workflow(selected, context, runner) {
     catch (cause) {
         const declared = declaredErrorOf(cause, selected.definition);
         if (declared === undefined) {
-            reportUndeclaredRecipeError(cause, selected.address);
+            reportUndeclaredDefinedError(cause, selected.address);
             throw cause;
         }
         throw protocolError(declared.family, declared.message, {

package/dist/execution/invocation/result/index.d.ts

@@ -1,5 +1,5 @@
 export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export type { InvocationDefectCode } from './errors.js';
 export { project } from './project.js';
-export { reportUndeclaredRecipeError } from './recipe.js';
+export { reportUndeclaredDefinedError } from './undeclared.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/index.js

@@ -1,4 +1,4 @@
 export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export { project } from './project.js';
-export { reportUndeclaredRecipeError } from './recipe.js';
+export { reportUndeclaredDefinedError } from './undeclared.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/undeclared.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Log a Query or Mutation's declared error that reaches a Function which does not re-declare it,
+ * before the Server redacts it as an internal error: its code, the id of the Query or Mutation and
+ * the Function, never its details, which a read as the executor may fill with what the caller may
+ * not read.
+ */
+export declare function reportUndeclaredDefinedError(cause: unknown, address: string): void;

package/dist/execution/invocation/result/undeclared.js

@@ -0,0 +1,18 @@
+import { definedErrorOf } from '../../../application/error/index.js';
+/**
+ * Log a Query or Mutation's declared error that reaches a Function which does not re-declare it,
+ * before the Server redacts it as an internal error: its code, the id of the Query or Mutation and
+ * the Function, never its details, which a read as the executor may fill with what the caller may
+ * not read.
+ */
+export function reportUndeclaredDefinedError(cause, address) {
+    const raised = definedErrorOf(cause);
+    if (raised === undefined)
+        return;
+    // oxlint-disable-next-line no-console
+    console.error('[sdk] Query or Mutation error not re-declared by its Function', {
+        code: raised.code,
+        id: raised.id,
+        function: address,
+    });
+}

package/dist/execution/workflows/failure.d.ts

@@ -26,30 +26,30 @@ export declare class StepRetryAfter extends Error {
     constructor(delayMs: number, cause?: unknown);
 }
 /**
- * Encode what a Workflow did not catch as the Execution's failure: a Step's recipe failure ends it
- * with `STEP_EXHAUSTED`, naming the recipe and a `QueryError`'s code, never its details, which a
+ * Encode what a Workflow did not catch as the Execution's failure: a Step's Query failure ends it
+ * with `STEP_EXHAUSTED`, naming the Query and a `QueryError`'s code, never its details, which a
  * read as the executor may fill with what the Execution's reader may not read; an S12 refusal names
  * only Classes, so its message says what to declare. Anything else is encoded as
- * `terminalFailure` encodes it. Inside a Step, a recipe failure caught from an earlier Step and
+ * `terminalFailure` encodes it. Inside a Step, a Query failure caught from an earlier Step and
  * thrown again fails that Step, as `queryFailure` encodes it.
  */
 export declare function uncaughtFailure(engine: DurableEngine, cause: unknown, definition: object): Error | undefined;
 /**
- * Encode a declared business error of `definition`, a recipe's it re-declares included, or a Step
+ * Encode a declared business error of `definition`, a Query's it re-declares included, or a Step
  * that spent its retry budget, as a terminal engine failure, or return undefined for any other
  * error, which the engine retries.
  */
 export declare function terminalFailure(engine: DurableEngine, cause: unknown, definition: object): Error | undefined;
 /**
- * Encode a recipe's failure as the Step's terminal failure, or return undefined for any other
- * error. A read that met data it cannot answer, a query the Host cannot serve, or a recipe S12
+ * Encode a Query's failure as the Step's terminal failure, or return undefined for any other
+ * error. A read that met data it cannot answer, a document the Host cannot serve, or a Query S12
  * refuses is not retried. A refused read is a failed attempt as any Kernel refusal: retried,
  * unless the Kernel refused it for good.
  */
 export declare function queryFailure(engine: DurableEngine, cause: unknown): Error | undefined;
 /**
  * What a journaled Step failed with, as the Workflow sees it: its declared business error, rebuilt
- * through the definition's own factory, its recipe's `QueryError` or S12 refusal, or
+ * through the definition's own factory, its Query's `QueryError` or S12 refusal, or
  * `StepExhausted` once the engine spent its retry budget or the Step threw an exhaustion caught
  * from an earlier Step. A replay throws what the live run threw.
  */

package/dist/execution/workflows/failure.js

@@ -4,9 +4,9 @@ import { isQueryError, QueryError } from '../../application/query/execution/erro
 import { ResponseError } from '../../platform/client/index.js';
 /** Metadata key the Kernel reads a declared failure from (`backend/restate` outcome decoding). */
 const FAILURE = 'astrale.failure';
-/** Metadata key of a Step's recipe failure, which only the Workflow reads back. */
+/** Metadata key of a Step's Query failure, which only the Workflow reads back. */
 const QUERY_FAILURE = 'astrale.query';
-/** The Step each recipe failure the Workflow sees failed: uncaught, it ends the Execution. */
+/** The Step each Query failure the Workflow sees failed: uncaught, it ends the Execution. */
 const queryFailures = new WeakMap();
 /** Failure code of an Execution whose Workflow did not catch a Step that failed for good. */
 export const STEP_EXHAUSTED = 'STEP_EXHAUSTED';
@@ -91,11 +91,11 @@ const STATUS = {
     UNSUPPORTED: 422,
 };
 /**
- * Encode what a Workflow did not catch as the Execution's failure: a Step's recipe failure ends it
- * with `STEP_EXHAUSTED`, naming the recipe and a `QueryError`'s code, never its details, which a
+ * Encode what a Workflow did not catch as the Execution's failure: a Step's Query failure ends it
+ * with `STEP_EXHAUSTED`, naming the Query and a `QueryError`'s code, never its details, which a
  * read as the executor may fill with what the Execution's reader may not read; an S12 refusal names
  * only Classes, so its message says what to declare. Anything else is encoded as
- * `terminalFailure` encodes it. Inside a Step, a recipe failure caught from an earlier Step and
+ * `terminalFailure` encodes it. Inside a Step, a Query failure caught from an earlier Step and
  * thrown again fails that Step, as `queryFailure` encodes it.
  */
 export function uncaughtFailure(engine, cause, definition) {
@@ -105,17 +105,17 @@ export function uncaughtFailure(engine, cause, definition) {
     if (cause instanceof UndeclaredCrossing) {
         return stepFailure(engine, `Workflow Step ${step} failed: ${cause.message}`, {
             step,
-            query: { recipe: cause.recipe },
+            query: { id: cause.query },
         });
     }
-    const { code, recipe } = cause;
-    return stepFailure(engine, `Workflow Step ${step} failed: ${code} from ${recipe}.`, {
+    const { code, query } = cause;
+    return stepFailure(engine, `Workflow Step ${step} failed: ${code} from ${query}.`, {
         step,
-        query: { code, recipe },
+        query: { code, id: query },
     });
 }
 /**
- * Encode a declared business error of `definition`, a recipe's it re-declares included, or a Step
+ * Encode a declared business error of `definition`, a Query's it re-declares included, or a Step
  * that spent its retry budget, as a terminal engine failure, or return undefined for any other
  * error, which the engine retries.
  */
@@ -147,18 +147,18 @@ function stepFailure(engine, message, details) {
     });
 }
 /**
- * Encode a recipe's failure as the Step's terminal failure, or return undefined for any other
- * error. A read that met data it cannot answer, a query the Host cannot serve, or a recipe S12
+ * Encode a Query's failure as the Step's terminal failure, or return undefined for any other
+ * error. A read that met data it cannot answer, a document the Host cannot serve, or a Query S12
  * refuses is not retried. A refused read is a failed attempt as any Kernel refusal: retried,
  * unless the Kernel refused it for good.
  */
 export function queryFailure(engine, cause) {
     let failure;
     if (cause instanceof UndeclaredCrossing)
-        failure = { recipe: cause.recipe, message: cause.message };
+        failure = { query: cause.query, message: cause.message };
     else if (isQueryError(cause) && cause.code !== 'REFUSED') {
-        const { code, recipe, message, details } = cause;
-        failure = { code, recipe, message, details };
+        const { code, query, message, details } = cause;
+        failure = { code, query, message, details };
     }
     else
         return undefined;
@@ -168,7 +168,7 @@ export function queryFailure(engine, cause) {
 }
 /**
  * What a journaled Step failed with, as the Workflow sees it: its declared business error, rebuilt
- * through the definition's own factory, its recipe's `QueryError` or S12 refusal, or
+ * through the definition's own factory, its Query's `QueryError` or S12 refusal, or
  * `StepExhausted` once the engine spent its retry budget or the Step threw an exhaustion caught
  * from an earlier Step. A replay throws what the live run threw.
  */
@@ -180,10 +180,11 @@ export function replayedFailure(engine, cause, definition, step) {
     const query = metadata?.[QUERY_FAILURE];
     if (query !== undefined) {
         const failure = JSON.parse(query);
+        const id = (failure.query ?? failure.recipe);
         // Only a `QueryError` has a code.
         const error = failure.code === undefined
-            ? new UndeclaredCrossing(failure.recipe, failure.message)
-            : new QueryError(failure.code, failure.recipe, failure.details);
+            ? new UndeclaredCrossing(id, failure.message)
+            : new QueryError(failure.code, id, failure.details);
         error.message = failure.message;
         queryFailures.set(error, step);
         return error;

package/dist/execution/workflows/receiver.d.ts

@@ -18,7 +18,7 @@ export interface DurableReceiver {
 export declare function createDurableReceiver(input: {
     readonly workflows: readonly RuntimeWorkflow[];
     readonly domain: Domain;
-    /** The Class requirements the Domain's build declares, which a Step's recipe reads are checked against. */
+    /** The Class requirements the Domain's build declares, which a Step's Query reads are checked against. */
     readonly declared?: readonly DeclaredClass[];
     readonly identity: Identity;
     readonly serving: AdmittedDurableServing;

package/dist/execution/workflows/run.js

@@ -1,7 +1,7 @@
 import { declaredErrorFactory } from '../../application/error/index.js';
 import { acceptStepId } from '../../application/workflow/step/index.js';
 import { acceptStepOutput } from '../../application/workflow/step/output.js';
-import { reportUndeclaredRecipeError, validateOutput } from '../invocation/result/index.js';
+import { reportUndeclaredDefinedError, validateOutput } from '../invocation/result/index.js';
 import { BACKOFF, UNAVAILABLE, failedAttemptError, failedAttemptOf, nextAttempt, } from './attempts.js';
 import { decodeEnvelope } from './envelope.js';
 import { queryFailure, replayedFailure, StepExhausted, StepRetryAfter, terminalFailure, uncaughtFailure, } from './failure.js';
@@ -134,7 +134,7 @@ function durableContext(input, context, envelope) {
                 if (terminal !== undefined)
                     throw terminal;
                 // Retried as any failed attempt, and logged: the Workflow does not re-declare it.
-                reportUndeclaredRecipeError(cause, workflow.address);
+                reportUndeclaredDefinedError(cause, workflow.address);
                 throw failedAttemptError(engine, cause, startedAt, now(), step?.repeatsEffects() ?? false);
             }
             finally {

package/dist/execution/workflows/steps.d.ts

@@ -30,7 +30,7 @@ export type StepAuthorities = (attempt: StepAttempt) => StepAuthorityBinding;
 export declare function sessionSteps(input: {
     readonly executor: Executor;
     readonly domain: Domain;
-    /** The Class requirements the Domain's build declares: a recipe's reads are checked against them. */
+    /** The Class requirements the Domain's build declares: a Query's reads are checked against them. */
     readonly declared: readonly DeclaredClass[];
     readonly integrations: IntegrationClientFactory<Integrations>;
 }): StepAuthorities;

package/dist/platform/schema/class-authoring.d.ts

@@ -1,4 +1,4 @@
-import { edgeClass as kernelEdgeClass, nodeClass as kernelNodeClass, type DirectedEdgeClass, type DirectedEdgeInput, type Lazy, type NodeClass, type NodeClassInput as KernelNodeClassInput, type NodeClassPolicyInput, type Policy, type UndirectedEdgeClass, type UndirectedEdgeInput } from '@astrale-os/kernel-dsl/v1/builder';
+import { edgeClass as kernelEdgeClass, nodeClass as kernelNodeClass, type DirectedEdgeClass, type DirectedEdgeInput, type Lazy, type NodeClass, type NodeClassInput as KernelNodeClassInput, type NodeClassPolicyInput as NodeClassReadRule, type Policy, type UndirectedEdgeClass, type UndirectedEdgeInput } from '@astrale-os/kernel-dsl/v1/builder';
 import { type ClassIcon } from './class-icon.js';
 /**
  * SDK Node Class input: every author must make an explicit, admitted icon choice, and every
@@ -9,12 +9,7 @@ export type NodeClassInput = Omit<KernelNodeClassInput, 'icon'> & {
 };
 /** Who may read or traverse an Edge Class: a named Policy, or the constant `true` or `false`. */
 export type ClassReadRule = Lazy<Policy> | boolean;
-/**
- * Who may read or traverse a Node Class: a named Policy, the constant `true` or `false`, or Policy
- * checks over the observed Node (`self`) and fixed members (`ref(...)`), composed as the checks of
- * an authorized callable.
- */
-export type NodeClassReadRule = NodeClassPolicyInput;
+export type { NodeClassReadRule };
 /**
  * The observation rules of a concrete Class. A Node stays traversable through either rule, so a
  * read rule other than `true` leaves every caller able to reach it, and to select its reference,
@@ -84,4 +79,3 @@ export declare const edgeClass: Readonly<{
 export declare function defineClass(config: NodeInput): NodeClass;
 export declare function defineClass(config: DirectedInput): DirectedEdgeClass;
 export declare function defineClass(config: UndirectedInput): UndirectedEdgeClass;
-export {};

package/dist/platform/schema/index.d.ts

@@ -18,7 +18,7 @@ export type { ClassIcon } from './class-icon.js';
 export type { StoredPropertyInputOf } from './property-input.js';
 export type { CallablePolicyBuilder, CallablePolicyContext, ClassRuleBuilder, ClassRuleContext, PolicyCheckContext, CallableProjection, AuthoredMethodProjection, AuthoredPropertyProjection, ClassIdentityProjection, ClassOwnerProjection, CoreEdge, CoreEndpoint, CoreNode, DefinedSchema, DirectedEdgeClass, ClassReferenceProjection, ClassProjection, FunctionProjection, EdgeClass, Function, Method, MethodProjection, Lazy, NodeClass, Policy, PolicyExistsContext, PolicyNodeBinder, PolicyPatternContext, Property, PropertyProjection, ResolvedDomainOfInput, View, } from '@astrale-os/kernel-dsl/v1/builder';
 export type { Array, Object, Value } from '@astrale-os/kernel-dsl/value';
-export type { CallableAdmission, CallableExecution, ClassKind, DirectedEdgeContract, EdgeClassPolicies, NodeClassDefinition, PolicyCheckObject, PolicyObjectRef, PropertyFacet, PropertyImmutability, StateTopology, UndirectedEdgeContract, } from '@astrale-os/kernel-dsl/v1/language';
+export type { CallableAdmission, CallableExecution, ClassKind, DirectedEdgeContract, EdgeClassPolicies, EdgePropertyDefinition, NodeClassDefinition, PolicyCheckObject, PolicyObjectRef, PropertyFacet, PropertyImmutability, ResolvedPropertyCollection, StateTopology, UndirectedEdgeContract, } from '@astrale-os/kernel-dsl/v1/language';
 export type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */
 export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';

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.24, reduced to its Classes. Regenerate with pnpm sync:kernel-schema. */
+/** Generated from the Kernel Schema of @astrale-os/kernel-core 1.0.0-beta.26, reduced to its Classes. Regenerate with pnpm sync:kernel-schema. */
 export declare const kernelCompiledSchema: string;