@astrale-os/kernel-dsl 0.2.0-beta.39 → 0.2.0-beta.40

package/dist/v1/builder/callable/authoring.d.ts

@@ -1,6 +1,6 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
-import type { FunctionAuth } from '../../language/callable/model/callable.js';
+import type { BinaryInputProjection, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { Class } from '../class/authoring.js';
 import type { ValueSchemaInput } from '../class/property.js';
@@ -11,6 +11,7 @@ import type { TypedValueSchema } from '../value/schema.js';
 import type { View } from '../view/authoring.js';
 import { type AUTHORING } from '../schema/handle.js';
 declare const CALLABLE_OUTPUT: unique symbol;
+declare const CALLABLE_INPUT: unique symbol;
 declare const CALLABLE_PROJECTION: unique symbol;
 declare const CALLABLE_PROJECTION_VALUE: unique symbol;
 export interface CallablePolicyContext {
@@ -39,12 +40,19 @@ export interface BinaryOutput {
     readonly [CALLABLE_OUTPUT]: true;
 }
 export type CallableOutputInput = ValueSchemaInput | StreamOutput | BinaryOutput;
-export interface CallableInputBase {
+export interface BinaryInputAuthoring<out Metadata extends ValueSchemaInput = ValueSchemaInput> {
+    readonly mode: 'binary';
+    readonly metadata: Metadata;
+    readonly maximumBytes: number;
+    readonly [CALLABLE_INPUT]: true;
+}
+export type FunctionInputSchema = ValueSchemaInput | BinaryInputAuthoring;
+export interface CallableInputBase<Input extends FunctionInputSchema = ValueSchemaInput> {
     readonly description?: string;
-    readonly input: ValueSchemaInput;
+    readonly input: Input;
     readonly output: CallableOutputInput;
 }
-type ConcreteCallableInput = CallableInputBase & ({
+type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
     readonly policy?: never;
 } | {
@@ -54,7 +62,7 @@ type ConcreteCallableInput = CallableInputBase & ({
     readonly auth: 'authorized';
     readonly policy?: CallablePolicyBuilder;
 });
-export type FunctionInput = ConcreteCallableInput & {
+export type FunctionInput = ConcreteCallableInput<FunctionInputSchema> & {
     readonly static?: never;
     readonly abstract?: never;
 };
@@ -73,6 +81,7 @@ export interface CallableProjection<out Input = unknown, out Output = unknown, o
     readonly abstract: Abstract;
 }
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type FunctionInputOf<Schema> = Schema extends BinaryInputAuthoring<infer Metadata> ? BinaryInputProjection<ValueInputOf<Metadata>> : ValueInputOf<Schema>;
 type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
 type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
@@ -96,7 +105,7 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 export type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
-export declare function func<const Config extends FunctionInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false>>;
+export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false>>;
 export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
     readonly static: true;
 } ? true : false, Abstract extends boolean = Config extends {
@@ -117,5 +126,12 @@ export declare const output: {
     readonly stream: <const Item extends ValueSchemaInput>(item: Item) => StreamOutput<Item>;
     readonly binary: () => BinaryOutput;
 };
+/** Explicit binary Function input. Plain schemas remain value inputs. */
+export declare const input: {
+    readonly binary: <const Metadata extends ValueSchemaInput>(metadata: Metadata, options: {
+        readonly maximumBytes: number;
+    }) => BinaryInputAuthoring<Metadata>;
+};
+export declare function isBinaryInputAuthoring(value: FunctionInputSchema): value is BinaryInputAuthoring;
 export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
 export {};

package/dist/v1/builder/callable/authoring.js

@@ -62,6 +62,19 @@ export const output = Object.freeze({
         });
     },
 });
+/** Explicit binary Function input. Plain schemas remain value inputs. */
+export const input = Object.freeze({
+    binary(metadata, options) {
+        return authoringValue('callable-input', {
+            mode: 'binary',
+            metadata,
+            maximumBytes: options.maximumBytes,
+        });
+    },
+});
+export function isBinaryInputAuthoring(value) {
+    return isAuthoringValue(value, 'callable-input');
+}
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }

package/dist/v1/builder/class/authoring.d.ts

@@ -7,6 +7,7 @@ import type { MediaType } from '../../language/class/model/data.js';
 import type { EdgeCount } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
+import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
 import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
@@ -106,8 +107,8 @@ export interface AuthoredMethodProjection<out Value extends Method = Method, out
 }
 type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
 type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
-type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
-type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type ValueOutputOf<Schema> = Schema extends BlobSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
@@ -228,11 +229,12 @@ type UndirectedEdgeClassIdentity<Config> = Config extends {
     readonly endpoints: Endpoints;
     readonly constraints: Constraints;
 } : never;
