irgen 0.2.0

package/dist/emit/frontend/runtime-emitter.js

@@ -0,0 +1,435 @@
+import path from "node:path";
+import fs from "node:fs";
+export function emitRuntime(project, srcDir, ir) {
+    const libDir = path.join(srcDir, "lib");
+    if (!fs.existsSync(libDir))
+        fs.mkdirSync(libDir, { recursive: true });
+    emitRuntimeContract(project, libDir);
+    emitRuntimeImplementation(project, libDir);
+    emitRuntimeConfig(project, libDir, ir);
+    emitRuntimeHooks(project, libDir);
+}
+function emitRuntimeContract(project, libDir) {
+    const filePath = path.join(libDir, "runtime-contract.ts");
+    const content = `/**
+ * Frontend Core — Runtime Contract
+ */
+
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+export type ResponseType = "json" | "text" | "html" | "blob";
+export type BodyType = "none" | "json" | "text" | "multipart" | "formUrlEncoded";
+
+export type Dict<T = unknown> = Record<string, T>;
+export type PathParams = Record<string, string | number>;
+export type QueryParams = Record<string, string | number | boolean | null | undefined>;
+
+export type OperationContext =
+  | { kind: "page"; pageId: string }
+  | { kind: "tableRow"; pageId: string; rowId: string }
+  | { kind: "tableBulk"; pageId: string; selectedIds: string[] }
+  | { kind: "form"; pageId: string; formId: string }
+  | { kind: "system"; reason: string };
+
+export type NormalizedErrorCode =
+  | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "VALIDATION_ERROR"
+  | "CONFLICT" | "RATE_LIMITED" | "TIMEOUT" | "NETWORK_ERROR"
+  | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
+
+export interface FieldError { field: string; message: string; code?: string; }
+
+export interface NormalizedError {
+  code: NormalizedErrorCode;
+  message: string;
+  status?: number;
+  details?: Dict;
+  fieldErrors?: FieldError[];
+  cause?: unknown;
+  raw?: unknown;
+}
+
+export type AuthState =
+  | { status: "anonymous" }
+  | { status: "authenticated"; user?: Dict; roles?: string[] }
+  | { status: "error"; error: NormalizedError };
+
+export type AuthStrategyId = string;
+export interface AuthStrategy {
+  id: AuthStrategyId;
+  attach(req: RuntimeRequest, ds: DataSourceRuntimeConfig): Promise<RuntimeRequest>;
+  loadState?: (rt: Runtime, dsId: string) => Promise<AuthState>;
+  onLoginSuccess?: (rt: Runtime, dsId: string, payload: unknown) => Promise<void>;
+  onLogout?: (rt: Runtime, dsId: string) => Promise<void>;
+}
+
+export type CsrfStrategyId = string;
+export interface CsrfStrategy {
+  id: CsrfStrategyId;
+  attach(req: RuntimeRequest, rt: Runtime, dsId: string): Promise<RuntimeRequest>;
+}
+
+export interface DataSourceRuntimeConfig {
+  id: string;
+  baseUrl: string;
+  defaultHeaders?: Record<string, string>;
+  withCredentials?: boolean;
+  timeoutMs?: number;
+  authStrategyId?: AuthStrategyId;
+  csrfStrategyId?: CsrfStrategyId;
+}
+
+export interface EnvelopeAdapter {
+  id: string;
+  extractData: (payload: unknown) => unknown;
+  extractMeta?: (payload: unknown) => unknown;
+  extractErrorPayload?: (payload: unknown) => unknown;
+}
+
+export interface PaginationResult { total?: number; nextCursor?: string; prevCursor?: string; }
+export interface PaginationAdapter { id: string; extract: (payload: unknown) => PaginationResult; }
+
+export interface RequestBodySpec {
+  type: BodyType;
+  build?: (input: unknown, ctx: OperationContext, rt: Runtime) => Promise<unknown>;
+  contentType?: string;
+  accept?: string;
+}
+
+export interface ResponseSpec {
+  type: ResponseType;
+  envelopeAdapterId?: string;
+  paginationAdapterId?: string;
+  filenameHint?: string;
+}
+
+export interface ResultHandlingSpec {
+  invalidate?: Array<{ kind: string; resourceId?: string; id?: string; operationId?: string; key?: any }>;
+  redirectTo?: (result: OperationResultNormalized, rt: Runtime) => string | null;
+  openUrl?: (result: OperationResultNormalized, rt: Runtime) => string | null;
+  downloadAs?: (result: OperationResultNormalized, rt: Runtime) => { filename: string } | null;
+  toastOnSuccess?: { kind: string; message: string };
+  toastOnError?: { kind: string; message: string };
+}
+
+export interface OperationSpec {
+  id: string;
+  datasourceId: string;
+  method: HttpMethod;
+  path: string;
+  pathParams?: (input: unknown, ctx: OperationContext, rt: Runtime) => Promise<PathParams>;
+  query?: (input: unknown, ctx: OperationContext, rt: Runtime) => Promise<QueryParams>;
+  headers?: (input: unknown, ctx: OperationContext, rt: Runtime) => Promise<Record<string, string>>;
+  body?: RequestBodySpec;
+  response: ResponseSpec;
+  resultHandling?: ResultHandlingSpec;
+  requiresAuth?: boolean;
+  requiredRoles?: string[];
+}
+
+export interface ResourceSpec {
+  id: string;
+  datasourceId: string;
+  idField?: string;
+  listOpId?: string;
+  getOpId?: string;
+  createOpId?: string;
+  updateOpId?: string;
+  deleteOpId?: string;
+}
+
+export interface RuntimeRequest {
+  url: string;
+  method: HttpMethod;
+  headers: Record<string, string>;
+  body?: unknown;
+  credentials?: RequestCredentials;
+  signal?: AbortSignal;
+  responseType: ResponseType;
+}
+
+export interface OperationResultNormalized {
+  ok: boolean;
+  status?: number;
+  data?: unknown;
+  meta?: unknown;
+  pagination?: PaginationResult;
+  error?: NormalizedError;
+  raw?: unknown;
+}
+
+export interface Runtime {
+  getDataSource(dsId: string): DataSourceRuntimeConfig;
+  getAuthState(dsId: string): AuthState;
+  execute(operationId: string, input: unknown, ctx: OperationContext): Promise<OperationResultNormalized>;
+  invalidate?(targets: any[]): void;
+}
+`;
+    project.createSourceFile(filePath, content, { overwrite: true });
+}
+function emitRuntimeImplementation(project, libDir) {
+    const filePath = path.join(libDir, "runtime.ts");
+    const content = `import type * as T from "./runtime-contract";
+
+export class BaseRuntime implements T.Runtime {
+  private authStates: Record<string, T.AuthState> = {};
+
+  constructor(
+    private datasources: T.DataSourceRuntimeConfig[],
+    private operations: T.OperationSpec[],
+    private adapters: {
+      envelope: T.EnvelopeAdapter[];
+      pagination: T.PaginationAdapter[];
+    },
+    private strategies: {
+      auth: Record<string, T.AuthStrategy>;
+      csrf: Record<string, T.CsrfStrategy>;
+    }
+  ) {}
+
+  getDataSource(dsId: string): T.DataSourceRuntimeConfig {
+    const ds = this.datasources.find((d) => d.id === dsId);
+    if (!ds) throw new Error(\`DataSource not found: \${dsId}\`);
+    return ds;
+  }
+
+  getAuthState(dsId: string): T.AuthState {
+    return this.authStates[dsId] || { status: "anonymous" };
+  }
+
+  setAuthState(dsId: string, state: T.AuthState) {
+    this.authStates[dsId] = state;
+  }
+
+  async execute(
+    operationId: string,
+    input: unknown,
+    ctx: T.OperationContext
+  ): Promise<T.OperationResultNormalized> {
+    const op = this.operations.find((o) => o.id === operationId);
+    if (!op) throw new Error(\`Operation not found: \${operationId}\`);
+
+    const ds = this.getDataSource(op.datasourceId);
+
+    try {
+      let url = \`\${ds.baseUrl}\${op.path}\`;
+      
+      if (op.pathParams) {
+        const params = await op.pathParams(input, ctx, this);
+        for (const [key, val] of Object.entries(params)) {
+          url = url.replace(\`:\${key}\`, String(val));
+        }
+      }
+
+      const queryParams = op.query ? await op.query(input, ctx, this) : {};
+      const searchParams = new URLSearchParams();
+      for (const [key, val] of Object.entries(queryParams)) {
+        if (val !== undefined && val !== null) {
+          searchParams.append(key, String(val));
+        }
+      }
+      if (searchParams.toString()) {
+        url += (url.includes("?") ? "&" : "?") + searchParams.toString();
+      }
+
+      let headers: Record<string, string> = {
+        ...ds.defaultHeaders,
+        ...(op.headers ? await op.headers(input, ctx, this) : {}),
+      };
+
+      let body: any = undefined;
+      if (op.body && op.body.type !== "none") {
+        body = op.body.build ? await op.body.build(input, ctx, this) : input;
+        
+        if (op.body.type === "json" && typeof body !== "string" && !(body instanceof FormData)) {
+          body = JSON.stringify(body);
+          headers["Content-Type"] = op.body.contentType || "application/json";
+        } else if (op.body.type === "text") {
+          headers["Content-Type"] = op.body.contentType || "text/plain";
+        }
+      }
+
+      const req: T.RuntimeRequest = {
+        url,
+        method: op.method,
+        headers,
+        body,
+        credentials: ds.withCredentials ? "include" : undefined,
+        responseType: op.response.type,
+      };
+
+      let finalReq = req;
+      if (ds.authStrategyId && this.strategies.auth[ds.authStrategyId]) {
+        finalReq = await this.strategies.auth[ds.authStrategyId].attach(finalReq, ds);
+      }
+      if (ds.csrfStrategyId && this.strategies.csrf[ds.csrfStrategyId]) {
+        finalReq = await this.strategies.csrf[ds.csrfStrategyId].attach(finalReq, this, ds.id);
+      }
+
+      const response = await fetch(finalReq.url, {
+        method: finalReq.method,
+        headers: finalReq.headers,
+        body: finalReq.body as any,
+        credentials: finalReq.credentials,
+      });
+
+      const result: T.OperationResultNormalized = {
+        ok: response.ok,
+        status: response.status,
+      };
+
+      if (!response.ok) {
+        result.error = await this.normalizeError(response);
+        return result;
+      }
+
+      let rawPayload: any;
+      if (op.response.type === "json") rawPayload = await response.json();
+      else if (op.response.type === "blob") rawPayload = await response.blob();
+      else rawPayload = await response.text();
+
+      result.raw = rawPayload;
+
+      if (op.response.envelopeAdapterId) {
+        const adapter = this.adapters.envelope.find(a => a.id === op.response.envelopeAdapterId);
+        if (adapter) {
+          result.data = adapter.extractData(rawPayload);
+          result.meta = adapter.extractMeta?.(rawPayload);
+          const err = adapter.extractErrorPayload?.(rawPayload);
+          if (err) { result.ok = false; result.error = { code: "UNKNOWN_ERROR", message: String(err), details: err }; }
+        } else { result.data = rawPayload; }
+      } else { result.data = rawPayload; }
+
+      if (op.response.paginationAdapterId) {
+        const adapter = this.adapters.pagination.find(a => a.id === op.response.paginationAdapterId);
+        if (adapter) result.pagination = adapter.extract(rawPayload);
+      }
+
+      return result;
+    } catch (err: any) {
+      return { ok: false, error: { code: "INTERNAL_ERROR", message: err.message, cause: err } };
+    }
+  }
+
+  private async normalizeError(response: Response): Promise<T.NormalizedError> {
+    const status = response.status;
+    let code: T.NormalizedErrorCode = "INTERNAL_ERROR";
+    if (status === 401) code = "UNAUTHORIZED";
+    else if (status === 403) code = "FORBIDDEN";
+    else if (status === 404) code = "NOT_FOUND";
+    else if (status === 422) code = "VALIDATION_ERROR";
+
+    let message = response.statusText;
+    let details: any = {};
+    try {
+      const payload = await response.json();
+      message = payload.message || message;
+      details = payload;
+    } catch (_) {}
+
+    return { code, message, status, details };
+  }
+
+  invalidate(targets: any[]): void {
+      // hook for UI-level cache invalidation
+  }
+}
+`;
+    project.createSourceFile(filePath, content, { overwrite: true });
+}
+function emitRuntimeConfig(project, libDir, ir) {
+    const filePath = path.join(libDir, "runtime-instance.ts");
+    const serializeLogic = (logic) => {
+        if (!logic)
+            return "undefined";
+        return `async (input: any, ctx: any, rt: any) => (rt as any).evalLogic(${JSON.stringify(logic.logic)}, undefined, { ...input, ...ctx })`;
+    };
+    const opLines = ir.operations.map(op => `  {
+    id: "${op.id}",
+    datasourceId: "${op.datasourceId}",
+    method: "${op.method}",
+    path: "${op.path}",
+    response: ${JSON.stringify(op.response)},
+    requiresAuth: ${op.requiresAuth ?? false},
+    ${op.pathParams ? `pathParams: ${serializeLogic(op.pathParams)},` : ""}
+    ${op.query ? `query: ${serializeLogic(op.query)},` : ""}
+    ${op.headers ? `headers: ${serializeLogic(op.headers)},` : ""}
+    ${op.body ? `body: { type: "${op.body.type}", build: ${serializeLogic(op.body.build)} },` : ""}
+    ${op.resultHandling ? `resultHandling: ${JSON.stringify(op.resultHandling)},` : ""}
+  }`);
+    const content = `import { BaseRuntime } from "./runtime";
+import * as T from "./runtime-contract";
+
+export const datasources: T.DataSourceRuntimeConfig[] = ${JSON.stringify(ir.datasources, null, 2)};
+
+export const operations: T.OperationSpec[] = [
+${opLines.join(",\n")}
+];
+
+export const resources: T.ResourceSpec[] = ${JSON.stringify(ir.resources, null, 2)};
+
+export const envelopeAdapters: T.EnvelopeAdapter[] = [
+  { id: "ok_data_meta", extractData: (p: any) => p?.data, extractMeta: (p: any) => p?.meta, extractErrorPayload: (p: any) => p?.error },
+  { id: "items_cursor", extractData: (p: any) => p?.items, extractMeta: (p: any) => p?.meta, extractErrorPayload: (p: any) => p?.error }
+];
+
+export const paginationAdapters: T.PaginationAdapter[] = [
+  { id: "cursor_root", extract: (p: any) => ({ nextCursor: p?.nextCursor }) }
+];
+
+export const runtime = new BaseRuntime(
+  datasources,
+  operations,
+  { envelope: envelopeAdapters, pagination: paginationAdapters },
+  { auth: {}, csrf: {} }
+);
+
+(runtime as any).evalLogic = (logic: any, fallback: any, ctx: any) => {
+    return logic; 
+};
+`;
+    project.createSourceFile(filePath, content, { overwrite: true });
+}
+function emitRuntimeHooks(project, libDir) {
+    const filePath = path.join(libDir, "hooks.ts");
+    const content = `import { useState, useCallback } from "react";
+import { runtime } from "./runtime-instance";
+import * as T from "./runtime-contract";
+
+export function useOperation(operationId: string) {
+  const [data, setData] = useState<any>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<T.NormalizedError | null>(null);
+
+  const execute = useCallback(async (input: any = {}, ctx: T.OperationContext = { kind: "system", reason: "hook" }) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await runtime.execute(operationId, input, ctx);
+      if (result.ok) {
+        setData(result.data);
+        return result;
+      } else {
+        setError(result.error || { code: "UNKNOWN_ERROR", message: "Failed" } as any);
+        return result;
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [operationId]);
+
+  return { data, loading, error, execute };
+}
+
+export function useResource(resourceId: string) {
+  const res = runtime.getDataSource(resourceId); // this is just a placeholder for finding the resource
+  return {
+      list: useOperation(\`\${resourceId}.list\`),
+      get: useOperation(\`\${resourceId}.get\`),
+      create: useOperation(\`\${resourceId}.create\`),
+      update: useOperation(\`\${resourceId}.update\`),
+      delete: useOperation(\`\${resourceId}.delete\`),
+  };
+}
+`;
+    project.createSourceFile(filePath, content, { overwrite: true });
+}
+//# sourceMappingURL=runtime-emitter.js.map

