@astrale-os/sdk 0.6.0-beta.7 → 0.6.0-beta.9

package/dist/application/action/authoring.d.ts

@@ -1,5 +1,5 @@
 export { defineAction } from './define.js';
 export type { Action, ActionDefinition } from './action.js';
-export type { ActionContext, ActionExecution, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, } from './context.js';
+export type { ActionContext, ActionBinaryInput, ActionExecution, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, } from './context.js';
 export type { ActionBinary, ActionOutputOf } from './output.js';
 export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/action/context.d.ts

@@ -1,7 +1,7 @@
 import type { AuthenticationEvidence, Grant, IdentityId } from '../../platform/auth/index.js';
 import type { BoundClientSession } from '../../platform/client/session/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
-import type { CallableInputOf, Domain, ResolvedFunction, ResolvedMethod } from '../../platform/schema/index.js';
+import type { CallableInputOf, CallableInputModeOf, Domain, ResolvedFunction, ResolvedMethod } from '../../platform/schema/index.js';
 import type { HandlerDependencies } from '../dependency/index.js';
 import type { DeclaredErrorFactory, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { IntegrationClients, Integrations } from '../integration/index.js';
@@ -34,6 +34,16 @@ export interface ActionExecution {
         body(): Uint8Array;
     };
 }
+/** One admitted, single-consumer binary Function request body. */
+export interface ActionBinaryInput {
+    readonly body: ReadableStream<Uint8Array>;
+    readonly length: number;
+}
+type BinaryInputOf<Callable> = CallableInputModeOf<Callable> extends 'binary' ? {
+    readonly body: ActionBinaryInput;
+} : {
+    readonly body?: never;
+};
 export interface DomainGraphExecutor<DomainValue extends Domain = Domain> {
     readonly query: QueryExecutor<DomainValue>;
     readonly mutate: MutationExecutor<DomainValue>;
@@ -83,5 +93,5 @@ export type ActionContext<Callable extends ResolvedCallable, DomainValue extends
     readonly execution: ActionExecution;
     /** Construct one implementation-declared safe business error for `throw error(...)`. */
     readonly error: DeclaredErrorFactory<Errors>;
-} & AuthorityOf<Callable, DomainValue> & SelfOf<Callable>;
+} & AuthorityOf<Callable, DomainValue> & SelfOf<Callable> & BinaryInputOf<Callable>;
 export {};

package/dist/application/action/index.d.ts

@@ -1,5 +1,5 @@
 export { defineAction, isAction } from './define.js';
 export type { Action, ActionAddress, ActionAddressOf, ActionDefinition, CallableAtAddress, LocalCallable, ResolvedDomainOf, } from './action.js';
-export type { ActionContext, ActionExecution, AnonymousCaller, AuthenticatedCaller, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, ResolvedCallable, } from './context.js';
+export type { ActionContext, ActionBinaryInput, ActionExecution, AnonymousCaller, AuthenticatedCaller, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, ResolvedCallable, } from './context.js';
 export type { ActionBinary, ActionOutputOf } from './output.js';
 export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/dependency/index.d.ts

@@ -1 +1 @@
-export type { DependencyCallOptions, DependencyInvoker, HandlerDependencies } from './invoker.js';
+export type { DependencyBinaryCallOptions, DependencyCallOptions, DependencyInvoker, HandlerDependencies, } from './invoker.js';

package/dist/application/dependency/invoker.d.ts

@@ -1,18 +1,23 @@
 import type { Binary, Input } from '../../platform/client/index.js';
-import type { SessionRequestOptions } from '../../platform/client/session/index.js';
+import type { SessionRequestOptions, SessionRequestOptionsWithBody } from '../../platform/client/session/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
-import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, ResolvedMethod, KernelSchema, schema } from '../../platform/schema/index.js';
+import type { CallableInputOf, CallableInputModeOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ResolvedMethod, KernelSchema, schema } from '../../platform/schema/index.js';
 import type { LocalCallable } from '../action/index.js';
-export type DependencyCallOptions = Pick<SessionRequestOptions, 'timeoutMs' | 'idempotencyKey'>;
+export type DependencyCallOptions = Pick<SessionRequestOptions, 'timeoutMs' | 'idempotencyKey' | 'body'>;
+export type DependencyBinaryCallOptions = Pick<SessionRequestOptionsWithBody, 'timeoutMs' | 'idempotencyKey' | 'body'>;
 type InstanceMethodOf<D extends Domain> = Extract<LocalCallable<D>, ResolvedMethod<unknown, unknown, false>>;
 type FunctionOrStaticMethodOf<D extends Domain> = Exclude<LocalCallable<D>, ResolvedMethod<unknown, unknown, false>>;
