@newhomestar/sdk 0.2.7 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z, ZodTypeAny } from "zod";
+import type { IncomingMessage, ServerResponse } from "node:http";
 export interface ActionDef<I extends ZodTypeAny, O extends ZodTypeAny> {
     name: string;
     input: I;
@@ -7,7 +8,11 @@ export interface ActionDef<I extends ZodTypeAny, O extends ZodTypeAny> {
     fga?: {
         resourceType: string;
         relation: string;
+        resourceIdKey?: string;
+        policy?: string;
     };
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path?: string;
 }
 export interface ActionCtx {
     jobId: string;
@@ -20,31 +25,55 @@ export declare function action<I extends ZodTypeAny, O extends ZodTypeAny>(cfg:
     fga?: {
         resourceType: string;
         relation: string;
+        resourceIdKey?: string;
+        policy?: string;
     };
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path?: string;
     handler: (input: z.infer<I>, ctx: ActionCtx) => Promise<z.infer<O>>;
 }): ActionDef<I, O>;
-export interface WorkerDef {
-    name: string;
-    queue: string;
-    actions: Record<string, ActionDef<any, any>>;
-    envSpec?: {
-        name: string;
-        secret: boolean;
-        default?: string;
-    }[];
-}
+import type { NovaSpec } from './parseSpec';
+/**
+ * FGA policy hints embedded in nova.yaml
+ */
+export type FgaSpec = NovaSpec['fga'];
+import { WorkerDef } from './workerSchema';
+/**
+ * Register a worker definition - SAME API as before
+ */
 export declare function defineWorker<T extends WorkerDef>(def: T): T;
 /** Enqueue an async action and receive `{ job_id }` */
 export declare function enqueue<P extends object>(actionPath: `${string}.${string}`, payload: P): Promise<{
     job_id: string;
 }>;
+/**
+ * Create an oRPC router from a WorkerDef, mapping each action to an oRPC procedure
+ */
+export declare function createORPCRouter<T extends WorkerDef>(def: T): Record<string, any>;
+export interface ORPCServerOptions {
+    port?: number;
+    plugins?: any[];
+}
+/**
+ * Run an oRPC server with OpenAPI support - replaces runTRPCServer
+ */
+export declare function runORPCServer<T extends WorkerDef>(def: T, options?: ORPCServerOptions): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
 export declare function runWorker(def: WorkerDef): Promise<void>;
-export type { ZodTypeAny as SchemaAny, ZodTypeAny };
+export declare function generateOpenAPISpec<T extends WorkerDef>(def: T): Promise<{
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description: string;
+    };
+    paths: any;
+}>;
 /**
- * Spin up an HTTP server exposing each action under POST /<worker>/<action>
+ * Enhanced HTTP server exposing each action under configurable routes
  */
-export declare function runHttpServer(def: WorkerDef, opts?: {
+export declare function runHttpServer<T extends WorkerDef>(def: T, opts?: {
     port?: number;
 }): void;
+export type { ZodTypeAny as SchemaAny, ZodTypeAny };
 export { parseNovaSpec } from "./parseSpec";
 export type { NovaSpec } from "./parseSpec";

package/dist/index.js

@@ -7,22 +7,57 @@ exports.parseNovaSpec = void 0;
 exports.action = action;
 exports.defineWorker = defineWorker;
 exports.enqueue = enqueue;
+exports.createORPCRouter = createORPCRouter;
+exports.runORPCServer = runORPCServer;
 exports.runWorker = runWorker;
+exports.generateOpenAPISpec = generateOpenAPISpec;
 exports.runHttpServer = runHttpServer;
 const dotenv_1 = __importDefault(require("dotenv"));
 const supabase_js_1 = require("@supabase/supabase-js");
+const sdk_1 = require("@openfga/sdk");
+// TODO: Install oRPC dependencies
+// import { os } from "@orpc/server";
+// import { OpenAPIHandler } from "@orpc/openapi/node";
+// Temporary stubs for oRPC until dependencies are installed
+const os = {
+    route: (config) => ({
+        input: (schema) => ({
+            output: (schema) => ({
+                handler: (handler) => ({ _route: config, _input: schema, _output: schema, _handler: handler })
+            })
+        })
+    })
+};
+const OpenAPIHandler = class {
+    constructor(router, options) { }
+    async handle(req, res, context) {
+        return { matched: false };
+    }
+};
+const node_http_1 = require("node:http");
 if (!process.env.RUNTIME_SUPABASE_URL) {
     // local dev – read .env.local
     dotenv_1.default.config({ path: ".env.local", override: true });
 }
 function action(cfg) {
-    return { name: cfg.name ?? "unnamed", ...cfg };
+    return {
+        name: cfg.name ?? "unnamed",
+        method: cfg.method ?? 'POST',
+        path: cfg.path,
+        ...cfg
+    };
 }
+// WorkerDef represents the code-level definition passed into defineWorker()
+const workerSchema_1 = require("./workerSchema");
+/**
+ * Register a worker definition - SAME API as before
+ */
 function defineWorker(def) {
-    return def; // identity – type info retained for CLI
+    // Runtime validation of the worker definition
+    workerSchema_1.WorkerDefSchema.parse(def);
+    return def;
 }
-/*──────────────────────*  Client‑side enqueue()  *──────────────────*/
-// CLIENT_SUPABASE_… vars exist in gateways / other services
+/*──────────────────────*  Client‑side enqueue() (UNCHANGED)  *──────────────────*/
 const CLIENT_SUPABASE_URL = process.env.CLIENT_SUPABASE_PUBLIC_URL;
 const CLIENT_SUPABASE_KEY = process.env.CLIENT_SUPABASE_SERVICE_ROLE_KEY;
 let clientSupabase;
@@ -43,7 +78,77 @@ async function enqueue(actionPath, payload) {
         throw error;
     return data;
 }
-/*──────────────── Runtime harness (Supabase RPC) ───────────────*/
+/*──────────────── NEW: oRPC Router Creation ───────────────*/
+/**
+ * Create an oRPC router from a WorkerDef, mapping each action to an oRPC procedure
+ */
+function createORPCRouter(def) {
+    const procedures = {};
+    for (const [actionName, actionDef] of Object.entries(def.actions)) {
+        const method = actionDef.method || 'POST';
+        const path = actionDef.path || `/${actionName}`;
+        // Create oRPC procedure with route information
+        const procedure = os
+            .route({ method, path })
+            .input(actionDef.input)
+            .output(actionDef.output)
+            .handler(async ({ input, context }) => {
+            const ctx = {
+                jobId: context?.jobId || `orpc-${Date.now()}`,
+                progress: (percent, meta) => {
+                    console.log(`[${actionName}] Progress: ${percent}%`, meta);
+                }
+            };
+            return await actionDef.handler(input, ctx);
+        });
+        procedures[actionName] = procedure;
+    }
+    return procedures;
+}
+/**
+ * Run an oRPC server with OpenAPI support - replaces runTRPCServer
+ */
+function runORPCServer(def, options = {}) {
+    const router = createORPCRouter(def);
+    const handler = new OpenAPIHandler(router, {
+        plugins: options.plugins || []
+    });
+    const server = (0, node_http_1.createServer)(async (req, res) => {
+        try {
+            const result = await handler.handle(req, res, {
+                context: {
+                    worker: def,
+                    queue: def.queue,
+                    jobId: `http-${Date.now()}`
+                }
+            });
+            if (!result.matched) {
+                res.statusCode = 404;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: 'No procedure matched' }));
+            }
+        }
+        catch (error) {
+            console.error('[oRPC Server Error]:', error);
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    });
+    const port = options.port ?? (process.env.PORT ? parseInt(process.env.PORT) : 3000);
+    server.listen(port, () => {
+        console.log(`[nova] oRPC server "${def.name}" listening on http://localhost:${port}`);
+        console.log(`[nova] OpenAPI spec available at http://localhost:${port}/openapi.json`);
+        // Log available endpoints
+        Object.entries(def.actions).forEach(([actionName, actionDef]) => {
+            const method = actionDef.method || 'POST';
+            const path = actionDef.path || `/${actionName}`;
+            console.log(`[nova] ${method} ${path} -> ${actionName}`);
+        });
+    });
+    return server;
+}
+/*──────────────── Runtime harness (Supabase RPC) - UNCHANGED ───────────────*/
 const RUNTIME_SUPABASE_URL = process.env.RUNTIME_SUPABASE_URL;
 const RUNTIME_SUPABASE_KEY = process.env.RUNTIME_SUPABASE_SERVICE_ROLE_KEY;
 const runtime = RUNTIME_SUPABASE_URL && RUNTIME_SUPABASE_KEY