package/dist/emit/frontend/runtime-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-emitter.js","sourceRoot":"","sources":["../../../src/emit/frontend/runtime-emitter.ts"],"names":[],"mappings":"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"}

package/dist/emit/frontend/runtime-template.d.ts

@@ -0,0 +1,28 @@
+import type { Runtime, OperationSpec, OperationContext, OperationResultNormalized, DataSourceRuntimeConfig, AuthState, EnvelopeAdapter, PaginationAdapter } from "../../ir/frontend-contract.js";
+/**
+ * Headless Runtime Implementation (Phase 0 Prototype)
+ */
+export declare class BaseRuntime implements Runtime {
+    private datasources;
+    private operations;
+    private adapters;
+    private strategies;
+    private authStates;
+    constructor(datasources: DataSourceRuntimeConfig[], operations: OperationSpec[], adapters: {
+        envelope: EnvelopeAdapter[];
+        pagination: PaginationAdapter[];
+    }, strategies: {
+        auth: any;
+        csrf: any;
+    });
+    getDataSource(dsId: string): DataSourceRuntimeConfig;
+    getAuthState(dsId: string): AuthState;
+    setAuthState(dsId: string, state: AuthState): void;
+    execute(operationId: string, input: unknown, ctx: OperationContext): Promise<OperationResultNormalized>;
+    private normalizeError;
+    private normalizePayloadError;
+    private normalizeException;
+    private handleResultSignals;
+    invalidate(targets: any): void;
+}
+//# sourceMappingURL=runtime-template.d.ts.map

