@oddington/sdk 0.1.19 → 0.1.21

package/dist/types/packages/sdk/src/public.d.ts

@@ -2,7 +2,7 @@ import type { AskInput, CapturedRecords, DigestInput, InboxFile, PublicationRequ
 import type { FileAddOptions } from '../../../shared/inbox-files.js';
 import type { RecordReadInput } from '../../../shared/record-capture.js';
 import type { RecordDeleteRequest, RecordUpdateRequest, RecordWriteRequest } from '../../../shared/record-write.js';
-export type { RoutineSchema, RoutineSchemaValue, RoutineDefinition, RoutineInput, RoutineRuntime, RoutineArtifactInput, RoutineArtifact } from './routine-definition-types.js';
+export type { RoutineSchema, RoutineSchemaValue, RoutineDefinition, RoutineInput, RoutineRuntime, RoutineAccess, RoutineCapabilities, RoutineStep, RoutineSteps, RoutineStepInput, RoutineStepResult, RoutineStepOutput, RoutineArtifactInput, RoutineArtifact } from './routine-definition-types.js';
 export declare const defineRoutine: import('./routine-definition-types.js').DefineRoutine;
 export declare const schema: import('./routine-definition-types.js').RoutineSchemaBuilders;
 export declare const file: import('./routine-definition-types.js').RoutineFileSchema;
@@ -84,53 +84,105 @@ export declare const auth: {
 /** Customer-owned module augmentation supplies types, never runtime authority. */
 export interface AppRoutineTypes {
 }
-export type AppRoutineErrorReason = 'not_enabled' | 'authority_unavailable' | 'execution_unavailable' | 'invalid_input';
+/** Generated app declarations derive inference directly from the authored export. */
+export type RoutineAppBinding<Definition> = Definition extends import('./routine-definition-types.js').RoutineDefinition<infer Input extends import('./routine-definition-types.js').RoutineSchema<unknown> | undefined, infer Steps extends import('./routine-definition-types.js').RoutineSteps, infer Result extends import('./routine-definition-types.js').RoutineSchema<unknown> | undefined, any, any, any> ? Omit<AppRoutineBinding<import('./routine-definition-types.js').RoutineSchemaValue<Input>, import('./routine-definition-types.js').RoutineSchemaValue<Result>, {
+    [Key in keyof Steps]: Awaited<ReturnType<Steps[Key]['run']>>;
+}>, 'run'> & {
+    run(...input: Input extends undefined | import('./routine-definition-types.js').RoutineSchema<unknown, true> ? [input?: Input extends undefined ? Record<string, never> : import('./routine-definition-types.js').RoutineSchemaValue<Input>] : [input: import('./routine-definition-types.js').RoutineSchemaValue<Input>]): Promise<AppRoutineHandle<import('./routine-definition-types.js').RoutineSchemaValue<Result>, {
+        [Key in keyof Steps]: Awaited<ReturnType<Steps[Key]['run']>>;
+    }>>;
+} : never;
+export type AppRoutineErrorReason = 'authority_unavailable' | 'execution_unavailable' | 'invalid_input';
 export declare class AppRoutineError extends Error {
     readonly reason: AppRoutineErrorReason;
     constructor(reason: AppRoutineErrorReason);
 }
-export type AppRoutineEvent<Result, Steps> = {
-    type: 'started';
-} | {
-    [Key in Extract<keyof Steps, string>]: {
-        type: 'step';
-        id: Key;
-    } & (Steps[Key] extends undefined ? {
-        summary?: undefined;
+export type AppRoutineHandle<Result, Steps> = {
+    current(): Promise<Omit<RunSummary, 'result'> & {
+        result?: Result;
+    }>;
+    watch(): AsyncIterable<Omit<RunSummary, 'result'> & {
+        result?: Result;
+    }>;
+    step<Key extends Extract<keyof Steps, string>>(id: Key): Promise<Omit<StepDetail, 'summary' | 'data'> & (Steps[Key] extends {
+        summary: infer Summary;
+        data?: infer Data;
+    } ? {
+        summary?: Summary;
+        data?: Data;
     } : {
-        summary: Steps[Key];
-    });
-}[Extract<keyof Steps, string>] | ({
-    type: 'finished';
-    state: 'succeeded';
-} & ([Result] extends [undefined] ? {
-    result?: undefined;
-} : {
-    result: Result;
-})) | {
-    type: 'finished';
+        summary?: unknown;
+        data?: unknown;
+    })>;
+    publish(): Promise<Omit<RunSummary, 'result'> & {
+        result?: Result;
+    }>;
+};
+export type LocalPublication = {
+    state: 'not_needed' | 'ready' | 'published';
+} | {
     state: 'failed';
-    error: 'execution_failed';
+    message: string;
+};
+export type StepDetail = {
+    id: string;
+    title: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    startedAt?: string;
+    finishedAt?: string;
+    summary?: unknown;
+    data?: unknown;
+};
+export type RunSummary = {
+    id: string;
+    routine: string;
+    placement: 'local' | 'remote';
+    status: 'queued' | 'running' | 'succeeded' | 'failed';
+    createdAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    steps: Array<Omit<StepDetail, 'data'> & {
+        detailAvailable: boolean;
+    }>;
+    result?: unknown;
+    failure?: {
+        message: string;
+    };
+    publication?: LocalPublication;
+};
+export type RunHandle = {
+    current(): Promise<RunSummary>;
+    watch(): AsyncIterable<RunSummary>;
+    step(id: string): Promise<StepDetail>;
+    publish(): Promise<RunSummary>;
+};
+export type RoutineReadiness = {
+    state: 'ready';
+    placement: 'local' | 'remote';
 } | {
-    type: 'finished';
-    state: 'cancelled';
+    state: 'unavailable';
+    reason: 'not_deployed' | 'definition_invalid' | 'capability_unavailable';
+    message: string;
 };
-export type AppRoutineHandle<Result, Steps> = {
-    events(): AsyncIterable<AppRoutineEvent<Result, Steps>>;
-    cancel(): Promise<void>;
+export type RoutineDescription = Omit<import('../../../shared/app-descriptor.js').AppRoutineDescriptor, 'connections'> & {
+    connections: Array<{
+        id: string;
+        provider: string;
+        name: string;
+        available: boolean;
+    }>;
+    readiness: RoutineReadiness;
 };
 export type AppRoutineBinding<Input, Result, Steps> = {
-    availability(): Promise<{
-        available: true;
-        steps: Extract<keyof Steps, string>[];
-    } | {
-        available: false;
-        reason: 'not_enabled' | 'authority_unavailable' | 'execution_unavailable';
-    }>;
+    describe(): Promise<RoutineDescription>;
     run(input: Input): Promise<AppRoutineHandle<Result, Steps>>;
-    recover(): Promise<AppRoutineHandle<Result, Steps>[]>;
+    runs: {
+        list(): Promise<RunSummary[]>;
+        get(id: string): Promise<RunHandle>;
+    };
 };
 export declare const app: {
+    listRoutines(): Promise<RoutineDescription[]>;
     routines: AppRoutineTypes;
 };
 /** A declared stage without a summary takes no second argument. */

package/dist/types/packages/sdk/src/routine-definition-types.d.ts

@@ -2,14 +2,37 @@ import type { AppValueSchema } from '../../../shared/app-routine-contract.js';
 import type { File } from '../../../shared/files-contract.js';
 import type { Connections } from '../../../shared/airtable-contract.js';
 import type { DataRepository } from '../../../shared/data-contract.js';
+import type { Handler } from '../../../shared/inbox-contract.js';
 import type { files, RoutinePublicationClient } from './public.js';
 declare const valueType: unique symbol;
 /** Serializable declaration; the phantom type never carries authority. */
-export type RoutineSchema<Value> = AppValueSchema & {
+export type RoutineSchema<Value, Defaulted extends boolean = boolean> = AppValueSchema & {
     readonly [valueType]?: Value;
+    default(value: Value): RoutineSchema<Value, true>;
+    readonly hasDefault?: Defaulted;
 };
 export type RoutineSchemaValue<Schema> = Schema extends RoutineSchema<infer Value> ? Value : undefined;
-export type RoutineSteps = Record<string, RoutineSchema<unknown> | null>;
+export type RoutineAccess = {
+    readonly repositories?: Readonly<Record<string, 'read' | 'write'>>;
+    readonly connections?: readonly string[];
+    readonly models?: readonly string[];
+    readonly files?: 'read' | 'read-write';
+    readonly publish?: readonly ('asks' | 'digests')[];
+};
+export type RoutineStepOutput = {
+    summary: unknown;
+    data: unknown;
+};
+export type RoutineStep<Input = any, Output extends RoutineStepOutput = RoutineStepOutput, Access extends RoutineAccess = RoutineAccess> = {
+    readonly title: string;
+    readonly run: (input: Input, os: RoutineCapabilities<Access>) => Output | Promise<Output>;
+};
+export type RoutineSteps = Record<string, {
+    readonly title: string;
+    readonly run: (...args: any[]) => RoutineStepOutput | Promise<RoutineStepOutput>;
+}>;
+export type RoutineStepInput<Step extends RoutineSteps[string]> = Parameters<Step['run']>[0];
+export type RoutineStepResult<Step extends RoutineSteps[string]> = Awaited<ReturnType<Step['run']>>;
 export type RoutineInput<Value> = Value extends object ? {
     readonly [Key in keyof Value]: RoutineInput<Value[Key]>;
 } : Value;
@@ -29,45 +52,56 @@ export type RoutineArtifact = Readonly<{
     size: number;
     sha256: string;
 }>;
-export type RoutineRuntime<Steps extends RoutineSteps> = {
+type RepositoryFor<Mode> = Mode extends 'write' ? DataRepository : Omit<DataRepository, 'changes'>;
+type ConnectionName<Access extends RoutineAccess> = Access['connections'] extends readonly (infer Name)[] ? Name extends `airtable/${infer Alias}` ? Alias : never : never;
+export type RoutineCapabilities<Access extends RoutineAccess> = {
     readonly run: {
         readonly id: string;
     };
     readonly data: {
-        repository(name: string): DataRepository;
+        repository<Name extends Extract<keyof Access['repositories'], string>>(name: Name): RepositoryFor<NonNullable<Access['repositories']>[Name]>;
+    };
+    readonly files: Access['files'] extends 'read-write' ? typeof files : Access['files'] extends 'read' ? Pick<typeof files, 'get' | 'read'> : {};
+    readonly connections: {
+        airtable(name: ConnectionName<Access>): ReturnType<Connections['airtable']>;
     };
-    readonly files: typeof files;
-    readonly connections: Connections;
-    readonly inbox: RoutinePublicationClient;
-    artifact(input: RoutineArtifactInput): Promise<RoutineArtifact>;
-    step<Key extends Extract<keyof Steps, string>>(id: Key, ...summary: Steps[Key] extends null ? [] : [summary: RoutineSchemaValue<Steps[Key]>]): Promise<void>;
+    readonly inbox: Pick<RoutinePublicationClient, (Access['publish'] extends readonly string[] ? 'asks' extends Access['publish'][number] ? 'publishAsk' : never : never) | (Access['publish'] extends readonly string[] ? 'digests' extends Access['publish'][number] ? 'publishDigest' : never : never)>;
+};
+export type RoutineRuntime<Steps extends RoutineSteps, Access extends RoutineAccess = RoutineAccess> = RoutineCapabilities<Access> & {
+    step<Key extends Extract<keyof Steps, string>>(id: Key, ...input: Parameters<Steps[Key]['run']> extends [] ? [] : [input: RoutineInput<RoutineStepInput<Steps[Key]>>]): Promise<RoutineStepResult<Steps[Key]>>;
 };
-export type RoutineDefinition<Input extends RoutineSchema<unknown> | undefined, Steps extends RoutineSteps, Result extends RoutineSchema<unknown> | undefined> = {
+export type RoutineDefinition<Input extends RoutineSchema<unknown> | undefined = RoutineSchema<unknown> | undefined, Steps extends RoutineSteps = RoutineSteps, Result extends RoutineSchema<unknown> | undefined = RoutineSchema<unknown> | undefined, Access extends RoutineAccess = RoutineAccess, Responses extends readonly Handler<any>[] = readonly Handler<any>[], Id extends string = string> = {
+    readonly id: Id;
+    readonly title?: string;
     readonly input?: Input;
     readonly steps?: Steps;
     readonly result?: Result;
-    readonly run: (input: RoutineInput<Input extends undefined ? Record<string, never> : RoutineSchemaValue<Input>>, os: RoutineRuntime<Steps>) => Result extends undefined ? void | Promise<void> : RoutineSchemaValue<Result> | Promise<RoutineSchemaValue<Result>>;
+    readonly access?: Access;
+    readonly responses?: Responses;
+    readonly run: (input: RoutineInput<Input extends undefined ? Record<string, never> : RoutineSchemaValue<Input>>, os: RoutineRuntime<Steps, Access>) => Result extends undefined ? void | Promise<void> : RoutineSchemaValue<Result> | Promise<RoutineSchemaValue<Result>>;
 };
-export type DefineRoutine = <Input extends RoutineSchema<unknown> | undefined = undefined, const Steps extends RoutineSteps = {}, Result extends RoutineSchema<unknown> | undefined = undefined>(definition: RoutineDefinition<Input, Steps, Result>) => RoutineDefinition<Input, Steps, Result>;
+export type DefineRoutine = <const Id extends string, Input extends RoutineSchema<unknown> | undefined = undefined, const Access extends RoutineAccess = {}, const Steps extends Record<string, RoutineStep<any, RoutineStepOutput, Access>> = {}, Result extends RoutineSchema<unknown> | undefined = undefined, const Responses extends readonly Handler<any>[] = readonly []>(definition: RoutineDefinition<Input, Steps, Result, Access, Responses, Id> & {
+    steps?: Steps & Record<string, RoutineStep<any, RoutineStepOutput, Access>>;
+}) => RoutineDefinition<Input, Steps, Result, Access, Responses, Id>;
 export type RoutineSchemaBuilders = {
     object<const Properties extends Record<string, RoutineSchema<unknown>>>(properties: Properties): RoutineSchema<{
         [Key in keyof Properties]: RoutineSchemaValue<Properties[Key]>;
-    }>;
+    }, false>;
     array<Item extends RoutineSchema<unknown>>(items: Item, options: {
         maxItems: number;
-    }): RoutineSchema<RoutineSchemaValue<Item>[]>;
+    }): RoutineSchema<RoutineSchemaValue<Item>[], false>;
     string(options?: {
         maxLength?: number;
-    }): RoutineSchema<string>;
+    }): RoutineSchema<string, false>;
     integer(options?: {
         minimum?: number;
         maximum?: number;
-    }): RoutineSchema<number>;
+    }): RoutineSchema<number, false>;
     number(options?: {
         minimum?: number;
         maximum?: number;
-    }): RoutineSchema<number>;
-    boolean(): RoutineSchema<boolean>;
+    }): RoutineSchema<number, false>;
+    boolean(): RoutineSchema<boolean, false>;
 };
-export type RoutineFileSchema = () => RoutineSchema<File>;
+export type RoutineFileSchema = () => RoutineSchema<File, false>;
 export {};

package/dist/types/shared/app-descriptor.d.ts

@@ -0,0 +1,21 @@
+import type { AppValueSchema } from './app-routine-contract.js';
+/** Build-time structure only. Runtime readiness and availability belong to hosts. */
+export type AppRoutineDescriptor = {
+    id: string;
+    title?: string;
+    input: AppValueSchema & {
+        default?: unknown;
+    };
+    connections: {
+        id: string;
+        provider: string;
+        name: string;
+    }[];
+    steps: {
+        id: string;
+        title: string;
+    }[];
+};
+export type AppDescriptor = {
+    routines: AppRoutineDescriptor[];
+};

package/dist/types/shared/app-routine-contract.d.ts

@@ -44,6 +44,7 @@ export declare class AppRoutineContractError extends Error {
     readonly code: 'invalid_contract' | 'invalid_value';
     constructor(code: 'invalid_contract' | 'invalid_value');
 }
+export declare function isAppRoutineName(value: unknown): value is string;
 /** One operation owns the property budget across input, result and all summaries. */
 export declare function parseAppRoutineContract(value: unknown): AppRoutineContract;
 export declare function validateRoutineSchemaValue(schema: AppValueSchema, value: unknown): void;

