@oddington/sdk 0.1.6 → 0.1.7

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

@@ -58,12 +58,76 @@ export type HostedSessionSource = {
         };
     };
 };
-/** OS-owned HTTPS browser bootstrap. Reinitialization replaces the previous context. */
+/** OS-owned hosted or exact-origin local browser bootstrap. Reinitialization replaces the context. */
 export declare const os: {
     init(options: {
         auth: HostedSessionSource;
     }): void;
 };
+/** Customer-owned module augmentation supplies types, never runtime authority. */
+export interface AppRoutineTypes {
+}
+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;
+    } : {
+        summary: Steps[Key];
+    });
+}[Extract<keyof Steps, string>] | ({
+    type: 'finished';
+    state: 'succeeded';
+} & ([Result] extends [undefined] ? {
+    result?: undefined;
+} : {
+    result: Result;
+})) | {
+    type: 'finished';
+    state: 'failed';
+    error: 'execution_failed';
+} | {
+    type: 'finished';
+    state: 'cancelled';
+};
+export type AppRoutineHandle<Result, Steps> = {
+    events(): AsyncIterable<AppRoutineEvent<Result, Steps>>;
+    cancel(): Promise<void>;
+};
+export type AppRoutineBinding<Input, Result, Steps> = {
+    availability(): Promise<{
+        available: true;
+        steps: Extract<keyof Steps, string>[];
+    } | {
+        available: false;
+        reason: 'authority_unavailable' | 'execution_unavailable';
+    }>;
+    run(input: Input): Promise<AppRoutineHandle<Result, Steps>>;
+    recover(): Promise<AppRoutineHandle<Result, Steps>[]>;
+};
+export declare const app: {
+    routines: AppRoutineTypes;
+};
+/** A declared stage without a summary takes no second argument. */
+export type AppRunContext<Input, Result, Steps> = {
+    readonly input: AppRunInput<Input>;
+    step<Key extends Extract<keyof Steps, string>>(id: Key, ...summary: Steps[Key] extends undefined ? [] : [summary: Steps[Key]]): Promise<void>;
+    finish(...result: [Result] extends [undefined] ? [] : [result: Result]): Promise<void>;
+};
+export type AppRunInput<Value> = Value extends object ? {
+    readonly [Key in keyof Value]: AppRunInput<Value[Key]>;
+} : Value;
+export declare const appRun: {
+    current<Input = unknown, Result = undefined, Steps = Record<string, undefined>>(): AppRunContext<Input, Result, Steps> | undefined;
+};
 export type InboxRequester = (path: string, init?: RequestInit) => Promise<Response>;
 export type RoutinePublicationClientOptions = {
     workspace?: string;

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

@@ -61,6 +61,8 @@ export declare class FileOperationError extends Error {
     constructor(code: FileErrorCode, status: number, retryable?: boolean);
 }
 export declare const FILE_ID_PATTERN: RegExp;
+/** Descriptor admission is independent of each runtime's supported writes. */
+export declare const FILE_ORIGINAL_MAX_BYTES: number;
 /** Treat descriptor transport as untrusted; no provider fields escape the boundary. */
 export declare function parseFileDescriptor(value: unknown): File;
 export declare function parseEnrichmentDescriptor(value: unknown): FileEnrichment;

package/package.json

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