package/dist/emit/frontend/runtime-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-template.d.ts","sourceRoot":"","sources":["../../../src/emit/frontend/runtime-template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,OAAO,EACP,aAAa,EACb,gBAAgB,EAChB,yBAAyB,EACzB,uBAAuB,EACvB,SAAS,EAIT,eAAe,EACf,iBAAiB,EACpB,MAAM,+BAA+B,CAAC;AAEvC;;GAEG;AACH,qBAAa,WAAY,YAAW,OAAO;IAInC,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;IATtB,OAAO,CAAC,UAAU,CAAiC;gBAGvC,WAAW,EAAE,uBAAuB,EAAE,EACtC,UAAU,EAAE,aAAa,EAAE,EAC3B,QAAQ,EAAE;QACd,QAAQ,EAAE,eAAe,EAAE,CAAC;QAC5B,UAAU,EAAE,iBAAiB,EAAE,CAAC;KACnC,EACO,UAAU,EAAE;QAChB,IAAI,EAAE,GAAG,CAAC;QACV,IAAI,EAAE,GAAG,CAAC;KACb;IAGL,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB;IAMpD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAIrC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS;IAIrC,OAAO,CACT,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACtB,OAAO,CAAC,yBAAyB,CAAC;YAsJvB,cAAc;IAsB5B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,mBAAmB;IAQ3B,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;CAGjC"}