package/dist/types/shared/inbox-contract.d.ts

@@ -310,7 +310,11 @@ export declare function validateRecordReference(value: unknown): RecordReference
 export declare function validateRecordSource(value: unknown): RecordSource;
 export declare function validateResponseDefinition(value: unknown): ResponseDefinition;
 export declare function validateResponse(definition: unknown, value: unknown): QuestionResponse;
-export declare function defineHandler<Input extends JsonValue>(value: Handler<Input>): Handler<Input>;
+export declare function defineHandler<Input extends JsonValue, const Id extends string = string>(value: Handler<Input> & {
+    id: Id;
+}): Handler<Input> & {
+    id: Id;
+};
 export declare function respond<Input extends JsonValue>(handler: Handler<Input>, input: Input): HandlerReference;
 export declare function question(value: QuestionInput): Question;
 /** Structural validation is shared. Registered view/handler availability,

package/dist/types/shared/inbox-member-contract.d.ts

@@ -11,8 +11,8 @@ export declare const INBOX_LOCAL_INPUT_BYTES: number;
 export declare const INBOX_UUID: RegExp;
 export type InboxOperation = 'current' | 'items.list' | 'items.read' | 'items.see' | 'items.markDigestRead' | 'items.rename' | 'items.setLifecycle' | 'items.listRecipientCandidates' | 'items.addRecipient' | 'questions.list' | 'questions.answer' | 'questions.searchRecords' | 'files.read';
 export declare function isAppQuestionOperation(operation: InboxOperation): boolean;
-/** Closed wire vocabulary, shared by the SDK and its owning Worker. */
-export declare function parseInboxRequest(value: unknown): {
+/** Closed wire vocabulary. Hosts select the listing mode; input cannot select it. */
+export declare function parseInboxRequest(value: unknown, questionListContext?: 'local' | 'hosted'): {
     operation: InboxOperation;
     input: Record<string, unknown>;
 };

package/dist/types/shared/inbox-member-types.d.ts

@@ -161,6 +161,10 @@ export type InboxSearchInput = ItemRevision & {
     query: string;
     selected?: RecordReference;
 };
+/** Hosted listing relevance only; local listing uses its bound declaration. */
+export type InboxQuestionListInput = {
+    routines: readonly string[];
+};
 export interface InboxMember {
     current(): Promise<InboxCurrent>;
     items: {
@@ -181,7 +185,7 @@ export interface InboxMember {
         }): Promise<RecipientAddition>;
     };
     questions: {
-        list(): Promise<AnswerableQuestion[]>;
+        list(input?: InboxQuestionListInput): Promise<AnswerableQuestion[]>;
         answer(input: InboxAnswerInput): Promise<ResponseAcceptance>;
         searchRecords(input: InboxSearchInput): Promise<RecordSelectionResult>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddington/sdk",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Oddington routine and response-handler SDK",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",