@deepseek-ai/dsh-typert-protocol 0.2.1-alpha.1 → 0.2.1-alpha.3

package/lib/types/index.d.ts

@@ -5,18 +5,21 @@
  * @module @deepseek-ai/dsh-typert-protocol
  */
 import { Context, Service } from '@deepseek-ai/cordis';
-import type { TypertContextMap } from './types.ts';
+import type { RemoteWireArgs, TypertContextMap, TypertResourceReader, TypertResourceReaders } from './types.ts';
 export { RemoteError, remoteErrorOf } from './remote-error.ts';
 export { TYPERT_OWNED_VALUE, isTypertOwnedValue, typertOwnedValue } from './owned-value.ts';
 export type { TypertOwnedValue } from './owned-value.ts';
 export { isRemoteJsonValue, isRemoteUplinkItem } from './json-value.ts';
+export { createTypertRemoteInfo, isTypertRemoteMethod } from './remote-info.ts';
+export { principalOf } from './principal.ts';
+export type { RemoteAccessResource, RemoteAccessResourceKind, RemoteAccessResourceOf } from './remote-access.ts';
 /**
  * Test one generated Remote name against the Connection endpoint grammar.
  * @param value - namespace, method, lookup, or Context segment.
  * @returns whether the value can cross the shared RPC carrier unchanged.
  */
 export declare function isTypertRemoteSegment(value: string): boolean;