+type WithInputMode<C, Mode extends 'value' | 'binary'> = C extends unknown ? CallableInputModeOf<C> extends Mode ? C : never : never;
+type ValueFunctionOrStaticMethodOf<D extends Domain> = WithInputMode<FunctionOrStaticMethodOf<D>, 'value'>;
+type BinaryFunctionOf<D extends Domain> = WithInputMode<Extract<LocalCallable<D>, ResolvedFunction>, 'binary'>;
 type DependencyInputOf<C> = C extends unknown ? unknown extends CallableInputOf<C> ? Input : [CallableInputOf<C>] extends [void] ? undefined : CallableInputOf<C> : never;
 type DependencyResultOf<C> = unknown extends CallableOutputOf<C> ? unknown : CallableResultOf<C, Binary>;
 /** One declared dependency, bound to one explicitly selected invocation authority. */
 export interface DependencyInvoker<D extends Domain> {
     readonly invoke: {
-        <const C extends FunctionOrStaticMethodOf<D>>(select: (domain: D) => C, input: NoInfer<DependencyInputOf<C>>, options?: DependencyCallOptions): Promise<DependencyResultOf<C>>;
+        <const C extends ValueFunctionOrStaticMethodOf<D>>(select: (domain: D) => C, input: NoInfer<DependencyInputOf<C>>, options?: DependencyCallOptions): Promise<DependencyResultOf<C>>;
         <const C extends InstanceMethodOf<D>>(select: (domain: D) => C, instance: NodeId, input: NoInfer<DependencyInputOf<C>>, options?: DependencyCallOptions): Promise<DependencyResultOf<C>>;
+        <const C extends BinaryFunctionOf<D>>(select: (domain: D) => C, metadata: NoInfer<DependencyInputOf<C>>, options: DependencyBinaryCallOptions): Promise<DependencyResultOf<C>>;
     };
 }
 /**

package/dist/application/mutation/authoring/properties.d.ts

@@ -1,9 +1,11 @@
 import type { MutationPropsInput } from '@astrale-os/kernel-core/graph/mutate';
 import type { PropertyInputOf, ResolvedClass, ResolvedProperty } from '@astrale-os/kernel-dsl/v1';
+import { PropertyValues } from '@astrale-os/kernel-dsl/v1/language';
+import type { StoredPropertyInputOf } from '../../../platform/schema/property-input.js';
 export type RichPropertyInput<Class> = PropertyInputOf<Class>;
 export type RichPropertyName<Class> = Extract<keyof PropertyInputOf<Class>, string>;
 export interface RichPropertyConditions<Class> {
-    readonly equals?: RichPropertyInput<Class>;
+    readonly equals?: StoredPropertyInputOf<Class>;
     readonly absent?: readonly RichPropertyName<Class>[];
 }
 export interface RichPropertyDelta<Class> {
@@ -12,11 +14,11 @@ export interface RichPropertyDelta<Class> {
 }
 export declare function properties<Class extends ResolvedClass>(selected: Class, input: RichPropertyInput<Class>): MutationPropsInput;
 export declare function conditions<Class extends ResolvedClass>(selected: Class, input: RichPropertyConditions<Class>): Readonly<{
-    equals?: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>> | undefined;
+    equals?: PropertyValues | undefined;
     absent?: readonly `${string}:class.${string}.property.${string}`[] | undefined;
 }>;
 export declare function delta<Class extends ResolvedClass>(selected: Class, input: RichPropertyDelta<Class>): Readonly<{
-    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>>;
+    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/v1/language").PropertyValue>>;
     unset: readonly `${string}:class.${string}.property.${string}`[];
 }>;
 export declare function resolvedProperty<Class extends ResolvedClass>(selected: Class, name: RichPropertyName<Class>): ResolvedProperty;

package/dist/application/mutation/authoring/properties.js

@@ -1,10 +1,39 @@
 import { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { PropertyValues } from '@astrale-os/kernel-dsl/v1/language';
 export function properties(selected, input) {
-    return selected.properties.from(input);
+    const ordinary = Object.create(null);
+    const receipts = [];
+    const sources = new Map();
+    for (const [name, value] of Object.entries(input)) {
+        const property = resolvedProperty(selected, name);
+        const previous = sources.get(property.key);
+        if (previous !== undefined) {
+            throw new TypeError(`Property ${property.key} is supplied through both ${JSON.stringify(previous)} and ${JSON.stringify(name)}.`);
+        }
+        sources.set(property.key, name);
+        if (isBlobProperty(property)) {
+            if (typeof value !== 'string') {
+                throw new TypeError(`Blob Property ${property.key} requires an upload receipt.`);
+            }
+            receipts.push([property.key, value]);
+        }
+        else {
+            ordinary[name] = value;
+        }
+    }
+    // Blob receipts are admitted by the Kernel executor. A property's ordinary validator expects
+    // the stored Ref, so run it only for ordinary write values before combining the two sets.
+    const admitted = selected.properties.from(ordinary);
+    return receipts.length === 0
+        ? admitted
+        : PropertyValues.create([
+            ...Object.entries(admitted).map(([key, value]) => [PropertyKey(key), value]),
+            ...receipts,
+        ]);
 }
 export function conditions(selected, input) {
     return Object.freeze({
-        ...(input.equals === undefined ? {} : { equals: properties(selected, input.equals) }),
+        ...(input.equals === undefined ? {} : { equals: selected.properties.from(input.equals) }),
         ...(input.absent === undefined
             ? {}
             : {
@@ -12,6 +41,10 @@ export function conditions(selected, input) {
             }),
     });
 }
+function isBlobProperty(property) {
+    const contract = property.definition.schema;
+    return (contract !== null && typeof contract === 'object' && contract['x-astrale-value-kind'] === 'blob');
+}
 export function delta(selected, input) {
     return Object.freeze({
         set: properties(selected, input.set ?? {}),

package/dist/application/mutation/authoring/transition.js

@@ -49,7 +49,10 @@ export function authorStateTransition(core, input) {
         class: selectedClassKey,
         props: conditions(selectedClass, {
             ...(suppliedAbsent === undefined ? {} : { absent: suppliedAbsent }),
-            equals: { ...suppliedEquals, ...from },
+            equals: {
+                ...suppliedEquals,
+                ...from,
+            },
         }),
     });
     core.updateNode({

package/dist/execution/invocation/admission/input.d.ts

@@ -1,2 +1,2 @@
-import type { ResolvedCallable } from '../../../application/action/index.js';
-export declare function input(callable: ResolvedCallable, value: unknown): void;
+import type { ResolvedCallable, ActionBinaryInput } from '../../../application/action/index.js';
+export declare function input(callable: ResolvedCallable, value: unknown, binary?: ActionBinaryInput): void;

package/dist/execution/invocation/admission/input.js

@@ -1,4 +1,18 @@
-import { validateInput } from '../result/index.js';
-export function input(callable, value) {
+import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
+import { validateInput, protocolError } from '../result/index.js';
+export function input(callable, value, binary) {
+    if (isBinaryInput(callable.input)) {
+        if (binary === undefined) {
+            throw protocolError('VALIDATION_ERROR', 'Binary Function request body is required.');
+        }
+        if (!Number.isSafeInteger(binary.length) ||
+            binary.length < 0 ||
+            binary.length > callable.input.maximumBytes) {
+            throw protocolError('LIMIT_EXCEEDED', 'Binary Function request body exceeds its limit.');
+        }
+    }
+    else if (binary !== undefined) {
+        throw protocolError('VALIDATION_ERROR', 'Callable does not accept a binary request body.');
+    }
     validateInput(callable, value);
 }

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

@@ -1,4 +1,5 @@
 import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
 import { reference } from '../../../platform/client/session/index.js';
 import { NodeId } from '../../../platform/graph/node/index.js';
 import { Path } from '../../../platform/graph/path/index.js';
@@ -20,19 +21,14 @@ function bindDependency(dependency, session) {
     const invoke = session.invoke.bind(session);
     return Object.freeze({
         async invoke(select, ...args) {
-            if (typeof select !== 'function')
-                invalid();
-            const selected = select(dependency);
-            if (selected === null ||
-                typeof selected !== 'object' ||
-                !('key' in selected) ||
-                typeof selected.key !== 'string')
-                invalid();
-            const callable = dependency.callable(selected.key);
-            if (callable !== selected || Key.origin(callable.key) !== dependency.origin)
-                invalid();
-            if ('owner' in callable && (!callable.executable || !ownMethod(dependency, callable)))
-                invalid();
+            const callable = selectedCallable(dependency, select);
+            if (isBinaryInput(callable.input)) {
+                if ('owner' in callable || args.length !== 2)
+                    invalid();
+                // Runtime selection is wider than the authored Function; mode was checked above.
+                const binaryReference = reference(dependency, callable);
+                return invoke(binaryReference, args[0], binaryOptions(args[1]));
+            }
             if ('owner' in callable && !callable.static) {
                 if (args.length < 2 || args.length > 3 || typeof args[0] !== 'string')
                     invalid();
@@ -45,6 +41,22 @@ function bindDependency(dependency, session) {
         },
     });
 }
+function selectedCallable(domain, select) {
+    if (typeof select !== 'function')
+        invalid();
+    const selected = select(domain);
+    if (selected === null ||
+        typeof selected !== 'object' ||
+        !('key' in selected) ||
+        typeof selected.key !== 'string')
+        invalid();
+    const callable = domain.callable(selected.key);
+    if (callable !== selected || Key.origin(callable.key) !== domain.origin)
+        invalid();
+    if ('owner' in callable && (!callable.executable || !ownMethod(domain, callable)))
+        invalid();
+    return callable;
+}
 function ownMethod(domain, callable) {
     const owner = Object.values(domain.classes).find((value) => value === callable.owner);
     if (owner === undefined)
@@ -63,6 +75,16 @@ function options(value) {
     // Canonical ClientSession admits option values and clamps them to the parent lifetime.
     return value;
 }
+function binaryOptions(value) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        !Object.hasOwn(value, 'body') ||
+        !(value.body instanceof Blob) ||
+        Reflect.ownKeys(value).some((key) => key !== 'body' && key !== 'timeoutMs'))
+        invalid();
+    return value;
+}
 function invalid() {
     throw new TypeError('Dependency invocation requires one owned executable callable, its input, and valid instance/options.');
 }

package/dist/execution/invocation/dispatch/context.d.ts

@@ -1,5 +1,5 @@
 import type { HandlerRequest } from '@astrale-os/kernel-server';
-import type { ActionExecution, Caller, DomainGraphExecutors, DomainKernelSessions } from '../../../application/action/index.js';
+import type { ActionExecution, ActionBinaryInput, Caller, DomainGraphExecutors, DomainKernelSessions } from '../../../application/action/index.js';
 import type { HandlerDependencies } from '../../../application/dependency/index.js';
 import type { MutationExecutor } from '../../../application/mutation/index.js';
 import type { QueryExecutor } from '../../../application/query/index.js';
@@ -10,6 +10,7 @@ import type { InvocationAuthentication } from '../admission/index.js';
 export interface DispatchContext {
     readonly domain: Domain;
     readonly input: unknown;
+    readonly body?: ActionBinaryInput;
     readonly caller: Caller;
     readonly dependencies: HandlerDependencies<Domain> | null;
     readonly kernel: DomainKernelSessions | null;

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

@@ -17,6 +17,7 @@ export function context(request, runtime, authentication, self) {
     return Object.freeze({
         domain: runtime.loaded.domain,
         input: request.call.input,
+        ...(request.context.binary === undefined ? {} : { body: request.context.binary }),
         caller: authentication.caller,
         kernel: authentication.graph === null
             ? null

package/dist/execution/invocation/invocation.js

@@ -26,11 +26,11 @@ export async function invoke(request, inputConfig) {
     const selected = select(inputConfig.runtime.loaded.registry, selectedTarget);
     if (selected === undefined)
         return Object.freeze({ kind: 'miss' });
-    input(selected.implementation.callable, request.call.input);
+    input(selected.implementation.callable, request.call.input, request.context.binary);
     const admittedAuthentication = await authentication(selected.implementation.callable, request, release, inputConfig.runtime.loaded.domain, inputConfig.authority);
     const close = once(admittedAuthentication.close);
-    active(request.context);
     try {
+        active(request.context);
         const dispatchContext = context(request, inputConfig.runtime, admittedAuthentication, selected.self);
         const output = selected.implementation.kind === 'action'
             ? await action(selected.implementation, dispatchContext)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.6.0-beta.7",
+  "version": "0.6.0-beta.9",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -237,11 +237,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/kernel-client": "0.6.0-beta.78",
-    "@astrale-os/kernel-core": "0.9.0-beta.58",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.42",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.64",
-    "@astrale-os/kernel-server": "0.5.0-beta.66",
+    "@astrale-os/kernel-client": "0.6.0-beta.82",
+    "@astrale-os/kernel-core": "0.9.0-beta.61",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.43",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.67",
+    "@astrale-os/kernel-server": "0.5.0-beta.69",
     "@lucide/icons": "1.34.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "cross-spawn": "7.0.6",