package/dist/emit/frontend/runtime-template.js

@@ -0,0 +1,218 @@
+/**
+ * Headless Runtime Implementation (Phase 0 Prototype)
+ */
+export class BaseRuntime {
+    datasources;
+    operations;
+    adapters;
+    strategies;
+    authStates = {};
+    constructor(datasources, operations, adapters, strategies) {
+        this.datasources = datasources;
+        this.operations = operations;
+        this.adapters = adapters;
+        this.strategies = strategies;
+    }
+    getDataSource(dsId) {
+        const ds = this.datasources.find((d) => d.id === dsId);
+        if (!ds)
+            throw new Error(`DataSource not found: ${dsId}`);
+        return ds;
+    }
+    getAuthState(dsId) {
+        return this.authStates[dsId] || { status: "anonymous" };
+    }
+    setAuthState(dsId, state) {
+        this.authStates[dsId] = state;
+    }
+    async execute(operationId, input, ctx) {
+        const op = this.operations.find((o) => o.id === operationId);
+        if (!op)
+            throw new Error(`Operation not found: ${operationId}`);
+        const ds = this.getDataSource(op.datasourceId);
+        try {
+            // 1. Build initial request
+            let url = `${ds.baseUrl}${op.path}`;
+            // Resolve path params
+            if (op.pathParams) {
+                const params = await op.pathParams(input, ctx, this);
+                for (const [key, val] of Object.entries(params)) {
+                    url = url.replace(`:${key}`, String(val));
+                }
+            }
+            // Resolve query params
+            const queryParams = op.query ? await op.query(input, ctx, this) : {};
+            const searchParams = new URLSearchParams();
+            for (const [key, val] of Object.entries(queryParams)) {
+                if (val !== undefined && val !== null) {
+                    searchParams.append(key, String(val));
+                }
+            }
+            if (searchParams.toString()) {
+                url += (url.includes("?") ? "&" : "?") + searchParams.toString();
+            }
+            let headers = {
+                ...ds.defaultHeaders,
+                ...(op.headers ? await op.headers(input, ctx, this) : {}),
+            };
+            let body = undefined;
+            if (op.body && op.body.type !== "none") {
+                body = op.body.build ? await op.body.build(input, ctx, this) : input;
+                if (op.body.type === "json" && typeof body !== "string" && !(body instanceof FormData)) {
+                    body = JSON.stringify(body);
+                    headers["Content-Type"] = op.body.contentType || "application/json";
+                }
+                else if (op.body.type === "text") {
+                    headers["Content-Type"] = op.body.contentType || "text/plain";
+                }
+                // Note: multipart (FormData) let fetch set the content-type with boundary
+            }
+            if (op.response.type === "json") {
+                headers["Accept"] = op.response.envelopeAdapterId ? "application/json" : "*/*";
+            }
+            let req = {
+                url,
+                method: op.method,
+                headers,
+                body,
+                credentials: ds.withCredentials ? "include" : undefined,
+                responseType: op.response.type,
+            };
+            // 2. Apply Auth Strategy
+            if (ds.authStrategyId) {
+                const strategy = this.strategies.auth[ds.authStrategyId];
+                if (strategy) {
+                    req = await strategy.attach(req, ds);
+                }
+            }
+            // 3. Apply CSRF Strategy
+            if (ds.csrfStrategyId) {
+                const strategy = this.strategies.csrf[ds.csrfStrategyId];
+                if (strategy) {
+                    req = await strategy.attach(req, this, ds.id);
+                }
+            }
+            // 4. Perform Fetch
+            const response = await fetch(req.url, {
+                method: req.method,
+                headers: req.headers,
+                body: req.body,
+                credentials: req.credentials,
+                signal: req.signal,
+            });
+            // 5. Build Result
+            const result = {
+                ok: response.ok,
+                status: response.status,
+            };
+            if (!response.ok) {
+                result.error = await this.normalizeError(response);
+                return result;
+            }
+            // 6. Parse and Normalize Response
+            let rawPayload;
+            if (op.response.type === "json") {
+                rawPayload = await response.json();
+            }
+            else if (op.response.type === "text" || op.response.type === "html") {
+                rawPayload = await response.text();
+            }
+            else if (op.response.type === "blob") {
+                rawPayload = await response.blob();
+            }
+            result.raw = rawPayload;
+            // Apply Envelope Adapter
+            if (op.response.envelopeAdapterId) {
+                const adapter = this.adapters.envelope.find((a) => a.id === op.response.envelopeAdapterId);
+                if (adapter) {
+                    result.data = adapter.extractData(rawPayload);
+                    result.meta = adapter.extractMeta?.(rawPayload);
+                    const errorPayload = adapter.extractErrorPayload?.(rawPayload);
+                    if (errorPayload) {
+                        result.ok = false;
+                        result.error = this.normalizePayloadError(errorPayload, response.status);
+                    }
+                }
+                else {
+                    result.data = rawPayload;
+                }
+            }
+            else {
+                result.data = rawPayload;
+            }
+            // Apply Pagination Adapter
+            if (op.response.paginationAdapterId) {
+                const adapter = this.adapters.pagination.find((a) => a.id === op.response.paginationAdapterId);
+                if (adapter) {
+                    result.pagination = adapter.extract(rawPayload);
+                }
+            }
+            // 7. Handle Outcomes (Toasts, Invalidations, etc. - usually delegated to UI hooks but runtime can signal)
+            if (result.ok && op.resultHandling) {
+                this.handleResultSignals(op.resultHandling, result);
+            }
+            return result;
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: this.normalizeException(err),
+            };
+        }
+    }
+    async normalizeError(response) {
+        const status = response.status;
+        let code = "INTERNAL_ERROR";
+        let message = response.statusText;
+        if (status === 401)
+            code = "UNAUTHORIZED";
+        else if (status === 403)
+            code = "FORBIDDEN";
+        else if (status === 404)
+            code = "NOT_FOUND";
+        else if (status === 422)
+            code = "VALIDATION_ERROR";
+        else if (status === 409)
+            code = "CONFLICT";
+        else if (status === 429)
+            code = "RATE_LIMITED";
+        let details = {};
+        try {
+            const payload = await response.json();
+            message = payload.message || message;
+            details = payload;
+        }
+        catch (_) { }
+        return { code, message, status, details };
+    }
+    normalizePayloadError(payload, status) {
+        return {
+            code: "UNKNOWN_ERROR",
+            message: typeof payload === "string" ? payload : (payload.message || "Operation failed"),
+            details: payload,
+            status,
+        };
+    }
+    normalizeException(err) {
+        if (err.name === "AbortError")
+            return { code: "TIMEOUT", message: "Request timed out" };
+        if (err instanceof TypeError)
+            return { code: "NETWORK_ERROR", message: "Network error or CORS issue" };
+        return {
+            code: "INTERNAL_ERROR",
+            message: err.message || "An unexpected error occurred",
+            cause: err,
+        };
+    }
+    handleResultSignals(spec, result) {
+        // In a real implementation, this would trigger event emitters or state updates
+        // that the UI hooks (useOperation) listen to.
+        if (spec.invalidate && typeof this.invalidate === "function") {
+            this.invalidate(spec.invalidate);
+        }
+    }
+    invalidate(targets) {
+        // Implementation for cache invalidation (e.g. TanStack Query integration)
+    }
+}
+//# sourceMappingURL=runtime-template.js.map