-export type { InvocationDescriptor, InvocationParameterDescriptor, InvocationSourceLocation, PeerId, PeerScope, RemoteErrorCode, RemoteErrorDetailsMap, RemoteFailure, RemoteInvocation, RemoteResult, RemoteStream, RemoteStreamHandle, TypertClientEventListener, TypertClientRemote, TypertClientContextAdapter, TypertCodec, TypertContext, TypertContextMap, TypertContextRegistry, TypertContextWire, TypertDisposer, TypertForwardableEvent, TypertForwardableEventEntry, TypertHostContextAdapter, TypertHostContextResolver, TypertLocalRegistry, TypertLookup, TypertLookupDefinition, TypertLookupHost, TypertLookupMap, TypertLookupProvider, TypertLookupResolver, TypertLookupRegistry, TypertLookupWire, TypertRemoteScopeApi, TypertRemoteScopeMap, TypertRemoteScopeNamespace, TypertRemoteContribution, TypertRemoteEvent, TypertRemoteEventSelection, TypertRemoteMap, TypertRemoteNamespace, TypertRemoteNamespaceMap, TypertRemoteRegistry, TypertRegistryChange, TypertRegistryListener, TypertSchema, TypertRegistryContract, } from './types.ts';
+export type { InvocationDescriptor, InvocationParameterDescriptor, InvocationSourceLocation, PeerId, PeerScope, Principal, PrincipalMap, RemoteDecoded, RemoteErrorCode, RemoteErrorDetailsMap, RemoteFailure, RemoteInvocation, RemoteResult, RemoteStream, RemoteStreamHandle, RemoteUplinkWindow, RemoteWireArgs, RemoteWireValue, TypertClientEventListener, TypertClientRemote, TypertClientContextAdapter, TypertCodec, TypertContext, TypertContextMap, TypertContextRegistry, TypertContextWire, TypertDisposer, TypertForwardableEvent, TypertForwardableEventEntry, TypertHostContextAdapter, TypertHostContextResolver, TypertResource, TypertResourceDeclaration, TypertResourceEntry, TypertResourceId, TypertResourceKind, TypertResourceMap, TypertResourceReader, TypertResourceReaders, TypertResourceRegistry, TypertLocalRegistry, TypertLookup, TypertLookupDefinition, TypertLookupHost, TypertLookupMap, TypertLookupProvider, TypertLookupResolver, TypertLookupRegistry, TypertLookupWire, TypertRemoteScopeApi, TypertRemoteScopeMap, TypertRemoteScopeNamespace, TypertRemoteContribution, TypertRemoteInfo, TypertRemoteInputOptions, TypertRemoteMethod, TypertRemoteValue, TypertRemoteCodecSpec, TypertRemoteParameterSpec, TypertRemoteMethodSpec, TypertRemoteSpec, TypertRemoteEvent, TypertRemoteEventSelection, TypertRemoteMap, TypertRemoteNamespace, TypertRemoteNamespaceMap, TypertRemoteRegistry, TypertRegistryChange, TypertRegistryListener, TypertSchema, TypertRegistryContract, } from './types.ts';
 /** Options for an explicit Service-to-Gateway binding. */
 export interface TypertGatewayBindingOptions {
     /** Wire namespace; defaults to the Cordis service key. */
@@ -44,12 +47,48 @@ export interface RemoteMethodMarker {
     /** Stream methods yield many independently validated result items. */
     readonly mode?: 'stream';
     readonly invocation: RemoteInvocationMarker;
+    /**
+     * Declared `resources` readers keyed by resource kind. Callers spread the
+     * method's wire arguments into each one and validate its result.
+     */
+    readonly resources?: Readonly<Record<string, TypertResourceReader>>;
 }
-/** Options for a non-unary Remote method. */
-export interface RemoteMethodOptions {
+/**
+ * Explicit endpoint and resource choices for one Remote Scope method.
+ * @template WireArgs - the decorated method's positional parameters as the
+ *   wire carries them; the default `never` admits readers of any tuple.
+ */
+export interface RemoteScopeOptions<WireArgs extends readonly unknown[] = never> {
+    /** Exported endpoint method; omission retains the implementation member name. */
+    readonly name?: string;
+    /**
+     * Per-kind readers of the resources one call touches. Each receives the
+     * method's arguments as its own parameters, JSON arguments as their Typert
+     * codecs validated them, a lookup parameter as its wire identity and a
+     * cancellation parameter as the call's signal, so it performs plain reads
+     * only, and returns one identity, several, or `undefined` for none. A
+     * throw, an empty list, or an identity other than a non-empty string
+     * refuses the call. For a kind without a reader, the Gateway reads the
+     * identity of a scoped Context whose Host adapter declares that `resource`
+     * and of lookup parameters declaring it, else the field registered in
+     * `typert.resources`: a top-level argument or, failing that, the first
+     * object argument. A call that carries no identity touches `global`. The
+     * readers and these defaults together must name every resource the method
+     * accesses: access control never checks a resource they omit.
+     */
+    readonly resources?: TypertResourceReaders<WireArgs>;
+}
+/**
+ * Explicit endpoint, stream, and resource choices for one direct Remote method.
+ * @template WireArgs - the decorated method's positional parameters as the
+ *   wire carries them; the default `never` admits readers of any tuple.
+ */
+export interface RemoteMethodOptions<WireArgs extends readonly unknown[] = never> extends RemoteScopeOptions<WireArgs> {
     /** `stream`: deliver each Iterable item over the shared logical-stream carrier. */
-    readonly mode: 'stream';
+    readonly mode?: 'stream';
 }
+/** A decorator whose `resources` readers were checked against the decorated method's parameters. */
+type RemoteTypedMethodDecorator<This extends object, Args extends unknown[], Result> = (method: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>) => void;
 type RemoteMethodDecorator = <This extends object, Args extends unknown[], Result>(method: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>) => void;
 /**
  * Bind one visible Service field to a Cordis key and Remote namespace. A
@@ -58,7 +97,7 @@ type RemoteMethodDecorator = <This extends object, Args extends unknown[], Resul
  * a Host composition to read it.
  * @param service - owning Service instance, normally `this`.
  * @param serviceKey - exact Cordis service key.
- * @param options - optional distinct wire namespace.
+ * @param options - optional wire namespace.
  * @returns a frozen, inspectable binding with no compiler-injected metadata.
  */
 export declare function bindTypertRemote<Service extends object>(service: Service, serviceKey: string, options?: TypertGatewayBindingOptions): TypertGatewayBinding<Service>;
@@ -70,7 +109,7 @@ export declare abstract class TypertRemoteService<out T = never> extends Service
      * Register the Service and bind the same key to Typert Gateway.
      * @param ctx - owning Cordis Context.
      * @param serviceKey - exact Cordis service key and default wire namespace.
-     * @param options - optional distinct wire namespace.
+     * @param options - optional wire namespace.
      */
     protected constructor(ctx: Context, serviceKey: string, options?: TypertGatewayBindingOptions);
 }
@@ -81,18 +120,31 @@ export declare abstract class TypertRemoteService<out T = never> extends Service
  */
 export declare function Remote<This extends object, Args extends unknown[], Result>(_method: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>): void;
 /**
- * Mark one public instance method under an exported name or as a logical stream.
- * @param option - endpoint method name or stream delivery mode.
+ * Mark one public instance method with an endpoint name.
+ * @param name - exported endpoint method.
+ * @returns a standard method decorator.
+ */
+export declare function Remote(name: string): RemoteMethodDecorator;
+/**
+ * Mark one public instance method with endpoint, stream, or resource options.
+ * @param options - Remote options; each reader's parameters are inferred from the decorated method.
  * @returns a standard method decorator.
  */
-export declare function Remote(option: string | RemoteMethodOptions): RemoteMethodDecorator;
+export declare function Remote<This extends object, Args extends unknown[], Result>(options: NoInfer<RemoteMethodOptions<RemoteWireArgs<Args>>>): RemoteTypedMethodDecorator<This, Args, Result>;
 /**
  * Create a decorator for a method resolved from one Remote Scope.
  * @param key - scope key declared through the Context map.
- * @param exportName - optional Remote export name; defaults to the method name.
+ * @param name - optional Remote export name; defaults to the method name.
+ * @returns a standard method decorator that records a versioned prototype descriptor.
+ */
+export declare function RemoteScope(key: Extract<keyof TypertContextMap, string>, name?: string): RemoteMethodDecorator;
+/**
+ * Create a decorator for a Remote Scope method with endpoint or resource options.
+ * @param key - scope key declared through the Context map.
+ * @param options - Remote Scope options; each reader's parameters are inferred from the decorated method.
  * @returns a standard method decorator that records a versioned prototype descriptor.
  */
-export declare function RemoteScope(key: Extract<keyof TypertContextMap, string>, exportName?: string): RemoteMethodDecorator;
+export declare function RemoteScope<This extends object, Args extends unknown[], Result>(key: Extract<keyof TypertContextMap, string>, options: NoInfer<RemoteScopeOptions<RemoteWireArgs<Args>>>): RemoteTypedMethodDecorator<This, Args, Result>;
 /**
  * Read Remote markers attached to a live Service's class prototype.
  * The returned snapshot cannot mutate the stored descriptor.

package/lib/types/index.js

@@ -8,6 +8,8 @@ import { Context, Service } from '@deepseek-ai/cordis';
 export { RemoteError, remoteErrorOf } from "./remote-error.js";
 export { TYPERT_OWNED_VALUE, isTypertOwnedValue, typertOwnedValue } from "./owned-value.js";
 export { isRemoteJsonValue, isRemoteUplinkItem } from "./json-value.js";
+export { createTypertRemoteInfo, isTypertRemoteMethod } from "./remote-info.js";
+export { principalOf } from "./principal.js";
 const TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
 /**
  * Test one generated Remote name against the Connection endpoint grammar.
@@ -25,7 +27,7 @@ const REMOTE_METHOD_DESCRIPTOR = '@deepseek-ai/dsh-typert-protocol/remote-method
  * a Host composition to read it.
  * @param service - owning Service instance, normally `this`.
  * @param serviceKey - exact Cordis service key.
- * @param options - optional distinct wire namespace.
+ * @param options - optional wire namespace.
  * @returns a frozen, inspectable binding with no compiler-injected metadata.
  */
 export function bindTypertRemote(service, serviceKey, options = {}) {
@@ -33,7 +35,7 @@ export function bindTypertRemote(service, serviceKey, options = {}) {
     const namespace = options.namespace ?? serviceKey;
     validateName('namespace', namespace);
     const ctx = Reflect.get(service, 'ctx');
-    if (ctx instanceof Context)
+    if (Context.is(ctx))
         provideInvocationAccessor(ctx);
     return Object.freeze({ service, serviceKey, namespace });
 }
@@ -45,7 +47,7 @@ export class TypertRemoteService extends Service {
      * Register the Service and bind the same key to Typert Gateway.
      * @param ctx - owning Cordis Context.
      * @param serviceKey - exact Cordis service key and default wire namespace.
-     * @param options - optional distinct wire namespace.
+     * @param options - optional wire namespace.
      */
     constructor(ctx, serviceKey, options = {}) {
         super(ctx, serviceKey);
@@ -66,38 +68,61 @@ function provideInvocationAccessor(ctx) {
 export function Remote(methodExportOrOptions, context) {
     if (typeof methodExportOrOptions === 'string') {
         validateName('Remote export name', methodExportOrOptions);
-        return remoteDecorator({ kind: 'direct' }, undefined, methodExportOrOptions);
+        return remoteDecorator({ kind: 'direct' }, { exportName: methodExportOrOptions });
     }
     if (typeof methodExportOrOptions === 'object') {
-        if (remoteOptionMode(methodExportOrOptions) !== 'stream'
-            || Reflect.ownKeys(methodExportOrOptions).length !== 1) {
-            throw new TypeError('typert-protocol: Remote options must contain exactly mode: "stream"');
-        }
-        return remoteDecorator({ kind: 'direct' }, 'stream');
+        return remoteDecorator({ kind: 'direct' }, markerOptions(methodExportOrOptions, REMOTE_OPTION_KEYS, 'Remote options require name, mode: "stream", or resources'));
     }
     if (context === undefined)
         throw new TypeError('typert-protocol: Remote decorator context is missing');
     addMarkerInitializer(context, { kind: 'direct' });
 }
-function remoteOptionMode(options) {
-    return Reflect.get(options, 'mode');
+const REMOTE_OPTION_KEYS = new Set(['name', 'mode', 'resources']);
+const REMOTE_SCOPE_OPTION_KEYS = new Set(['name', 'resources']);
+/** Validate one decorator options object against its accepted keys and select the marker fields. */
+function markerOptions(options, accepted, requirement) {
+    const keys = Reflect.ownKeys(options);
+    if (keys.length === 0 || keys.some(key => typeof key !== 'string' || !accepted.has(key))
+        || (Object.hasOwn(options, 'mode') && options.mode !== 'stream')) {
+        throw new TypeError(`typert-protocol: ${requirement}`);
+    }
+    const { mode, name, resources } = options;
+    if (name !== undefined)
+        validateName('Remote export name', name);
+    return {
+        ...(mode === undefined ? {} : { mode }),
+        ...(name === undefined ? {} : { exportName: name }),
+        ...(resources === undefined ? {} : { resources: resourceReaders(resources) }),
+    };
+}
+/** Freeze declared readers into the marker record; a misdeclared reader fails at decoration. */
+function resourceReaders(resources) {
+    const readers = {};
+    for (const [kind, reader] of Object.entries(resources)) {
+        if (typeof reader !== 'function') {
+            throw new TypeError(`typert-protocol: Remote resource reader "${kind}" must be a function`);
+        }
+        readers[kind] = reader;
+    }
+    if (Object.keys(readers).length === 0)
+        throw new TypeError('typert-protocol: Remote resources require at least one reader');
+    return Object.freeze(readers);
 }
-function remoteDecorator(invocation, mode, exportName) {
+function remoteDecorator(invocation, options = {}) {
     return function (_method, context) {
-        addMarkerInitializer(context, invocation, mode, exportName);
+        addMarkerInitializer(context, invocation, options);
     };
 }
-/**
- * Create a decorator for a method resolved from one Remote Scope.
- * @param key - scope key declared through the Context map.
- * @param exportName - optional Remote export name; defaults to the method name.
- * @returns a standard method decorator that records a versioned prototype descriptor.
- */
-export function RemoteScope(key, exportName) {
+export function RemoteScope(key, option) {
     validateName('Scope key', key);
-    if (exportName !== undefined)
-        validateName('Remote export name', exportName);
-    return remoteDecorator({ kind: 'context', context: key }, undefined, exportName);
+    const invocation = { kind: 'context', context: key };
+    if (option === undefined)
+        return remoteDecorator(invocation);
+    if (typeof option === 'string') {
+        validateName('Remote export name', option);
+        return remoteDecorator(invocation, { exportName: option });
+    }
+    return remoteDecorator(invocation, markerOptions(option, REMOTE_SCOPE_OPTION_KEYS, 'RemoteScope options require name or resources'));
 }
 /**
  * Read Remote markers attached to a live Service's class prototype.
@@ -129,7 +154,7 @@ function readRemoteMethodDescriptor(prototype) {
     }
     return descriptor;
 }
-function addMarkerInitializer(context, invocation, mode, exportName) {
+function addMarkerInitializer(context, invocation, options = {}) {
     if (context.private || context.static || typeof context.name !== 'string') {
         throw new TypeError('typert-protocol: Remote decorators require a public instance method with a string name');
     }
@@ -139,21 +164,24 @@ function addMarkerInitializer(context, invocation, mode, exportName) {
         if (prototype === null) {
             throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
         }
-        mark(prototype, method, invocation, mode, exportName);
+        mark(prototype, method, invocation, options);
     });
 }
-function mark(prototype, method, invocation, mode, exportName) {
+function mark(prototype, method, invocation, { mode, exportName, resources }) {
     const descriptor = readRemoteMethodDescriptor(prototype);
     const marker = Object.freeze({
         method,
         ...(exportName === undefined || exportName === method ? {} : { exportName }),
         ...(mode === undefined ? {} : { mode }),
         invocation: Object.freeze(invocation),
+        ...(resources === undefined ? {} : { resources }),
     });
     const current = descriptor?.methods.find(candidate => candidate.method === method);
     if (current !== undefined) {
+        // One decorator application owns one frozen reader record, so identity marks the same declaration.
         if (current.exportName === marker.exportName
             && current.mode === marker.mode
+            && current.resources === marker.resources
             && sameInvocation(current.invocation, invocation))
             return;
         throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);

package/lib/types/principal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reads the non-owner caller of the current Remote call.
+ * @module @deepseek-ai/dsh-typert-protocol/principal
+ */
+import type { Principal, RemoteInvocation } from './types.ts';
+/**
+ * The identity a Remote-call producer records on durable output.
+ * @param invocation - `ctx.invocation`; `undefined` outside a Remote call.
+ * @returns the caller's principal when it is not the owner; `undefined` for the
+ *   owner and for trusted in-process code outside a Remote call.
+ */
+export declare function principalOf(invocation: RemoteInvocation | undefined): Principal | undefined;
+//# sourceMappingURL=principal.d.ts.map

package/lib/types/principal.js

@@ -0,0 +1,15 @@
+/**
+ * Reads the non-owner caller of the current Remote call.
+ * @module @deepseek-ai/dsh-typert-protocol/principal
+ */
+/**
+ * The identity a Remote-call producer records on durable output.
+ * @param invocation - `ctx.invocation`; `undefined` outside a Remote call.
+ * @returns the caller's principal when it is not the owner; `undefined` for the
+ *   owner and for trusted in-process code outside a Remote call.
+ */
+export function principalOf(invocation) {
+    const principal = invocation?.peer.principal;
+    return principal?.kind === 'owner' ? undefined : principal;
+}
+//# sourceMappingURL=principal.js.map

package/lib/types/remote-access.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Resources of Remote access control: the built-in identity-less `global`
+ * resource and one resource per identity of a kind declared in
+ * `TypertResourceMap`. Resources are independent: access to one resource
+ * implies no access to any other.
+ * @module @deepseek-ai/dsh-typert-protocol/remote-access
+ */
+import type { TypertResourceId, TypertResourceKind, TypertResourceMap } from './types.ts';
+/** One resource kind: the built-in `global` kind or a declared kind. */
+export type RemoteAccessResourceKind = 'global' | TypertResourceKind;
+/**
+ * One resource a call or forwarded event touches: `global`, or one identity
+ * of a declared kind. Identities are wire values, read before any lookup
+ * resolves or validates them.
+ */
+export type RemoteAccessResource = {
+    readonly kind: 'global';
+} | {
+    [Kind in TypertResourceKind]: {
+        readonly kind: Kind;
+        readonly id: TypertResourceId<TypertResourceMap[Kind]>;
+    };
+}[TypertResourceKind];
+/**
+ * The resource variant of one kind: `{ kind: 'global' }` for `global`, else
+ * that kind with its identity.
+ * @template K - the resource kind to select.
+ */
+export type RemoteAccessResourceOf<K extends RemoteAccessResourceKind> = Extract<RemoteAccessResource, {
+    readonly kind: K;
+}>;
+//# sourceMappingURL=remote-access.d.ts.map

package/lib/types/remote-access.js

@@ -0,0 +1,9 @@
+/**
+ * Resources of Remote access control: the built-in identity-less `global`
+ * resource and one resource per identity of a kind declared in
+ * `TypertResourceMap`. Resources are independent: access to one resource
+ * implies no access to any other.
+ * @module @deepseek-ai/dsh-typert-protocol/remote-access
+ */
+export {};
+//# sourceMappingURL=remote-access.js.map

package/lib/types/remote-info.d.ts

@@ -0,0 +1,21 @@
+/** Lazy assembly of generated Remote definitions using caller-supplied Zod; no runtime imports. */
+import type { z } from 'zod';
+import type { InvocationDescriptor, TypertRemoteInfo, TypertRemoteMethod, TypertRemoteSpec } from './types.ts';
+type Method = TypertRemoteMethod<object, unknown> | TypertRemoteMethod<object, unknown, 'stream', unknown>;
+/**
+ * Retain one generated definition per endpoint without constructing parsers or projections.
+ * The class instance builds its shared descriptor/method index on first access;
+ * input schemas and JSON Schema projections are cached only when requested.
+ * @param spec - compiler-produced method facts and Zod factories.
+ * @param zod - the generated artifact's Zod runtime for named-input parsers.
+ * @returns a lazy, mountable info instance with no registration or transport effects.
+ */
+export declare function createTypertRemoteInfo(spec: TypertRemoteSpec, zod: typeof z): TypertRemoteInfo;
+/**
+ * Narrow a Registry descriptor to its generated direct-method capabilities.
+ * @param descriptor - a live descriptor, including possible source fallback or Context-only receivers.
+ * @returns whether generated named input and direct invocation are available.
+ */
+export declare function isTypertRemoteMethod(descriptor: InvocationDescriptor): descriptor is Method;
+export {};
+//# sourceMappingURL=remote-info.d.ts.map

package/lib/types/remote-info.js

@@ -0,0 +1,143 @@
+/** Lazy assembly of generated Remote definitions using caller-supplied Zod; no runtime imports. */
+/**
+ * Retain one generated definition per endpoint without constructing parsers or projections.
+ * The class instance builds its shared descriptor/method index on first access;
+ * input schemas and JSON Schema projections are cached only when requested.
+ * @param spec - compiler-produced method facts and Zod factories.
+ * @param zod - the generated artifact's Zod runtime for named-input parsers.
+ * @returns a lazy, mountable info instance with no registration or transport effects.
+ */
+export function createTypertRemoteInfo(spec, zod) {
+    return new RemoteInfo(spec, zod);
+}
+class RemoteInfo {
+    spec;
+    zod;
+    index;
+    constructor(spec, zod) {
+        this.spec = spec;
+        this.zod = zod;
+    }
+    get package() { return this.spec.package; }
+    get descriptors() { return this.resolve().descriptors; }
+    get methods() { return this.resolve().methods; }
+    resolve() {
+        if (this.index !== undefined)
+            return this.index;
+        const zod = this.zod;
+        const descriptors = [];
+        const methods = Object.create(null);
+        for (const [endpoint, definition] of Object.entries(this.spec.methods)) {
+            const separator = endpoint.indexOf('/');
+            const namespace = endpoint.slice(0, separator);
+            const method = endpoint.slice(separator + 1);
+            const parameters = definition.parameters.map(parameter => ({ ...parameter, wire: parameter.wire ?? parameter.name }));
+            const descriptor = {
+                ...definition,
+                id: `${this.spec.package}#${endpoint}`,
+                namespace,
+                method,
+                parameters,
+                result: definition.result.description === undefined ? definition.result : new ResultValue(definition.result),
+            };
+            if (definition.invocation.kind === 'direct') {
+                const inputs = [];
+                const direct = Object.assign(descriptor, {
+                    input(options) {
+                        const strict = options?.strict === true;
+                        return inputs[strict ? 1 : 0] ??= new NamedInput(parameters, strict, zod);
+                    },
+                    invoke(remote, input, signal) {
+                        const named = input;
+                        const values = parameters.map(parameter => named[parameter.wire]);
+                        if (definition.cancellation !== undefined)
+                            values.push(signal);
+                        // Namespace access retains the Gateway's mount checks and scoped receiver policy.
+                        const receiver = Reflect.get(remote, namespace);
+                        const call = Reflect.get(receiver, method);
+                        return call.apply(receiver, values);
+                    },
+                });
+                // The generated namespace return type is selected by this same descriptor's mode.
+                methods[endpoint] = direct;
+            }
+            descriptors.push(descriptor);
+        }
+        return this.index = { descriptors, methods };
+    }
+}
+/**
+ * Narrow a Registry descriptor to its generated direct-method capabilities.
+ * @param descriptor - a live descriptor, including possible source fallback or Context-only receivers.
+ * @returns whether generated named input and direct invocation are available.
+ */
+export function isTypertRemoteMethod(descriptor) {
+    return descriptor.invocation.kind === 'direct' && descriptor.result.mode === 'strict'
+        && 'input' in descriptor && typeof descriptor.input === 'function'
+        && 'invoke' in descriptor && typeof descriptor.invoke === 'function';
+}
+function optional(parameter) {
+    return parameter.source === 'json' && parameter.acceptsUndefined === true;
+}
+class NamedInput {
+    parameters;
+    strict;
+    zod;
+    schema;
+    projection;
+    constructor(parameters, strict, zod) {
+        this.parameters = parameters;
+        this.strict = strict;
+        this.zod = zod;
+    }
+    codec(parameter) {
+        return this.strict ? parameter.strictCodec : parameter.codec;
+    }
+    create = () => this.schema ??= this.zod.strictObject(Object.fromEntries(this.parameters.map((parameter) => {
+        const value = this.codec(parameter).create();
+        return [parameter.wire, optional(parameter) ? value.optional() : value.nonoptional()];
+    })));
+    get jsonSchema() { return this.project().jsonSchema; }
+    get jsonSchemaError() { return this.project().jsonSchemaError; }
+    project() {
+        if (this.projection !== undefined)
+            return this.projection;
+        const unavailable = this.parameters.find(parameter => this.codec(parameter).jsonSchema === undefined);
+        if (unavailable !== undefined) {
+            return this.projection = { jsonSchemaError: this.codec(unavailable).jsonSchemaError ?? `No JSON Schema for parameter ${unavailable.wire}` };
+        }
+        return this.projection = {
+            jsonSchema: {
+                type: 'object',
+                properties: Object.fromEntries(this.parameters.map(parameter => [parameter.wire, {
+                        ...this.codec(parameter).jsonSchema,
+                        ...(parameter.description === undefined ? {} : { description: parameter.description }),
+                    }])),
+                required: this.parameters.filter(parameter => !optional(parameter)).map(parameter => parameter.wire),
+                additionalProperties: false,
+            },
+        };
+    }
+}
+class ResultValue {
+    spec;
+    projection;
+    constructor(spec) {
+        this.spec = spec;
+    }
+    get mode() { return this.spec.mode; }
+    get typeSymbol() { return this.spec.typeSymbol; }
+    get create() { return this.spec.create; }
+    get decode() { return this.spec.decode; }
+    get encode() { return this.spec.encode; }
+    get description() { return this.spec.description; }
+    get jsonSchemaError() { return this.spec.jsonSchemaError; }
+    get jsonSchema() {
+        if (this.projection === undefined) {
+            const schema = this.spec.jsonSchema;
+            this.projection = { value: schema === undefined ? undefined : { ...schema, description: this.spec.description } };
+        }
+        return this.projection.value;
+    }
+}
+//# sourceMappingURL=remote-info.js.map