@@ -78,6 +183,47 @@ async function runWorker(def) {
                 await nack(msg.msg_id, def.queue);
                 continue;
             }
+            // FGA enforcement (unchanged from original)
+            const hints = act.fga ? (Array.isArray(act.fga) ? act.fga : [act.fga]) : [];
+            if (hints.length) {
+                const apiEndpoint = process.env.OPENFGA_API_ENDPOINT;
+                const storeId = process.env.OPENFGA_STORE_ID;
+                const authToken = process.env.OPENFGA_AUTH_TOKEN;
+                if (!apiEndpoint || !storeId || !authToken) {
+                    throw new Error('Missing OPENFGA_API_ENDPOINT, OPENFGA_STORE_ID, or OPENFGA_AUTH_TOKEN for FGA enforcement');
+                }
+                const fgaClient = new sdk_1.OpenFgaClient({ apiUrl: apiEndpoint, storeId });
+                let authorized = true;
+                for (const hint of hints) {
+                    const key = hint.resourceIdKey;
+                    if (!key) {
+                        throw new Error(`Missing resourceIdKey for FGA hint on action '${actName}'`);
+                    }
+                    const id = payload[key];
+                    if (!id) {
+                        throw new Error(`Payload field '${key}' required for FGA hint on action '${actName}'`);
+                    }
+                    const tupleKey = {
+                        user: `user:${user_id}`,
+                        relation: hint.relation,
+                        object: `${hint.resourceType}:${id}`
+                    };
+                    const result = await fgaClient.check({
+                        user: tupleKey.user,
+                        relation: tupleKey.relation,
+                        object: tupleKey.object
+                    });
+                    if (!result.allowed) {
+                        authorized = false;
+                        break;
+                    }
+                }
+                if (!authorized) {
+                    await runtime.from("jobs").update({ status: "failed", error: "Unauthorized" }).eq("id", jobId);
+                    await ack(msg.msg_id, def.queue);
+                    continue;
+                }
+            }
             try {
                 const parsedInput = act.input.parse(payload);
                 const ctx = {
@@ -104,17 +250,59 @@ async function nack(id, q) {
     await runtime.schema("pgmq_public").rpc("nack", { queue_name: q, message_id: id });
 }
 function delay(ms) { return new Promise(r => setTimeout(r, ms)); }
-//──────────────────── HTTP Server Harness ─────────────────────
+/*──────────────── NEW: OpenAPI Spec Generation ───────────────*/
+async function generateOpenAPISpec(def) {
+    // This would use oRPC's built-in OpenAPI generation
+    // For now, return a basic spec structure
+    return {
+        openapi: "3.0.0",
+        info: {
+            title: `${def.name} API`,
+            version: "1.0.0",
+            description: `OpenAPI specification for Nova worker: ${def.name}`
+        },
+        paths: Object.entries(def.actions).reduce((paths, [actionName, actionDef]) => {
+            const method = (actionDef.method || 'POST').toLowerCase();
+            const path = actionDef.path || `/${actionName}`;
+            paths[path] = {
+                [method]: {
+                    operationId: actionName,
+                    summary: `Execute ${actionName} action`,
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: { type: 'object' } // Would be generated from Zod schema
+                            }
+                        }
+                    },
+                    responses: {
+                        '200': {
+                            description: 'Success',
+                            content: {
+                                'application/json': {
+                                    schema: { type: 'object' } // Would be generated from Zod schema
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            return paths;
+        }, {})
+    };
+}
+/*──────────────── HTTP Server Harness (Enhanced) ───────────────*/
 const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 /**
- * Spin up an HTTP server exposing each action under POST /<worker>/<action>
+ * Enhanced HTTP server exposing each action under configurable routes
  */
 function runHttpServer(def, opts = {}) {
     const app = (0, express_1.default)();
     app.use(body_parser_1.default.json());
     for (const [actionName, act] of Object.entries(def.actions)) {
-        const route = `/${def.name}/${actionName}`;
+        const method = (act.method || 'POST').toLowerCase();
+        const route = act.path || `/${def.name}/${actionName}`;
         // unified handler: parse JSON body or default to empty object
         const handler = async (req, res) => {
             try {
@@ -129,16 +317,21 @@ function runHttpServer(def, opts = {}) {
                 res.status(400).json({ error: err.message });
             }
         };
-        // POST /<worker>/<action>
-        app.post(route, handler);
-        // expose health under GET /health for liveness checks
-        if (actionName === 'health') {
-            app.get(`/${actionName}`, handler);
+        // Register route with specified HTTP method
+        app[method](route, handler);
+        // Special case: expose health checks under GET /health for liveness checks
+        if (actionName === 'health' && method !== 'get') {
+            app.get('/health', handler);
         }
     }
     const port = opts.port ?? (process.env.PORT ? parseInt(process.env.PORT) : 3000);
     app.listen(port, () => {
         console.log(`[nova] HTTP server listening on http://localhost:${port}`);
+        Object.entries(def.actions).forEach(([actionName, actionDef]) => {
+            const method = (actionDef.method || 'POST').toUpperCase();
+            const path = actionDef.path || `/${def.name}/${actionName}`;
+            console.log(`[nova] ${method} ${path} -> ${actionName}`);
+        });
     });
 }
 // YAML spec parsing utility

package/dist/parseSpec.d.ts

@@ -7,20 +7,8 @@ export declare const NovaSpecSchema: z.ZodObject<{
         displayName: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         icon: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        displayName?: string | undefined;
-        description?: string | undefined;
-        icon?: string | undefined;
-        tags?: string[] | undefined;
-    }, {
-        name: string;
-        displayName?: string | undefined;
-        description?: string | undefined;
-        icon?: string | undefined;
-        tags?: string[] | undefined;
-    }>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
     spec: z.ZodObject<{
         runtime: z.ZodObject<{
             type: z.ZodString;
@@ -28,14 +16,8 @@ export declare const NovaSpecSchema: z.ZodObject<{
             resources: z.ZodObject<{
                 cpu: z.ZodString;
                 memory: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                cpu: string;
-                memory: string;
-            }, {
-                cpu: string;
-                memory: string;
-            }>;
-            command: z.ZodArray<z.ZodString, "many">;
+            }, z.core.$strip>;
+            command: z.ZodArray<z.ZodString>;
             queue: z.ZodString;
             port: z.ZodNumber;
             envSpec: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -43,50 +25,8 @@ export declare const NovaSpecSchema: z.ZodObject<{
                 value: z.ZodOptional<z.ZodString>;
                 secret: z.ZodOptional<z.ZodBoolean>;
                 default: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }, {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }>, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        }, {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
         actions: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             displayName: z.ZodOptional<z.ZodString>;
@@ -98,341 +38,33 @@ export declare const NovaSpecSchema: z.ZodObject<{
             schema: z.ZodOptional<z.ZodObject<{
                 input: z.ZodString;
                 output: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                input: string;
-                output: string;
-            }, {
-                input: string;
-                output: string;
-            }>>;
+            }, z.core.$strip>>;
             fga: z.ZodOptional<z.ZodObject<{
                 resourceType: z.ZodString;
                 relation: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                resourceType: string;
-                relation: string;
-            }, {
-                resourceType: string;
-                relation: string;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }, {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        runtime: {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        };
-        actions: {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }[];
-    }, {
-        runtime: {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        };
-        actions: {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }[];
-    }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     build: z.ZodOptional<z.ZodObject<{
         dockerfile: z.ZodString;
         context: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        dockerfile: string;
-        context: string;
-    }, {
-        dockerfile: string;
-        context: string;
-    }>>;
+    }, z.core.$strip>>;
     ui: z.ZodOptional<z.ZodObject<{
         category: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        category?: string | undefined;
-        color?: string | undefined;
-    }, {
-        category?: string | undefined;
-        color?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     fga: z.ZodOptional<z.ZodObject<{
         types: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
-            relations: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
+            relations: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
                 computedUserset: z.ZodObject<{
                     object: z.ZodString;
                     relation: z.ZodString;
-                }, "strip", z.ZodTypeAny, {
-                    object: string;
-                    relation: string;
-                }, {
-                    object: string;
-                    relation: string;
-                }>;
-            }, "strip", z.ZodTypeAny, {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }, {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>]>>;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }, {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        types: {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }[];
-    }, {
-        types: {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }[];
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    apiVersion: string;
-    kind: string;
-    metadata: {
-        name: string;
-        displayName?: string | undefined;
-        description?: string | undefined;
-        icon?: string | undefined;
-        tags?: string[] | undefined;
-    };
-    spec: {
-        runtime: {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        };
-        actions: {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }[];
-    };
-    fga?: {
-        types: {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }[];
-    } | undefined;
-    build?: {
-        dockerfile: string;
-        context: string;
-    } | undefined;
-    ui?: {
-        category?: string | undefined;
-        color?: string | undefined;
-    } | undefined;
-}, {
-    apiVersion: string;
-    kind: string;
-    metadata: {
-        name: string;
-        displayName?: string | undefined;
-        description?: string | undefined;
-        icon?: string | undefined;
-        tags?: string[] | undefined;
-    };
-    spec: {
-        runtime: {
-            type: string;
-            image: string;
-            resources: {
-                cpu: string;
-                memory: string;
-            };
-            command: string[];
-            queue: string;
-            port: number;
-            envSpec?: {
-                name: string;
-                value?: string | undefined;
-                secret?: boolean | undefined;
-                default?: string | undefined;
-            }[] | undefined;
-        };
-        actions: {
-            name: string;
-            displayName?: string | undefined;
-            description?: string | undefined;
-            icon?: string | undefined;
-            async?: boolean | undefined;
-            input?: unknown;
-            output?: unknown;
-            schema?: {
-                input: string;
-                output: string;
-            } | undefined;
-            fga?: {
-                resourceType: string;
-                relation: string;
-            } | undefined;
-        }[];
-    };
-    fga?: {
-        types: {
-            name: string;
-            relations: Record<string, string[] | {
-                computedUserset: {
-                    object: string;
-                    relation: string;
-                };
-            }>;
-        }[];
-    } | undefined;
-    build?: {
-        dockerfile: string;
-        context: string;
-    } | undefined;
-    ui?: {
-        category?: string | undefined;
-        color?: string | undefined;
-    } | undefined;
-}>;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
 export type NovaSpec = z.infer<typeof NovaSpecSchema>;
 /**
  * Parse nova.yaml content and validate against the NovaSpec schema.

package/dist/parseSpec.js

@@ -95,8 +95,8 @@ function parseNovaSpec(yamlContent) {
     }
     catch (e) {
         if (e instanceof zod_1.z.ZodError) {
-            const details = e.errors
-                .map(err => `Path '${err.path.join(".")}': ${err.message}`)
+            const details = e.issues
+                .map((issue) => `Path '${issue.path.join(".")}': ${issue.message}`)
                 .join("; ");
             throw new Error(`nova.yaml validation error(s): ${details}`);
         }

package/dist/workerSchema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/**
+ * Schema for code-level defineWorker() argument.
+ * This enforces worker metadata, actions, envSpec, and optional FGA hints.
+ */
+export declare const WorkerDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    queue: z.ZodString;
+    envSpec: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        secret: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    fga: z.ZodOptional<z.ZodObject<{
+        types: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            relations: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                computedUserset: z.ZodObject<{
+                    object: z.ZodString;
+                    relation: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        input: z.ZodAny;
+        output: z.ZodAny;
+        method: z.ZodOptional<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            DELETE: "DELETE";
+            PATCH: "PATCH";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        fga: z.ZodOptional<z.ZodObject<{
+            resourceType: z.ZodString;
+            relation: z.ZodString;
+            resourceIdKey: z.ZodOptional<z.ZodString>;
+            policy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        handler: z.ZodAny;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkerDef = z.infer<typeof WorkerDefSchema>;

package/dist/workerSchema.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerDefSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for code-level defineWorker() argument.
+ * This enforces worker metadata, actions, envSpec, and optional FGA hints.
+ */
+exports.WorkerDefSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    queue: zod_1.z.string(),
+    // Optional environment variable spec for nova.yaml generation
+    envSpec: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string(), secret: zod_1.z.boolean(), default: zod_1.z.string().optional() })).optional(),
+    // Optional top-level FGA policy types
+    fga: zod_1.z.object({
+        types: zod_1.z.array(zod_1.z.object({
+            name: zod_1.z.string(),
+            relations: zod_1.z.record(zod_1.z.string(), zod_1.z.union([
+                zod_1.z.array(zod_1.z.string()),
+                zod_1.z.object({ computedUserset: zod_1.z.object({ object: zod_1.z.string(), relation: zod_1.z.string() }) })
+            ])),
+        }))
+    }).optional(),
+    // Map of action definitions
+    actions: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        name: zod_1.z.string().optional(),
+        input: zod_1.z.any(), // Zod schema instance expected
+        output: zod_1.z.any(), // Zod schema instance expected
+        // NEW: HTTP routing support for oRPC
+        method: zod_1.z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional(),
+        path: zod_1.z.string().optional(),
+        // Optional per-action OpenFGA hints: resource type, relation, ID key, and optional policy caveat
+        fga: zod_1.z.object({
+            resourceType: zod_1.z.string(),
+            relation: zod_1.z.string(),
+            resourceIdKey: zod_1.z.string().optional(),
+            policy: zod_1.z.string().optional(),
+        }).optional(),
+        handler: zod_1.z.any(), // function with signature (input, ctx) => Promise<…>
+    })),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newhomestar/sdk",
-  "version": "0.2.7",
+  "version": "0.4.0",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {
@@ -22,12 +22,16 @@
     "build": "tsc"
   },
   "dependencies": {
+    "@openfga/sdk": "^0.9.0",
+    "@orpc/openapi": "^0.0.53",
+    "@orpc/server": "^0.0.53",
+    "@orpc/zod": "^0.0.53",
     "@supabase/supabase-js": "^2.39.0",
+    "body-parser": "^1.20.2",
     "dotenv": "^16.4.3",
-    "zod": "^3.23.8",
     "express": "^4.18.2",
-    "body-parser": "^1.20.2",
-    "yaml": "^2.7.1"
+    "yaml": "^2.7.1",
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@types/node": "^20.11.17",