-type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, unknown, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown, State> : Entry extends ResolvedProperty<infer Value, infer Required, infer State> & {
+type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, unknown, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown, State> : Entry extends ResolvedProperty<infer Value, infer Required, infer State, infer Input> & {
     readonly name: infer Name;
     readonly key: infer Key;
 } ? {
     readonly value: Value;
+    readonly input: Input;
     readonly required: Required;
     readonly name: Name;
     readonly key: Key;

package/dist/v1/builder/index.d.ts

@@ -1,4 +1,4 @@
-export { func, method, output } from './callable/authoring.js';
+export { func, input, method, output } from './callable/authoring.js';
 export { core } from './core/authoring.js';
 export { defineClass, edgeClass, nodeClass } from './class/authoring.js';
 export { fullMatch } from './value/full-match.js';
@@ -12,7 +12,7 @@ export { valueSchema } from './value/schema.js';
 export { view } from './view/authoring.js';
 export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
-export type { CallableInputBase, CallableInput, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
+export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
 export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
 export type { PathAuthoring } from './value/path.js';

package/dist/v1/builder/index.js

@@ -1,4 +1,4 @@
-export { func, method, output } from './callable/authoring.js';
+export { func, input, method, output } from './callable/authoring.js';
 export { core } from './core/authoring.js';
 export { defineClass, edgeClass, nodeClass } from './class/authoring.js';
 export { fullMatch } from './value/full-match.js';

package/dist/v1/builder/lowering/callable.js

@@ -1,5 +1,5 @@
 import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
-import { callableInputField, callableConfiguration, callablePolicyObject, callableRef, callableSelf, isCallableOutputAuthoring, } from '../callable/authoring.js';
+import { callableInputField, callableConfiguration, callablePolicyObject, callableRef, callableSelf, isBinaryInputAuthoring, isCallableOutputAuthoring, } from '../callable/authoring.js';
 import { fail } from '../schema/diagnostic.js';
 export class V1CallableCompiler {
     context;
@@ -25,11 +25,19 @@ export class V1CallableCompiler {
         }
         const isStatic = method ? (config.static ?? false) : undefined;
         const isAbstract = method ? (config.abstract ?? false) : undefined;
-        const input = this.values.schema(config.input, 'callable-input', `${placement.pointer}/input`);
+        const binaryInput = isBinaryInputAuthoring(config.input) ? config.input : undefined;
+        if (method && binaryInput !== undefined) {
+            fail('BUILDER_CALLABLE_PLACEMENT', `${placement.pointer}/input`, 'Methods require Value input.');
+        }
+        const metadata = isBinaryInputAuthoring(config.input) ? config.input.metadata : config.input;
+        const inputSchema = this.values.schema(metadata, 'callable-input', binaryInput ? `${placement.pointer}/input/metadata` : `${placement.pointer}/input`);
+        const input = binaryInput
+            ? { mode: 'binary', metadata: inputSchema, maximumBytes: binaryInput.maximumBytes }
+            : inputSchema;
         const output = this.compileOutput(config.output, `${placement.pointer}/output`);
         const policy = config.policy === undefined
             ? undefined
-            : normalizePolicyChecks(config.policy(this.policyContext(input, placement, isStatic ?? false)));
+            : normalizePolicyChecks(config.policy(this.policyContext(inputSchema, placement, isStatic ?? false)));
         const base = {
             ...(config.description === undefined ? {} : { description: config.description }),
             input,
@@ -38,10 +46,15 @@ export class V1CallableCompiler {
         const contract = auth === 'authorized'
             ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }
             : { ...base, auth };
-        if (!method)
-            return { ref: placement.ref, ...contract };
+        if (!method) {
+            return {
+                ref: placement.ref,
+                ...contract,
+            };
+        }
         return {
             ...contract,
+            input: inputSchema,
             static: isStatic,
             abstract: isAbstract,
         };

package/dist/v1/builder/schema/handle.d.ts

@@ -1,5 +1,5 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
+export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-input' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
 export interface AuthoringValue<Kind extends AuthoringKind> {
     readonly [AUTHORING]: Kind;
 }

package/dist/v1/builder/schema/projection.d.ts

@@ -2,16 +2,18 @@ import type { Revision } from '../../addressing/index.js';
 import type * as domain from '../../domain/model/domain.js';
 import type * as language from '../../language/index.js';
 import type { StateTopology } from '../../language/state/index.js';
+import type { BlobReceipt } from '../../language/value/model/blob.js';
 import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
 import type { CallableProjection, Function, Method } from '../callable/authoring.js';
 import type { AuthoredPropertyProjection, Class, ClassIdentityProjection, ClassIdentityProjectionOf, ClassOwnerProjection, ClassOwnerProjectionOf, ClassReferenceProjection, ClassReferenceProjectionOf, DirectedEdgeClass, NodeClass, ProjectionOfClass, UndirectedEdgeClass } from '../class/authoring.js';
 import type { DomainSchemaInput } from './input.js';
-export interface PropertyProjection<Value = unknown, Required extends boolean = boolean, Name extends string = string, Key extends language.PropertyKey = language.PropertyKey, State extends StateTopology | undefined = StateTopology | undefined> {
+export interface PropertyProjection<Value = unknown, Required extends boolean = boolean, Name extends string = string, Key extends language.PropertyKey = language.PropertyKey, State extends StateTopology | undefined = StateTopology | undefined, Input = Value> {
     readonly value: Value;
     readonly required: Required;
     readonly name: Name;
     readonly key: Key;
     readonly state?: State;
+    readonly input: Input;
 }
 type MethodExecutableOf<OwnerAbstract extends boolean, MethodAbstract extends boolean> = MethodAbstract extends false ? true : OwnerAbstract extends false ? true : false;
 export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Abstract extends boolean = boolean, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey, Executable extends boolean = boolean> {
@@ -214,6 +216,7 @@ type EffectivePropertyProjectionsOfClass<Value extends Class> = ClassInputOf<Val
 } ? Properties : never;
 type AuthoredProjectionName<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, boolean, infer Name> ? Name : never;
 type AuthoredProjectionInput<Entry> = Entry extends AuthoredPropertyProjection<infer Input, unknown, boolean, string> ? Input : never;
+type CoreProjectionInput<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, boolean, string> ? Input extends BlobReceipt ? Output : Input : never;
 type AuthoredProjectionRequired<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, infer Required, string> ? Required : false;
 type UniqueAuthoredProjections<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
     readonly name: AuthoredProjectionName<Entries>;
@@ -223,11 +226,11 @@ type RequiredAuthoredPropertyNames<Entries> = CoreAuthoredProjections<Entries> e
 type OptionalAuthoredPropertyNames<Entries> = Exclude<AuthoredProjectionName<CoreAuthoredProjections<Entries>>, RequiredAuthoredPropertyNames<Entries>>;
 type AutomaticAuthoredPropertyNames<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? [AuthoredProjectionInput<Entry>] extends [never] ? AuthoredProjectionName<Entry> : never : never : never;
 type CorePropertyInputFromAuthoredProjections<Entries> = Readonly<{
-    [Name in RequiredAuthoredPropertyNames<Entries>]: AuthoredProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
+    [Name in RequiredAuthoredPropertyNames<Entries>]: CoreProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
         readonly name: Name;
     }>>;
 } & {
-    [Name in OptionalAuthoredPropertyNames<Entries>]?: AuthoredProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
+    [Name in OptionalAuthoredPropertyNames<Entries>]?: CoreProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
         readonly name: Name;
     }>>;
 } & {
@@ -260,10 +263,10 @@ type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['au
 type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>> : never;
 type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
 type MethodCollectionOperation = 'byKey' | 'get';
-type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required, infer State> & {
+type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required, infer State, infer Input> & {
     readonly name: infer Name extends string;
     readonly key: infer Key extends language.PropertyKey;
-} ? PropertyProjection<PropertyValue, Required, Name, Key, State> : never;
+} ? PropertyProjection<PropertyValue, Required, Name, Key, State, Input> : never;
 type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
     readonly name: infer Name extends string;
 } ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable']> : never;
@@ -292,12 +295,12 @@ type ShallowClassProjectionTupleOfResolved<Parents extends readonly unknown[]> =
 type ExactClass<Value> = Value extends {
     readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
 } ? Key extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? never : string extends Name ? never : Value : never : never;
-type OwnPropertyProjectionsOf<Origin extends string, Name extends string, Value> = OwnPropertyEntries<Value> extends infer Entry ? Entry extends AuthoredPropertyEntry<unknown, infer PropertyName, infer Field> ? Field extends AuthoredPropertyProjection<unknown, infer Output, infer Required, string, unknown, infer State> ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, Name, PropertyName>, State> : never : never : never;
+type OwnPropertyProjectionsOf<Origin extends string, Name extends string, Value> = OwnPropertyEntries<Value> extends infer Entry ? Entry extends AuthoredPropertyEntry<unknown, infer PropertyName, infer Field> ? Field extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, string, unknown, infer State> ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, Name, PropertyName>, State, Input> : never : never : never;
 type EffectivePropertyEntriesOfClass<Value> = ClassInputOf<Value> extends {
     readonly effectiveProperties: infer Properties;
 } ? Properties : never;
 type OwnerNameOf<Root extends DomainSchemaInput, CurrentName extends string, Owner> = Owner extends 'self' ? CurrentName : Owner extends ClassOwnerProjection ? Extract<LocalNameOfOwner<Root, Owner>, string> : Owner extends ClassIdentityProjection ? Extract<LocalNameOfIdentity<Root, Owner>, string> : never;
-type EffectivePropertyProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedProperty ? PropertyProjectionOfResolved<Entry> : Entry extends AuthoredPropertyProjection<unknown, infer Output, infer Required, infer PropertyName, infer Owner, infer State> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, OwnerName, PropertyName>, State> : never : never;
+type EffectivePropertyProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedProperty ? PropertyProjectionOfResolved<Entry> : Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer PropertyName, infer Owner, infer State> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, OwnerName, PropertyName>, State, Input> : never : never;
 type EffectivePropertyProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = EffectivePropertyEntriesOfClass<Value> extends infer Entry ? Entry extends unknown ? EffectivePropertyProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
 type OwnInstanceMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, false>>;
 type OwnStaticMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, true>>;
@@ -314,7 +317,7 @@ type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Valu
 type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
     readonly origin: Origin;
 }, language.DefinitionKey<Origin, 'function', Name>> : never;
-type ResolvedPropertyOfProjection<Value> = Value extends PropertyProjection<infer PropertyValue, infer Required, infer Name, infer Key, infer State> ? language.ResolvedProperty<PropertyValue, Required, State> & {
+type ResolvedPropertyOfProjection<Value> = Value extends PropertyProjection<infer PropertyValue, infer Required, infer Name, infer Key, infer State, infer Input> ? language.ResolvedProperty<PropertyValue, Required, State, Input> & {
     readonly name: Name;
     readonly key: Key;
 } : never;

package/dist/v1/compiled/admission/accept.js

@@ -271,7 +271,21 @@ function compiledCallable(input, values, method, path) {
         }
         policyCheck(value.policy, 0, `${path}/policy`);
     }
-    const inputIndex = index(value.input, values.length, 'Callable input', `${path}/input`);
+    let inputIndex;
+    if (!method && typeof value.input === 'object' && value.input !== null) {
+        const inputPath = `${path}/input`;
+        const binary = object(value.input, 'Binary input', inputPath);
+        exact(binary, ['mode', 'metadata', 'maximumBytes'], 'Binary input', inputPath);
+        if (binary.mode !== 'binary')
+            invalid('Binary input mode', undefined, `${inputPath}/mode`);
+        inputIndex = index(binary.metadata, values.length, 'Binary input metadata', `${inputPath}/metadata`);
+        const maximumBytes = integer(binary.maximumBytes, 'Binary input maximumBytes', `${inputPath}/maximumBytes`);
+        if (maximumBytes < 1)
+            invalid('Binary input maximumBytes', undefined, `${inputPath}/maximumBytes`);
+    }
+    else {
+        inputIndex = index(value.input, values.length, 'Callable input', `${path}/input`);
+    }
     if (value.fields !== undefined) {
         const fieldsPath = `${path}/fields`;
         for (const [field, nodes] of Object.entries(object(value.fields, 'Callable fields', fieldsPath))) {

package/dist/v1/compiled/admission/revision.js

@@ -54,7 +54,13 @@ function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
-        input: schemaOf(entry, input),
+        input: typeof input === 'number'
+            ? schemaOf(entry, input)
+            : {
+                mode: 'binary',
+                metadata: schemaOf(entry, input.metadata),
+                maximumBytes: input.maximumBytes,
+            },
         output: sourceOutput(entry, output),
     };
 }

package/dist/v1/compiled/admission/semantics.js

@@ -282,7 +282,7 @@ function validatePolicies(candidate, context) {
         validatePolicyParity(context, entry, entryIndex, localPolicies);
         for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
             if (callable.policy !== undefined)
-                validateCallablePolicy(context, entry, callable.policy, callable.input, callable.fields, false, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
+                validateCallablePolicy(context, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, callable.fields, false, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
         }
         for (const [classIndex, definition] of entry.definitions.classes.entries()) {
             for (const [kind, ref] of Object.entries(definition.policies)) {
@@ -523,7 +523,7 @@ function validatePolicyParity(context, entry, entryIndex, policies) {
     }
     for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
         if (callable.policy !== undefined) {
-            validateCallablePolicyTyping(context, typing, entry, callable.policy, callable.input, undefined, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
+            validateCallablePolicyTyping(context, typing, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, undefined, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
         }
     }
 }

package/dist/v1/compiled/compiler/compile.js

@@ -1,3 +1,4 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
 import { classifyPreparedOrdering } from '../../language/value/ordering.js';
@@ -96,8 +97,18 @@ function compileEntry(schema, lookup) {
     const functions = Object.values(schema.functions)
         .sort((left, right) => compare(left.ref.name, right.ref.name))
         .map((definition) => {
-        const input = add(definition.input, `/functions/${definition.ref.name}/input`);
-        const fields = inputFieldNodes(values[input]);
+        const binary = isBinaryInput(definition.input);
+        const inputIndex = add(binary ? definition.input.metadata : definition.input, binary
+            ? `/functions/${definition.ref.name}/input/metadata`
+            : `/functions/${definition.ref.name}/input`);
+        const input = binary
+            ? {
+                mode: 'binary',
+                metadata: inputIndex,
+                maximumBytes: definition.input.maximumBytes,
+            }
+            : inputIndex;
+        const fields = inputFieldNodes(values[inputIndex]);
         return {
             ref: definition.ref,
             auth: definition.auth,

package/dist/v1/compiled/loader/load.js

@@ -86,7 +86,13 @@ function loadFunction(entry, value) {
     const { input, fields: _, output, ...definition } = value;
     return Object.freeze({
         ...definition,
-        input: schemaOf(entry, input),
+        input: typeof input === 'number'
+            ? schemaOf(entry, input)
+            : {
+                mode: 'binary',
+                metadata: schemaOf(entry, input.metadata),
+                maximumBytes: input.maximumBytes,
+            },
         output: loadOutput(entry, output),
     });
 }
@@ -107,7 +113,7 @@ function schemaOf(entry, index) {
 }
 function callableProgram(value) {
     return {
-        input: value.input,
+        input: typeof value.input === 'number' ? value.input : value.input.metadata,
         ...(value.fields === undefined ? {} : { fields: value.fields }),
         ...(value.output.mode === 'binary' ? {} : { output: value.output.value }),
     };

package/dist/v1/compiled/model/schema.d.ts

@@ -38,7 +38,11 @@ export type CompiledClass = (Omit<Extract<ClassDefinition, {
     readonly properties: readonly CompiledProperty[];
 });
 export interface CompiledFunction extends Omit<import('../../language/callable/model/callable.js').FunctionDefinition, 'input' | 'output'> {
-    readonly input: number;
+    readonly input: number | {
+        readonly mode: 'binary';
+        readonly metadata: number;
+        readonly maximumBytes: number;
+    };
     readonly fields?: Readonly<Record<string, readonly number[]>>;
     readonly output: CompiledOutput;
 }

package/dist/v1/index.d.ts

@@ -1,10 +1,11 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
 export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

package/dist/v1/index.js

@@ -1,6 +1,7 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
 export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';

package/dist/v1/language/callable/model/callable.d.ts

@@ -12,12 +12,25 @@ export type CallableOutput = {
     readonly mode: 'binary';
 };
 export type OutputMode = CallableOutput['mode'];
-export interface CallableDefinitionBase {
+/** A binary Function receives portable metadata and one required byte stream. */
+export interface BinaryInput {
+    readonly mode: 'binary';
+    readonly metadata: JsonSchema;
+    readonly maximumBytes: number;
+}
+export type CallableInputContract = JsonSchema | BinaryInput;
+declare const BINARY_INPUT_PROJECTION: unique symbol;
+/** Type-only witness retained by authored Functions; never serialized as an input Value. */
+export interface BinaryInputProjection<out Metadata = unknown> {
+    readonly [BINARY_INPUT_PROJECTION]: Metadata;
+}
+export declare function isBinaryInput(input: CallableInputContract): input is BinaryInput;
+export interface CallableDefinitionBase<Input extends CallableInputContract = CallableInputContract> {
     readonly description?: string;
-    readonly input: JsonSchema;
+    readonly input: Input;
     readonly output: CallableOutput;
 }
-export type CallableDefinition = CallableDefinitionBase & ({
+export type CallableDefinition<Input extends CallableInputContract = CallableInputContract> = CallableDefinitionBase<Input> & ({
     readonly auth: 'anonymous' | 'authenticated';
     readonly policy?: never;
 } | {
@@ -25,8 +38,9 @@ export type CallableDefinition = CallableDefinitionBase & ({
     readonly policy?: PolicyCheckExpression;
 });
 export type FunctionDefinition = DefinitionBase<FunctionRef> & CallableDefinition;
-export type MethodDefinition = CallableDefinition & {
+export type MethodDefinition = CallableDefinition<JsonSchema> & {
     readonly static: boolean;
     readonly abstract: boolean;
 };
 export type MethodRecord = Readonly<Record<string, MethodDefinition>>;
+export {};

package/dist/v1/language/callable/model/callable.js

@@ -1 +1,3 @@
-export {};
+export function isBinaryInput(input) {
+    return typeof input === 'object' && input !== null && input.mode === 'binary';
+}

package/dist/v1/language/callable/resolved.d.ts

@@ -2,7 +2,7 @@ import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressin
 import type { ResolvedClass } from '../class/resolved.js';
 import type { PolicyCheckExpression } from '../policy/model/policy.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
-import type { FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { BinaryInputProjection, FunctionDefinition, MethodDefinition } from './model/callable.js';
 import type { FunctionAuth } from './model/callable.js';
 type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends PolicyCheckExpression> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
     readonly auth: Auth;
@@ -65,7 +65,12 @@ export type MethodOwnerKeyOf<Method> = Method extends {
     readonly key: infer ExactKey extends MethodKey;
 } ? MethodOwnerKeyOfKey<ExactKey> : never;
 type MethodOwnerKeyOfKey<ExactKey extends MethodKey> = ExactKey extends `${infer Origin}:class.${infer Owner}.method.${string}` ? DefinitionKey<Extract<Origin, Key.Origin>, 'class', Owner> : never;
-export type CallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+type ProjectedCallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+type InputValue<Input> = Input extends BinaryInputProjection<infer Metadata> ? Metadata : Input;
+/** Portable metadata for a binary Function, or the Value for an ordinary callable. */
+export type CallableInputOf<Callable> = InputValue<ProjectedCallableInputOf<Callable>>;
+type InputMode<Input> = Input extends BinaryInputProjection ? 'binary' : 'value';
+export type CallableInputModeOf<Callable> = InputMode<ProjectedCallableInputOf<Callable>>;
 export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
 /** An exact local Method whose Schema requires an implementation. */
 export type ExecutableMethod<Input = unknown, Output = unknown, Static extends boolean = boolean> = ResolvedMethod<Input, Output, Static> & {

package/dist/v1/language/class/facets.d.ts

@@ -1,4 +1,5 @@
 import type { CallableInputOf, CallableOutputOf, ResolvedMethod, ResolvedMethodCollection } from '../callable/resolved.js';
+import type { StateTopology } from '../state/index.js';
 import type { ResolvedProperty, ResolvedPropertyCollection } from './resolved.js';
 type MemberName = string | number | symbol;
 type ValueAt<Collection, Key> = Key extends keyof Collection ? Collection[Key] : never;
@@ -17,7 +18,7 @@ type MethodByKeyOf<Class> = MethodCollectionOf<Class> extends {
     readonly byKey: infer ByKey extends Readonly<Record<string, ResolvedMethod>>;
 } ? ByKey : Readonly<Record<never, never>>;
 type MethodByNameOf<Class> = Pick<MethodCollectionOf<Class>, Exclude<keyof MethodCollectionOf<Class>, keyof ResolvedMethodCollection>>;
-export type PropertyOutputOf<Property> = Property extends ResolvedProperty<infer Value, infer Required> ? Required extends true ? Value : Value | undefined : never;
+export type PropertyOutputOf<Property> = Property extends ResolvedProperty<infer Value, infer Required, StateTopology | undefined, unknown> ? Required extends true ? Value : Value | undefined : never;
 /** Collision-safe direct Property values. Client supplies graph/wrapper reserved names. */
 export type PropertyShortcutsOf<Class, Reserved extends MemberName = never> = Readonly<{
     [Name in Exclude<keyof PropertyByNameOf<Class>, keyof MethodByNameOf<Class> | Reserved>]: PropertyOutputOf<ValueAt<PropertyByNameOf<Class>, Name>>;

package/dist/v1/language/class/resolved.d.ts

@@ -8,7 +8,7 @@ import type { ClassDefinition, ClassKind } from './model/class.js';
 import type { DataDefinition } from './model/data.js';
 import type { PropertyDefinition } from './model/property.js';
 import type { PropertyValues } from './property-values.js';
-export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean, out State extends StateTopology | undefined = StateTopology | undefined> {
+export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean, out State extends StateTopology | undefined = StateTopology | undefined, out Input = Value> {
     readonly owner: AnyResolvedClass;
     readonly name: string;
     readonly key: PropertyKey;
@@ -20,6 +20,7 @@ export interface ResolvedProperty<out Value = PortableValue, out Required extend
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
     readonly __value?: Value;
+    readonly __input?: Input;
 }
 export interface ResolvedData {
     readonly owner: ResolvedClass<'node'>;
@@ -68,14 +69,14 @@ export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>
 type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
     readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
 } ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
-export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value> ? Value : never;
+export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value, boolean, StateTopology | undefined, unknown> ? Value : never;
 export type PropertiesOf<Class> = Class extends {
     readonly properties: infer Properties extends ResolvedPropertyCollection;
 } ? Properties : ResolvedPropertyCollection<Record<never, never>>;
 export type PropertyValuesOf<Class> = PropertyValues & Readonly<{
     [Key in keyof PropertyByKeyOf<Class>]?: PropertyValueOf<PropertyByKeyOf<Class>[Key]>;
 }>;
-export type PropertyInputOf<Class> = PropertyInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
+export type PropertyInputOf<Class> = PropertyWriteInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
 export type MethodsOf<Class> = Class extends {
     readonly kind: 'node';
     readonly methods: infer Methods extends ResolvedMethodCollection;
@@ -110,10 +111,16 @@ type PropertyInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<u
 } & {
     [Name in keyof ByName]?: PropertyValueOf<ByName[Name]>;
 }>;
+type PropertyWriteInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>>> = Readonly<{
+    [Key in keyof ByKey]?: PropertyWriteValueOf<ByKey[Key]>;
+} & {
+    [Name in keyof ByName]?: PropertyWriteValueOf<ByName[Name]>;
+}>;
+type PropertyWriteValueOf<Property> = Property extends ResolvedProperty<unknown, boolean, StateTopology | undefined, infer Input> ? Input : never;
 type PropertyByKeyOf<Class> = PropertiesOf<Class> extends {
     readonly byKey: infer ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>;
 } ? ByKey : Readonly<Record<never, never>>;
 type PropertyByNameOf<Class> = Readonly<{
-    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty>;
+    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty<unknown, boolean, StateTopology | undefined, unknown>>;
 }>;
 export {};

package/dist/v1/language/index.d.ts

@@ -1,4 +1,5 @@
 export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
 export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
 export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';

package/dist/v1/language/index.js

@@ -1,4 +1,5 @@
 export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
 export { stateMachine } from './state/index.js';
 export { PropertyValues } from './class/property-values.js';
 export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/value/evaluate/evaluator.js

@@ -1,3 +1,4 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
 import { isInstantValue } from '../model/instant.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { appendPointer } from '../syntax/pointer.js';
@@ -131,6 +132,9 @@ class InstanceEvaluator {
         if (schema['x-astrale-value-kind'] === 'instant' && !isInstantValue(input)) {
             failures.push(invalid(instancePointer, 'x-astrale-value-kind', 'Value is not an exact UTC millisecond Instant.'));
         }
+        if (schema['x-astrale-value-kind'] === 'blob' && !isCanonicalBlobRef(input)) {
+            failures.push(invalid(instancePointer, 'x-astrale-value-kind', 'Value is not a canonical blob Ref.'));
+        }
         if (typeof schema.type === 'string') {
             if (!matchesType(schema.type, input)) {
                 failures.push(invalid(instancePointer, 'type', `Value is not of type ${schema.type}.`));

package/dist/v1/language/value/model/blob.d.ts

@@ -0,0 +1,33 @@
+import type { JsonSchemaObject } from './schema.js';
+declare const BLOB_SCHEMA: unique symbol;
+/** The portable value read from a blob-kind Node property. */
+export interface BlobRef {
+    readonly digest: `sha256:${string}`;
+    readonly mediaType: string;
+    readonly size: number;
+}
+/** An uploader-bound receipt is the only ordinary write input for a blob property. */
+export type BlobReceipt = string & {
+    readonly __brand: 'BlobReceipt';
+};
+/** Type-only marker; the serialized schema remains ordinary JSON. */
+export interface BlobSchema extends JsonSchemaObject {
+    readonly [BLOB_SCHEMA]: true;
+}
+export interface BlobOptions {
+    /** Required property-level bound, in bytes. */
+    readonly maxBytes: number;
+    /** Omission admits any canonical artifact media type. */
+    readonly mediaTypes?: readonly string[];
+}
+export declare const BLOB_VALUE_KIND: 'blob';
+export declare const BLOB_DIGEST_PATTERN = "sha256:[0-9a-f]{64}";
+export declare const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
+/** Build the one canonical V1 schema shape for a blob-valued Node property. */
+export declare function blob(options: BlobOptions): BlobSchema;
+/** Marker recognition on an already admitted V1 value schema. */
+export declare function isBlobValueSchema(input: unknown): input is BlobSchema;
+/** Exact canonical artifact media type, including ordered token parameters. */
+export declare function canonicalMediaType(input: string): string;
+export declare function isCanonicalBlobRef(input: unknown): input is BlobRef;
+export {};

package/dist/v1/language/value/model/blob.js

@@ -0,0 +1,90 @@
+export const BLOB_VALUE_KIND = 'blob';
+export const BLOB_DIGEST_PATTERN = 'sha256:[0-9a-f]{64}';
+export const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+/** Build the one canonical V1 schema shape for a blob-valued Node property. */
+export function blob(options) {
+    if (!Number.isSafeInteger(options?.maxBytes) || options.maxBytes < 1) {
+        throw new TypeError('Blob maxBytes must be a positive safe integer.');
+    }
+    let mediaTypes;
+    if (options.mediaTypes !== undefined) {
+        if (!Array.isArray(options.mediaTypes) || options.mediaTypes.length === 0) {
+            throw new TypeError('Blob mediaTypes must be a non-empty list.');
+        }
+        mediaTypes = [...new Set(options.mediaTypes.map(canonicalMediaType))].sort();
+    }
+    return Object.freeze({
+        type: 'object',
+        'x-astrale-value-kind': BLOB_VALUE_KIND,
+        properties: {
+            digest: { type: 'string', fullMatch: BLOB_DIGEST_PATTERN },
+            mediaType: mediaTypes === undefined
+                ? { type: 'string', fullMatch: BLOB_MEDIA_TYPE_PATTERN }
+                : { enum: mediaTypes },
+            size: { type: 'integer', minimum: 0, maximum: options.maxBytes },
+        },
+        required: ['digest', 'mediaType', 'size'],
+        additionalProperties: false,
+    });
+}
+/** Marker recognition on an already admitted V1 value schema. */
+export function isBlobValueSchema(input) {
+    return (input !== null &&
+        typeof input === 'object' &&
+        !Array.isArray(input) &&
+        input['x-astrale-value-kind'] === BLOB_VALUE_KIND);
+}
+/** Exact canonical artifact media type, including ordered token parameters. */
+export function canonicalMediaType(input) {
+    if (typeof input !== 'string')
+        throw new TypeError('Blob media type is invalid.');
+    const [essence, ...parametersInput] = input.split(';');
+    const [rawType, rawSubtype, ...extra] = essence.trim().split('/');
+    if (rawType === undefined ||
+        rawSubtype === undefined ||
+        extra.length !== 0 ||
+        !TOKEN.test(rawType) ||
+        !TOKEN.test(rawSubtype)) {
+        throw new TypeError('Blob media type is invalid.');
+    }
+    const parameters = parametersInput.map((part) => {
+        const separator = part.indexOf('=');
+        if (separator <= 0)
+            throw new TypeError('Blob media type parameter is invalid.');
+        const name = part.slice(0, separator).trim().toLowerCase();
+        const value = part.slice(separator + 1).trim();
+        if (!TOKEN.test(name) || !TOKEN.test(value)) {
+            throw new TypeError('Blob media type parameter is invalid.');
+        }
+        return [name, value];
+    });
+    parameters.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    if (new Set(parameters.map(([name]) => name)).size !== parameters.length) {
+        throw new TypeError('Blob media type parameters are duplicated.');
+    }
+    return parameters.reduce((result, [name, value]) => `${result};${name}=${value}`, `${rawType.toLowerCase()}/${rawSubtype.toLowerCase()}`);
+}
+export function isCanonicalBlobRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return false;
+    const value = input;
+    if (Object.keys(value).length !== 3 ||
+        !Object.hasOwn(value, 'digest') ||
+        !Object.hasOwn(value, 'mediaType') ||
+        !Object.hasOwn(value, 'size') ||
+        typeof value.digest !== 'string' ||
+        !DIGEST.test(value.digest) ||
+        typeof value.mediaType !== 'string' ||
+        !Number.isSafeInteger(value.size) ||
+        value.size < 0) {
+        return false;
+    }
+    try {
+        return canonicalMediaType(value.mediaType) === value.mediaType;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/v1/language/value/profile/rules.js

@@ -1,5 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { diagnostic } from '../../validation/diagnostic.js';
+import { blob, BLOB_VALUE_KIND } from '../model/blob.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { VALUE_SCHEMA_DIALECT } from '../model/schema.js';
 import { isIRegexp } from '../regexp/syntax.js';
@@ -28,19 +29,50 @@ export function validateSchemaProfile(schema, context, pointer) {
             diagnostics.push(diagnostic('VS_RESOURCE_ID', `${currentPointer}/$id`, '$id is forbidden in an embedded V1 value schema.'));
         }
         validateSemanticSets(location.schema, currentPointer, diagnostics);
-        validateValueKind(location.schema, currentPointer, diagnostics);
+        validateValueKind(location.schema, context, location.depth, currentPointer, diagnostics);
         validateRegexes(location.schema, currentPointer, diagnostics);
     });
-    void context;
     return diagnostics;
 }
-function validateValueKind(schema, pointer, diagnostics) {
+function validateValueKind(schema, context, depth, pointer, diagnostics) {
     if (!Object.hasOwn(schema, 'x-astrale-value-kind'))
         return;
-    if (schema['x-astrale-value-kind'] !== 'instant' || schema.type !== 'string') {
+    if (schema['x-astrale-value-kind'] === BLOB_VALUE_KIND) {
+        if (context !== 'property-facet' || depth !== 0 || !isCanonicalBlobSchema(schema)) {
+            diagnostics.push(diagnostic('VS_VALUE_KIND', `${pointer}/x-astrale-value-kind`, 'blob must be the exact schema.values.blob output at the root of a Node property.'));
+        }
+    }
+    else if (schema['x-astrale-value-kind'] !== 'instant' || schema.type !== 'string') {
         diagnostics.push(diagnostic('VS_VALUE_KIND', `${pointer}/x-astrale-value-kind`, 'x-astrale-value-kind is exactly instant and requires type string at the same schema location.'));
     }
 }
+function isCanonicalBlobSchema(input) {
+    const properties = input.properties;
+    if (!isJsonObject(properties))
+        return false;
+    const size = properties.size;
+    const mediaType = properties.mediaType;
+    if (!isJsonObject(size) || !isJsonObject(mediaType))
+        return false;
+    const maxBytes = size.maximum;
+    if (typeof maxBytes !== 'number' || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+        return false;
+    }
+    const mediaTypes = mediaType.enum;
+    if (mediaTypes !== undefined && (!Array.isArray(mediaTypes) || !mediaTypes.every(isString))) {
+        return false;
+    }
+    try {
+        return (json.serialize(input) ===
+            json.serialize(blob({ maxBytes, ...(mediaTypes === undefined ? {} : { mediaTypes }) })));
+    }
+    catch {
+        return false;
+    }
+}
+function isString(input) {
+    return typeof input === 'string';
+}
 function validateSemanticSets(schema, pointer, diagnostics) {
     if (Array.isArray(schema.type)) {
         rejectPrimitiveDuplicates(schema.type, `${pointer}/type`, 'type', diagnostics);

package/dist/v1/schema/compatibility/comparators/callables.d.ts

@@ -1,7 +1,6 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import type { CallableOutput, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { CallableOutput, CallableInputContract, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
 import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.js';
-import type { JsonSchema } from '../../../language/value/model/schema.js';
 import type { EffectiveMethod } from '../../analysis/class.js';
 import type { Fingerprint } from '../model.js';
 export declare function methodExistence(method: EffectiveMethod): Value;
@@ -20,7 +19,7 @@ export declare function callableFingerprint(callable: ResolvedFunction | Resolve
 type CallableSignature = {
     readonly static?: boolean;
     readonly abstract?: boolean;
-    readonly input: JsonSchema;
+    readonly input: CallableInputContract;
     readonly output: CallableOutput;
 };
 /** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -1,3 +1,4 @@
+import { isBinaryInput } from '../../../language/callable/model/callable.js';
 import { methodSignature as inheritedSignature } from '../../analysis/class.js';
 import { deepFreeze } from '../../canonical/freeze.js';
 import { keyForDefinitionRef } from '../coordinate.js';
@@ -61,7 +62,13 @@ export function callableFingerprint(callable) {
 export function callableSignature(declaration) {
     return {
         ...fieldsOf({ declaration, roles: CALLABLE_FIELDS }),
-        input: semanticValueSchema(declaration.input),
+        input: isBinaryInput(declaration.input)
+            ? {
+                mode: 'binary',
+                metadata: semanticValueSchema(declaration.input.metadata),
+                maximumBytes: declaration.input.maximumBytes,
+            }
+            : semanticValueSchema(declaration.input),
         output: semanticOutput(declaration.output),
     };
 }

package/dist/v1/schema/normalization/domain.js

@@ -1,5 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
@@ -92,7 +93,13 @@ function canonicalizeFunction(value) {
 function canonicalizeCallable(value) {
     const base = {
         ...withDescription(value),
-        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        input: isBinaryInput(value.input)
+            ? {
+                mode: 'binary',
+                metadata: canonicalizeValueSchema(value.input.metadata, 'callable-input'),
+                maximumBytes: value.input.maximumBytes,
+            }
+            : canonicalizeValueSchema(value.input, 'callable-input'),
         output: canonicalizeCallableOutput(value.output),
     };
     return value.auth === 'authorized'
@@ -106,6 +113,7 @@ function canonicalizeCallable(value) {
 function canonicalizeMethod(value) {
     return {
         ...canonicalizeCallable(value),
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
         static: value.static,
         abstract: value.abstract,
     };

package/dist/v1/schema/resolution/domain.js

@@ -2,6 +2,7 @@ import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain, createSourceDomain } from '../../domain/create.js';
 import { createDomainValidation, unknownInputField } from '../../domain/validation/create.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
@@ -78,7 +79,7 @@ function sourceValidation(closure, registries) {
             }
         }
         for (const definition of Object.values(owner.functions)) {
-            callables.set(Key.of(definition.ref), callableValidation(definition.input, definition.output.mode === 'binary'
+            callables.set(Key.of(definition.ref), callableValidation(isBinaryInput(definition.input) ? definition.input.metadata : definition.input, definition.output.mode === 'binary'
                 ? undefined
                 : definition.output.mode === 'value'
                     ? definition.output.schema

package/dist/v1/schema/resolution/origins.js

@@ -1,4 +1,5 @@
 import { compareDefinitionRefs, definitionRefIndex } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { policyVariableClass } from '../../language/policy/model/policy.js';
 import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
 import { walkSchema } from '../../language/value/syntax/walk.js';
@@ -80,7 +81,7 @@ export function collectCallableRefs(declaration, add) {
 }
 /** References inside the contract a caller compiles against: the input and output value schemas. */
 export function collectCallableContractRefs(declaration, add) {
-    collectValueDefinitionRefs(declaration.input, add);
+    collectValueDefinitionRefs(isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input, add);
     if (declaration.output.mode === 'value')
         collectValueDefinitionRefs(declaration.output.schema, add);
     if (declaration.output.mode === 'stream')

package/dist/v1/schema/validation/class.js

@@ -2,6 +2,7 @@ import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { admitStateTopology } from '../../language/state/topology.js';
+import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { diagnostic } from '../diagnostic.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
@@ -33,6 +34,10 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
     const valueRegistry = createValueSchemaRegistry(environment);
     for (const [name, property] of Object.entries(declaration.properties)) {
         const propertyPointer = `${pointer}/properties/${escapePointer(name)}`;
+        if (isBlobValueSchema(property.schema) &&
+            (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
+            diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
+        }
         if (property.state !== undefined) {
             if (declaration.kind !== 'node') {
                 diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, 'A State Property may be declared only on a Node Class.'));

package/dist/v1/schema/validation/domain.structure.js

@@ -183,6 +183,12 @@ const callableOutputSchema = discriminatedUnion('mode', [
         mode: literal('binary'),
     }),
 ]);
+const binaryInputSchema = strictObject({
+    mode: literal('binary'),
+    metadata: jsonSchemaSchema,
+    maximumBytes: number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+});
+const valueFunctionInputSchema = jsonSchemaSchema.refine((value) => typeof value !== 'object' || value === null || value.mode !== 'binary', 'Binary input must declare metadata and maximumBytes.');
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
@@ -254,6 +260,7 @@ function validateEdgeOrientationShape(value, context) {
 const functionDefinitionSchema = strictObject({
     ref: functionRefSchema,
     ...callableShape,
+    input: union([binaryInputSchema, valueFunctionInputSchema]),
 }).superRefine((callable, context) => {
     if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({

package/dist/v1/schema/validation/policy/uses.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isBinaryInput } from '../../../language/callable/model/callable.js';
 import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
@@ -48,7 +49,7 @@ export function validateCallableUses(context, typing) {
             continue;
         validateChecks(context, typing, declaration.policy, {
             pointer: `/functions/${escapePointer(name)}/policy`,
-            input: declaration.input,
+            input: isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input,
             instanceMethod: false,
         });
     }

package/dist/v1/schema/validation/value-api.d.ts

@@ -4,6 +4,8 @@ import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { DomainSchema } from '../model/schema.js';
 export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
+export type { BlobOptions, BlobReceipt, BlobRef, BlobSchema, } from '../../language/value/model/blob.js';
 export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
 export { instant } from '../../language/value/model/instant.js';
 export type { OrderingKind } from '../../language/value/ordering.js';

package/dist/v1/schema/validation/value-api.js

@@ -4,6 +4,7 @@ import { classifyOrdering as classifyOrderingWithRegistry } from '../../language
 import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
 const registries = new WeakMap();
 export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
 export { instant } from '../../language/value/model/instant.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export function validate(owner, contract, input, pointer = '') {

package/dist/v1/schema/validation/value.js

@@ -1,3 +1,4 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { validateValueSchema } from '../../language/value/profile/validate.js';
 import { diagnostic } from '../diagnostic.js';
 export function validateEmbeddedValueSchemas(schema, registry) {
@@ -21,7 +22,12 @@ function validateDefinition(declaration, pointer, registry, diagnostics) {
     }
 }
 function validateCallable(declaration, pointer, registry, diagnostics) {
-    validate(declaration.input, 'callable-input', `${pointer}/input`, registry, diagnostics);
+    if (isBinaryInput(declaration.input)) {
+        validate(declaration.input.metadata, 'callable-input', `${pointer}/input/metadata`, registry, diagnostics);
+    }
+    else {
+        validate(declaration.input, 'callable-input', `${pointer}/input`, registry, diagnostics);
+    }
     if (declaration.output.mode === 'value') {
         validate(declaration.output.schema, 'callable-output', `${pointer}/output/schema`, registry, diagnostics);
     }

package/dist/value/canonical.js

@@ -14,7 +14,8 @@ export function serializeAdmitted(input) {
 }
 function serializeSnapshot(input, maxBytes) {
     const output = serializeValue(input);
-    if (utf8Length(output, maxBytes) > maxBytes) {
+    // Scalar text uses at most three UTF-8 bytes per UTF-16 code unit, including JSON escapes.
+    if (output.length > maxBytes / 3 && utf8Length(output, maxBytes) > maxBytes) {
         throw new BoundaryError('VALUE_LIMIT', `Canonical JSON exceeds the ${maxBytes}-byte limit`);
     }
     return output;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.39",
+  "version": "0.2.0-beta.40",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {