@decaf-ts/integrations 0.3.4 → 0.3.5

package/lib/esm/kibana/services/KibanaUserService.js

@@ -11,6 +11,7 @@ import { BadRequestError, ConflictError, InternalError, NotFoundError, } from "@
 import { ClientBasedService, service } from "@decaf-ts/core";
 import Axios from "axios";
 import * as https from "node:https";
+import { resolveKibanaIsProduction } from "./runtime.js";
 import { KibanaAuthService } from "./KibanaAuthService.js";
 export class KibanaUserService extends ClientBasedService {
     async initialize(...args) {
@@ -86,7 +87,7 @@ export class KibanaUserService extends ClientBasedService {
             baseURL: `${config.protocol}://${config.host}`,
             validateStatus: () => true,
             httpsAgent: new https.Agent({
-                rejectUnauthorized: (this.config.isProduction()),
+                rejectUnauthorized: (resolveKibanaIsProduction(this.config)),
             }),
         });
     }
@@ -136,7 +137,7 @@ export class KibanaUserService extends ClientBasedService {
                 : undefined,
             validateStatus: () => true,
             httpsAgent: new https.Agent({
-                rejectUnauthorized: (this.config.isProduction()),
+                rejectUnauthorized: (resolveKibanaIsProduction(this.config)),
             }),
             ...extra,
         });
@@ -146,4 +147,4 @@ __decorate([
     service(),
     __metadata("design:type", KibanaAuthService)
 ], KibanaUserService.prototype, "authService", void 0);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KibanaUserService.js","sourceRoot":"","sources":["../../../../src/kibana/services/KibanaUserService.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BadRequestError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { ContextualArgs, MaybeContextualArg } from \"@decaf-ts/core\";\nimport { ClientBasedService, service } from \"@decaf-ts/core\";\nimport type { KibanaSetupConfig, KibanaUser } from \"../types\";\nimport Axios, { AxiosInstance } from \"axios\";\nimport * as https from \"node:https\";\nimport { KibanaAuthService } from \"./KibanaAuthService\";\n\nexport class KibanaUserService extends ClientBasedService<\n  AxiosInstance,\n  KibanaSetupConfig\n> {\n  @service()\n  protected authService!: KibanaAuthService;\n\n  async initialize(\n    ...args: MaybeContextualArg<any>\n  ): Promise<{ config: KibanaSetupConfig; client: AxiosInstance }> {\n    const { ctxArgs } = (await this.logCtx(args, \"initialize\", true)).for(\n      this.initialize\n    );\n    const config = ctxArgs[0] as KibanaSetupConfig;\n    this._config = config;\n    const client = this.createHttpClient(config);\n    this._client = client;\n    return { config, client };\n  }\n\n  async createUser(\n    user: KibanaUser,\n    realmName: string,\n    roleNames: string[] | undefined,\n    ...args: MaybeContextualArg<any>\n  ): Promise<void> {\n    const { ctxArgs } = (await this.logCtx(args, \"createUser\", true)).for(\n      this.createUser\n    );\n    const defaultRole = this.normalizeRoleConfig(realmName).name;\n    const payloadRoles =\n      roleNames && roleNames.length > 0 ? roleNames : [defaultRole];\n    const response = await this.request(\n      \"POST\",\n      `${this.config.protocol}://${this.config.es_host}/_security/user/${encodeURIComponent(user.username)}`,\n      {\n        password: user.password,\n        full_name: user.full_name,\n        email: user.email,\n        enabled: user.enabled ?? true,\n        metadata: user.metadata ?? {},\n        roles: user.roles ?? payloadRoles,\n      },\n      this.config.adminApiUser,\n      { headers: { \"kbn-xsrf\": \"true\", \"Content-Type\": \"application/json\" } },\n      200,\n      ...ctxArgs\n    );\n    if (response.status >= 300) {\n      const message = `Unable to create user ${user.username}: ${response.statusText}`;\n      const status = response.status as number;\n      if (status === 404 || message.toLowerCase().includes(\"not found\")) {\n        throw new NotFoundError(message);\n      }\n      if (status === 409 || message.toLowerCase().includes(\"conflict\")) {\n        throw new ConflictError(message);\n      }\n      if (status === 400) {\n        throw new BadRequestError(message);\n      }\n      if (status === 401 || status === 403) {\n        throw new NotFoundError(message);\n      }\n      throw new InternalError(message);\n    }\n  }\n\n  async updateUser(\n    user: KibanaUser,\n    realmName: string,\n    roleNames: string[] | undefined,\n    ...args: MaybeContextualArg<any>\n  ): Promise<void> {\n    const { ctxArgs } = (await this.logCtx(args, \"updateUser\", true)).for(\n      this.updateUser\n    );\n    const defaultRole = this.normalizeRoleConfig(realmName).name;\n    const payloadRoles =\n      roleNames && roleNames.length > 0 ? roleNames : [defaultRole];\n    const response = await this.request(\n      \"PUT\",\n      `${this.config.protocol}://${this.config.es_host}/_security/user/${encodeURIComponent(user.username)}`,\n      {\n        password: user.password,\n        full_name: user.full_name,\n        email: user.email,\n        enabled: user.enabled ?? true,\n        metadata: user.metadata ?? {},\n        roles: user.roles ?? payloadRoles,\n      },\n      this.config.adminApiUser,\n      { headers: { \"kbn-xsrf\": \"true\", \"Content-Type\": \"application/json\" } },\n      200,\n      ...ctxArgs\n    );\n    if (response.status >= 300) {\n      const message = `Unable to update user ${user.username}: ${response.statusText}`;\n      const status = response.status as number;\n      if (status === 404 || message.toLowerCase().includes(\"not found\")) {\n        throw new NotFoundError(message);\n      }\n      if (status === 409 || message.toLowerCase().includes(\"conflict\")) {\n        throw new ConflictError(message);\n      }\n      if (status === 400) {\n        throw new BadRequestError(message);\n      }\n      if (status === 401 || status === 403) {\n        throw new NotFoundError(message);\n      }\n      throw new InternalError(message);\n    }\n  }\n\n  private createHttpClient(config: KibanaSetupConfig): AxiosInstance {\n    return Axios.create({\n      baseURL: `${config.protocol}://${config.host}`,\n      validateStatus: () => true,\n      httpsAgent: new https.Agent({\n        rejectUnauthorized: ((this.config as any).isProduction()),\n      }),\n    });\n  }\n\n  protected parseError(error: Error): Error {\n    const message = error.message || error.name || \"Unknown error\";\n    const lowerMessage = message.toLowerCase();\n\n    if (lowerMessage.includes(\"not found\") || lowerMessage.includes(\"404\")) {\n      return new NotFoundError(message);\n    }\n\n    if (\n      lowerMessage.includes(\"already exists\") ||\n      lowerMessage.includes(\"conflict\") ||\n      lowerMessage.includes(\"409\")\n    ) {\n      return new ConflictError(message);\n    }\n\n    if (\n      lowerMessage.includes(\"invalid\") ||\n      lowerMessage.includes(\"bad request\") ||\n      lowerMessage.includes(\"400\")\n    ) {\n      return new BadRequestError(message);\n    }\n\n    if (lowerMessage.includes(\"unauthorized\") || lowerMessage.includes(\"401\")) {\n      return new NotFoundError(message);\n    }\n\n    if (lowerMessage.includes(\"forbidden\") || lowerMessage.includes(\"403\")) {\n      return new NotFoundError(message);\n    }\n\n    return new InternalError(message);\n  }\n\n  private normalizeRoleConfig(\n    realmName: string,\n    payload: Partial<{ name?: string }> = {}\n  ): { name: string } {\n    const suffix = realmName.toLowerCase();\n    const base = this.config.role ?? {};\n    return {\n      name: payload.name ?? base.name ?? `pla_${suffix}_reader`,\n    };\n  }\n\n  private async request(\n    method: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\",\n    url: string,\n    payload: unknown,\n    apiUser: KibanaUser | undefined,\n    extra: Record<string, any>,\n    successCode: number,\n    ...args: ContextualArgs<any>\n  ): Promise<any> {\n    this.logCtx(args, this.request);\n    return this.client.request({\n      method,\n      url,\n      data:\n        payload === undefined\n          ? undefined\n          : typeof payload === \"string\"\n            ? payload\n            : JSON.stringify(payload),\n      auth: apiUser\n        ? { username: apiUser.username, password: apiUser.password }\n        : undefined,\n      validateStatus: () => true,\n      httpsAgent: new https.Agent({\n        rejectUnauthorized: ((this.config as any).isProduction()),\n      }),\n      ...extra,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KibanaUserService.js","sourceRoot":"","sources":["../../../../src/kibana/services/KibanaUserService.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,aAAa,GACd,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,KAAwB,MAAM,OAAO,CAAC;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,yBAAyB,EAAE,qBAAkB;AACtD,OAAO,EAAE,iBAAiB,EAAE,+BAA4B;AAExD,MAAM,OAAO,iBAAkB,SAAQ,kBAGtC;IAIC,KAAK,CAAC,UAAU,CACd,GAAG,IAA6B;QAEhC,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CACnE,IAAI,CAAC,UAAU,CAChB,CAAC;QACF,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAsB,CAAC;QAC/C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,UAAU,CACd,IAAgB,EAChB,SAAiB,EACjB,SAA+B,EAC/B,GAAG,IAA6B;QAEhC,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CACnE,IAAI,CAAC,UAAU,CAChB,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;QAC7D,MAAM,YAAY,GAChB,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QAChE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CACjC,MAAM,EACN,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,mBAAmB,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,EACtG;YACE,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,EAAE;YAC7B,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,YAAY;SAClC,EACD,IAAI,CAAC,MAAM,CAAC,YAAY,EACxB,EAAE,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,kBAAkB,EAAE,EAAE,EACvE,GAAG,EACH,GAAG,OAAO,CACX,CAAC;QACF,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;YAC3B,MAAM,OAAO,GAAG,yBAAyB,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,UAAU,EAAE,CAAC;YACjF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAgB,CAAC;YACzC,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;gBAClE,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjE,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;gBACnB,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;YACrC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;gBACrC,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CACd,IAAgB,EAChB,SAAiB,EACjB,SAA+B,EAC/B,GAAG,IAA6B;QAEhC,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CACnE,IAAI,CAAC,UAAU,CAChB,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;QAC7D,MAAM,YAAY,GAChB,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QAChE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CACjC,KAAK,EACL,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,mBAAmB,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,EACtG;YACE,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,EAAE;YAC7B,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,YAAY;SAClC,EACD,IAAI,CAAC,MAAM,CAAC,YAAY,EACxB,EAAE,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,kBAAkB,EAAE,EAAE,EACvE,GAAG,EACH,GAAG,OAAO,CACX,CAAC;QACF,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;YAC3B,MAAM,OAAO,GAAG,yBAAyB,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,UAAU,EAAE,CAAC;YACjF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAgB,CAAC;YACzC,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;gBAClE,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjE,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;gBACnB,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;YACrC,CAAC;YACD,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;gBACrC,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,MAAyB;QAChD,OAAO,KAAK,CAAC,MAAM,CAAC;YAClB,OAAO,EAAE,GAAG,MAAM,CAAC,QAAQ,MAAM,MAAM,CAAC,IAAI,EAAE;YAC9C,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;YAC1B,UAAU,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC;gBAC1B,kBAAkB,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAa,CAAC,CAAC;aACpE,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAES,UAAU,CAAC,KAAY;QAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,IAAI,IAAI,eAAe,CAAC;QAC/D,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;QAE3C,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACvE,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,IACE,YAAY,CAAC,QAAQ,CAAC,gBAAgB,CAAC;YACvC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC;YACjC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAC5B,CAAC;YACD,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,IACE,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC;YAChC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC;YACpC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAC5B,CAAC;YACD,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC;QAED,IAAI,YAAY,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1E,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACvE,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAEO,mBAAmB,CACzB,SAAiB,EACjB,UAAsC,EAAE;QAExC,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;QACvC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACpC,OAAO;YACL,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,OAAO,MAAM,SAAS;SAC1D,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,MAAyC,EACzC,GAAW,EACX,OAAgB,EAChB,OAA+B,EAC/B,KAA0B,EAC1B,WAAmB,EACnB,GAAG,IAAyB;QAE5B,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;YACzB,MAAM;YACN,GAAG;YACH,IAAI,EACF,OAAO,KAAK,SAAS;gBACnB,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,OAAO,OAAO,KAAK,QAAQ;oBAC3B,CAAC,CAAC,OAAO;oBACT,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAC/B,IAAI,EAAE,OAAO;gBACX,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE;gBAC5D,CAAC,CAAC,SAAS;YACb,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;YAC1B,UAAU,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC;gBAC1B,kBAAkB,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAa,CAAC,CAAC;aACpE,CAAC;YACF,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;CACF;AAlMW;IADT,OAAO,EAAE;8BACc,iBAAiB;sDAAC","sourcesContent":["import {\n  BadRequestError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { ContextualArgs, MaybeContextualArg } from \"@decaf-ts/core\";\nimport { ClientBasedService, service } from \"@decaf-ts/core\";\nimport type { KibanaSetupConfig, KibanaUser } from \"../types\";\nimport Axios, { AxiosInstance } from \"axios\";\nimport * as https from \"node:https\";\nimport { resolveKibanaIsProduction } from \"./runtime\";\nimport { KibanaAuthService } from \"./KibanaAuthService\";\n\nexport class KibanaUserService extends ClientBasedService<\n  AxiosInstance,\n  KibanaSetupConfig\n> {\n  @service()\n  protected authService!: KibanaAuthService;\n\n  async initialize(\n    ...args: MaybeContextualArg<any>\n  ): Promise<{ config: KibanaSetupConfig; client: AxiosInstance }> {\n    const { ctxArgs } = (await this.logCtx(args, \"initialize\", true)).for(\n      this.initialize\n    );\n    const config = ctxArgs[0] as KibanaSetupConfig;\n    this._config = config;\n    const client = this.createHttpClient(config);\n    this._client = client;\n    return { config, client };\n  }\n\n  async createUser(\n    user: KibanaUser,\n    realmName: string,\n    roleNames: string[] | undefined,\n    ...args: MaybeContextualArg<any>\n  ): Promise<void> {\n    const { ctxArgs } = (await this.logCtx(args, \"createUser\", true)).for(\n      this.createUser\n    );\n    const defaultRole = this.normalizeRoleConfig(realmName).name;\n    const payloadRoles =\n      roleNames && roleNames.length > 0 ? roleNames : [defaultRole];\n    const response = await this.request(\n      \"POST\",\n      `${this.config.protocol}://${this.config.es_host}/_security/user/${encodeURIComponent(user.username)}`,\n      {\n        password: user.password,\n        full_name: user.full_name,\n        email: user.email,\n        enabled: user.enabled ?? true,\n        metadata: user.metadata ?? {},\n        roles: user.roles ?? payloadRoles,\n      },\n      this.config.adminApiUser,\n      { headers: { \"kbn-xsrf\": \"true\", \"Content-Type\": \"application/json\" } },\n      200,\n      ...ctxArgs\n    );\n    if (response.status >= 300) {\n      const message = `Unable to create user ${user.username}: ${response.statusText}`;\n      const status = response.status as number;\n      if (status === 404 || message.toLowerCase().includes(\"not found\")) {\n        throw new NotFoundError(message);\n      }\n      if (status === 409 || message.toLowerCase().includes(\"conflict\")) {\n        throw new ConflictError(message);\n      }\n      if (status === 400) {\n        throw new BadRequestError(message);\n      }\n      if (status === 401 || status === 403) {\n        throw new NotFoundError(message);\n      }\n      throw new InternalError(message);\n    }\n  }\n\n  async updateUser(\n    user: KibanaUser,\n    realmName: string,\n    roleNames: string[] | undefined,\n    ...args: MaybeContextualArg<any>\n  ): Promise<void> {\n    const { ctxArgs } = (await this.logCtx(args, \"updateUser\", true)).for(\n      this.updateUser\n    );\n    const defaultRole = this.normalizeRoleConfig(realmName).name;\n    const payloadRoles =\n      roleNames && roleNames.length > 0 ? roleNames : [defaultRole];\n    const response = await this.request(\n      \"PUT\",\n      `${this.config.protocol}://${this.config.es_host}/_security/user/${encodeURIComponent(user.username)}`,\n      {\n        password: user.password,\n        full_name: user.full_name,\n        email: user.email,\n        enabled: user.enabled ?? true,\n        metadata: user.metadata ?? {},\n        roles: user.roles ?? payloadRoles,\n      },\n      this.config.adminApiUser,\n      { headers: { \"kbn-xsrf\": \"true\", \"Content-Type\": \"application/json\" } },\n      200,\n      ...ctxArgs\n    );\n    if (response.status >= 300) {\n      const message = `Unable to update user ${user.username}: ${response.statusText}`;\n      const status = response.status as number;\n      if (status === 404 || message.toLowerCase().includes(\"not found\")) {\n        throw new NotFoundError(message);\n      }\n      if (status === 409 || message.toLowerCase().includes(\"conflict\")) {\n        throw new ConflictError(message);\n      }\n      if (status === 400) {\n        throw new BadRequestError(message);\n      }\n      if (status === 401 || status === 403) {\n        throw new NotFoundError(message);\n      }\n      throw new InternalError(message);\n    }\n  }\n\n  private createHttpClient(config: KibanaSetupConfig): AxiosInstance {\n    return Axios.create({\n      baseURL: `${config.protocol}://${config.host}`,\n      validateStatus: () => true,\n      httpsAgent: new https.Agent({\n        rejectUnauthorized: (resolveKibanaIsProduction(this.config as any)),\n      }),\n    });\n  }\n\n  protected parseError(error: Error): Error {\n    const message = error.message || error.name || \"Unknown error\";\n    const lowerMessage = message.toLowerCase();\n\n    if (lowerMessage.includes(\"not found\") || lowerMessage.includes(\"404\")) {\n      return new NotFoundError(message);\n    }\n\n    if (\n      lowerMessage.includes(\"already exists\") ||\n      lowerMessage.includes(\"conflict\") ||\n      lowerMessage.includes(\"409\")\n    ) {\n      return new ConflictError(message);\n    }\n\n    if (\n      lowerMessage.includes(\"invalid\") ||\n      lowerMessage.includes(\"bad request\") ||\n      lowerMessage.includes(\"400\")\n    ) {\n      return new BadRequestError(message);\n    }\n\n    if (lowerMessage.includes(\"unauthorized\") || lowerMessage.includes(\"401\")) {\n      return new NotFoundError(message);\n    }\n\n    if (lowerMessage.includes(\"forbidden\") || lowerMessage.includes(\"403\")) {\n      return new NotFoundError(message);\n    }\n\n    return new InternalError(message);\n  }\n\n  private normalizeRoleConfig(\n    realmName: string,\n    payload: Partial<{ name?: string }> = {}\n  ): { name: string } {\n    const suffix = realmName.toLowerCase();\n    const base = this.config.role ?? {};\n    return {\n      name: payload.name ?? base.name ?? `pla_${suffix}_reader`,\n    };\n  }\n\n  private async request(\n    method: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\",\n    url: string,\n    payload: unknown,\n    apiUser: KibanaUser | undefined,\n    extra: Record<string, any>,\n    successCode: number,\n    ...args: ContextualArgs<any>\n  ): Promise<any> {\n    this.logCtx(args, this.request);\n    return this.client.request({\n      method,\n      url,\n      data:\n        payload === undefined\n          ? undefined\n          : typeof payload === \"string\"\n            ? payload\n            : JSON.stringify(payload),\n      auth: apiUser\n        ? { username: apiUser.username, password: apiUser.password }\n        : undefined,\n      validateStatus: () => true,\n      httpsAgent: new https.Agent({\n        rejectUnauthorized: (resolveKibanaIsProduction(this.config as any)),\n      }),\n      ...extra,\n    });\n  }\n}\n"]}

package/lib/esm/kibana/services/runtime.js

@@ -0,0 +1,15 @@
+import { InternalError } from "@decaf-ts/db-decorators";
+let kibanaProductionResolver;
+export function setKibanaProductionResolver(resolver) {
+    kibanaProductionResolver = resolver;
+}
+export function resolveKibanaIsProduction(config) {
+    if (typeof config?.isProduction === "function") {
+        return config.isProduction();
+    }
+    if (kibanaProductionResolver) {
+        return kibanaProductionResolver();
+    }
+    throw new InternalError("Kibana production resolver not initialized");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9raWJhbmEvc2VydmljZXMvcnVudGltZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFJeEQsSUFBSSx3QkFBd0QsQ0FBQztBQUU3RCxNQUFNLFVBQVUsMkJBQTJCLENBQ3pDLFFBQTRCO0lBRTVCLHdCQUF3QixHQUFHLFFBQVEsQ0FBQztBQUN0QyxDQUFDO0FBRUQsTUFBTSxVQUFVLHlCQUF5QixDQUN2QyxNQUF5QztJQUV6QyxJQUFJLE9BQU8sTUFBTSxFQUFFLFlBQVksS0FBSyxVQUFVLEVBQUUsQ0FBQztRQUMvQyxPQUFPLE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBQ0QsSUFBSSx3QkFBd0IsRUFBRSxDQUFDO1FBQzdCLE9BQU8sd0JBQXdCLEVBQUUsQ0FBQztJQUNwQyxDQUFDO0lBQ0QsTUFBTSxJQUFJLGFBQWEsQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDO0FBQ3hFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnRlcm5hbEVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbnR5cGUgUHJvZHVjdGlvblJlc29sdmVyID0gKCkgPT4gYm9vbGVhbjtcblxubGV0IGtpYmFuYVByb2R1Y3Rpb25SZXNvbHZlcjogUHJvZHVjdGlvblJlc29sdmVyIHwgdW5kZWZpbmVkO1xuXG5leHBvcnQgZnVuY3Rpb24gc2V0S2liYW5hUHJvZHVjdGlvblJlc29sdmVyKFxuICByZXNvbHZlcjogUHJvZHVjdGlvblJlc29sdmVyXG4pOiB2b2lkIHtcbiAga2liYW5hUHJvZHVjdGlvblJlc29sdmVyID0gcmVzb2x2ZXI7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZXNvbHZlS2liYW5hSXNQcm9kdWN0aW9uKFxuICBjb25maWc/OiB7IGlzUHJvZHVjdGlvbj86ICgpID0+IGJvb2xlYW4gfVxuKTogYm9vbGVhbiB7XG4gIGlmICh0eXBlb2YgY29uZmlnPy5pc1Byb2R1Y3Rpb24gPT09IFwiZnVuY3Rpb25cIikge1xuICAgIHJldHVybiBjb25maWcuaXNQcm9kdWN0aW9uKCk7XG4gIH1cbiAgaWYgKGtpYmFuYVByb2R1Y3Rpb25SZXNvbHZlcikge1xuICAgIHJldHVybiBraWJhbmFQcm9kdWN0aW9uUmVzb2x2ZXIoKTtcbiAgfVxuICB0aHJvdyBuZXcgSW50ZXJuYWxFcnJvcihcIktpYmFuYSBwcm9kdWN0aW9uIHJlc29sdmVyIG5vdCBpbml0aWFsaXplZFwiKTtcbn1cbiJdfQ==

package/lib/types/graph/execution/CodeSandboxEvaluator.d.cts

@@ -0,0 +1,53 @@
+/**
+ * @module integrations/graph/execution/CodeSandboxEvaluator
+ * @summary Pluggable contract for evaluating code-based conditions (DECAF-32 §22.4).
+ * @description The engine does NOT implement the VM sandbox directly (§22.4).
+ * Downstream projects (e.g. ALFRED) register a `CodeSandboxEvaluator` via the
+ * `GraphExecutionEngineConfig.codeSandboxEvaluator` field. When absent, code
+ * conditions throw a `GRAPH_CODE_SANDBOX_NOT_CONFIGURED` error.
+ *
+ * The sandbox must follow the same restrictions as the Code Node (§22.4):
+ * - No system API access (`require`, `process`, `fs`, `child_process`, etc.)
+ * - Placeholder syntax for workflow data references (`{{ $input.foo }}`,
+ *   `{{ $node["Name"].output }}`, `{{ $vars.bar }}`, etc.)
+ * - Static code validation (e.g. `acorn`-based) before execution
+ * - The code must return a boolean value (for conditions) or any value
+ *   (for Code Node transforms)
+ */
+/**
+ * Context passed to the code sandbox evaluator.
+ */
+export interface CodeSandboxContext {
+    /** The raw code string authored by the user. */
+    code: string;
+    /** The programming language (defaults to `"javascript"`). */
+    language?: "javascript" | "typescript";
+    /** The current input values, accessible as `$input` in placeholders. */
+    input: Record<string, unknown>;
+    /** Workflow variables, accessible as `$vars` in placeholders. */
+    vars?: Record<string, unknown>;
+    /** Current loop item (if inside a foreach), accessible as `$item`. */
+    item?: unknown;
+    /** Current loop index (if inside a foreach), accessible as `$index`. */
+    index?: number;
+    /** Outputs of upstream nodes, accessible as `$node["Name"].output`. */
+    nodes?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Pluggable evaluator for code-based conditions and Code Node transforms.
+ *
+ * Implementations MUST enforce the Code Node restrictions (§22.4):
+ * no system API access, static validation, placeholder resolution.
+ */
+export interface CodeSandboxEvaluator {
+    /**
+     * Evaluates the given code in a restricted sandbox and returns the result.
+     *
+     * For conditions, the code is expected to return a boolean.
+     * For Code Node transforms, the code may return any value.
+     *
+     * @param ctx - The sandbox context containing code, input, and references.
+     * @returns The result of evaluating the code.
+     */
+    evaluate(ctx: CodeSandboxContext): Promise<unknown> | unknown;
+}

package/lib/types/graph/execution/CodeSandboxEvaluator.d.mts

@@ -0,0 +1,53 @@
+/**
+ * @module integrations/graph/execution/CodeSandboxEvaluator
+ * @summary Pluggable contract for evaluating code-based conditions (DECAF-32 §22.4).
+ * @description The engine does NOT implement the VM sandbox directly (§22.4).
+ * Downstream projects (e.g. ALFRED) register a `CodeSandboxEvaluator` via the
+ * `GraphExecutionEngineConfig.codeSandboxEvaluator` field. When absent, code
+ * conditions throw a `GRAPH_CODE_SANDBOX_NOT_CONFIGURED` error.
+ *
+ * The sandbox must follow the same restrictions as the Code Node (§22.4):
+ * - No system API access (`require`, `process`, `fs`, `child_process`, etc.)
+ * - Placeholder syntax for workflow data references (`{{ $input.foo }}`,
+ *   `{{ $node["Name"].output }}`, `{{ $vars.bar }}`, etc.)
+ * - Static code validation (e.g. `acorn`-based) before execution
+ * - The code must return a boolean value (for conditions) or any value
+ *   (for Code Node transforms)
+ */
+/**
+ * Context passed to the code sandbox evaluator.
+ */
+export interface CodeSandboxContext {
+    /** The raw code string authored by the user. */
+    code: string;
+    /** The programming language (defaults to `"javascript"`). */
+    language?: "javascript" | "typescript";
+    /** The current input values, accessible as `$input` in placeholders. */
+    input: Record<string, unknown>;
+    /** Workflow variables, accessible as `$vars` in placeholders. */
+    vars?: Record<string, unknown>;
+    /** Current loop item (if inside a foreach), accessible as `$item`. */
+    item?: unknown;
+    /** Current loop index (if inside a foreach), accessible as `$index`. */
+    index?: number;
+    /** Outputs of upstream nodes, accessible as `$node["Name"].output`. */
+    nodes?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Pluggable evaluator for code-based conditions and Code Node transforms.
+ *
+ * Implementations MUST enforce the Code Node restrictions (§22.4):
+ * no system API access, static validation, placeholder resolution.
+ */
+export interface CodeSandboxEvaluator {
+    /**
+     * Evaluates the given code in a restricted sandbox and returns the result.
+     *
+     * For conditions, the code is expected to return a boolean.
+     * For Code Node transforms, the code may return any value.
+     *
+     * @param ctx - The sandbox context containing code, input, and references.
+     * @returns The result of evaluating the code.
+     */
+    evaluate(ctx: CodeSandboxContext): Promise<unknown> | unknown;
+}

package/lib/types/graph/execution/GraphExecutionEngine.d.cts

@@ -11,6 +11,7 @@ import { GraphExecutionEventEmitter } from "../events/GraphExecutionEventEmitter
 import type { GraphNodeExecutorRegistry } from "../registry/GraphNodeExecutorRegistry.d.cts";
 import { GraphExecutionPlanner } from "../planning/GraphExecutionPlanner.d.cts";
 import type { GraphValueStoreAdapter } from "../store/GraphValueStoreAdapter.d.cts";
+import type { CodeSandboxEvaluator } from "./CodeSandboxEvaluator.d.cts";
 /**
  * Configuration for the {@link GraphExecutionEngine}.
  */
@@ -20,6 +21,13 @@ export interface GraphExecutionEngineConfig {
     valueStoreAdapter?: GraphValueStoreAdapter;
     eventEmitter?: GraphExecutionEventEmitter;
     defaultOptions?: Partial<GraphExecutionOptions>;
+    /**
+     * Optional pluggable code sandbox evaluator for code-based conditions
+     * (DECAF-32 §22.4). When absent, code conditions throw
+     * `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`. Downstream projects (e.g. ALFRED)
+     * supply the actual VM sandbox implementation.
+     */
+    codeSandboxEvaluator?: CodeSandboxEvaluator;
     /**
      * Optional callback invoked at the end of engine construction with the
      * fully-initialised engine instance. Use this to register executors that
@@ -44,6 +52,8 @@ export declare class GraphExecutionEngine implements Observable<[GraphExecutionO
     private readonly planner;
     private readonly valueStoreAdapter;
     private readonly defaultOptions;
+    /** Pluggable code sandbox evaluator (§22.4); may be undefined. */
+    readonly codeSandboxEvaluator?: CodeSandboxEvaluator;
     constructor(config: GraphExecutionEngineConfig);
     private readonly config;
     observe(observer: GraphExecutionObserver): () => void;

package/lib/types/graph/execution/GraphExecutionEngine.d.mts

@@ -11,6 +11,7 @@ import { GraphExecutionEventEmitter } from "../events/GraphExecutionEventEmitter
 import type { GraphNodeExecutorRegistry } from "../registry/GraphNodeExecutorRegistry.d.mts";
 import { GraphExecutionPlanner } from "../planning/GraphExecutionPlanner.d.mts";
 import type { GraphValueStoreAdapter } from "../store/GraphValueStoreAdapter.d.mts";
+import type { CodeSandboxEvaluator } from "./CodeSandboxEvaluator.d.mts";
 /**
  * Configuration for the {@link GraphExecutionEngine}.
  */
@@ -20,6 +21,13 @@ export interface GraphExecutionEngineConfig {
     valueStoreAdapter?: GraphValueStoreAdapter;
     eventEmitter?: GraphExecutionEventEmitter;
     defaultOptions?: Partial<GraphExecutionOptions>;
+    /**
+     * Optional pluggable code sandbox evaluator for code-based conditions
+     * (DECAF-32 §22.4). When absent, code conditions throw
+     * `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`. Downstream projects (e.g. ALFRED)
+     * supply the actual VM sandbox implementation.
+     */
+    codeSandboxEvaluator?: CodeSandboxEvaluator;
     /**
      * Optional callback invoked at the end of engine construction with the
      * fully-initialised engine instance. Use this to register executors that
@@ -44,6 +52,8 @@ export declare class GraphExecutionEngine implements Observable<[GraphExecutionO
     private readonly planner;
     private readonly valueStoreAdapter;
     private readonly defaultOptions;
+    /** Pluggable code sandbox evaluator (§22.4); may be undefined. */
+    readonly codeSandboxEvaluator?: CodeSandboxEvaluator;
     constructor(config: GraphExecutionEngineConfig);
     private readonly config;
     observe(observer: GraphExecutionObserver): () => void;

package/lib/types/graph/execution/SwitchGraphNodeExecutor.d.cts

@@ -0,0 +1,42 @@
+/**
+ * @module integrations/graph/execution/SwitchGraphNodeExecutor
+ * @summary Executor for the Switch flow-control node (DECAF-32 §22.2.2).
+ * @description Evaluates each case's condition against the node's input and
+ * routes the input to the first matching case's output port. Falls back to
+ * the `default` output when no case matches. Supports both
+ * {@link ConditionExpression} (graphical mode) and {@link CodeCondition}
+ * (code mode via the pluggable {@link CodeSandboxEvaluator}).
+ */
+import type { GraphNodeExecutor } from "./GraphNodeExecutor.d.cts";
+import type { GraphExecutionContext } from "./GraphExecutionContext.d.cts";
+import type { GraphExecutionValues } from "../types.d.cts";
+import type { CodeSandboxEvaluator } from "./CodeSandboxEvaluator.d.cts";
+/**
+ * Executor for `core.flow.switch` nodes.
+ *
+ * Evaluates each case's condition in order and routes the input to the
+ * first matching case's output port. When no case matches, routes to the
+ * `default` output port.
+ *
+ * Condition evaluation:
+ * - `ConditionExpression` — evaluated via {@link ConditionExpressionEvaluator}.
+ * - `CodeCondition` — evaluated via the pluggable {@link CodeSandboxEvaluator}
+ *   from the engine's config. Throws `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`
+ *   when no evaluator is registered.
+ */
+export declare class SwitchGraphNodeExecutor implements GraphNodeExecutor {
+    private readonly engine?;
+    private readonly expressionEvaluator;
+    constructor(engine?: {
+        codeSandboxEvaluator?: CodeSandboxEvaluator;
+    } | undefined);
+    execute(input: GraphExecutionValues, context: GraphExecutionContext): Promise<GraphExecutionValues>;
+    /**
+     * Evaluates a single switch case condition.
+     */
+    private evaluateCondition;
+    /**
+     * Evaluates a code condition via the pluggable sandbox evaluator.
+     */
+    private evaluateCodeCondition;
+}

package/lib/types/graph/execution/SwitchGraphNodeExecutor.d.mts

@@ -0,0 +1,42 @@
+/**
+ * @module integrations/graph/execution/SwitchGraphNodeExecutor
+ * @summary Executor for the Switch flow-control node (DECAF-32 §22.2.2).
+ * @description Evaluates each case's condition against the node's input and
+ * routes the input to the first matching case's output port. Falls back to
+ * the `default` output when no case matches. Supports both
+ * {@link ConditionExpression} (graphical mode) and {@link CodeCondition}
+ * (code mode via the pluggable {@link CodeSandboxEvaluator}).
+ */
+import type { GraphNodeExecutor } from "./GraphNodeExecutor.d.mts";
+import type { GraphExecutionContext } from "./GraphExecutionContext.d.mts";
+import type { GraphExecutionValues } from "../types.d.mts";
+import type { CodeSandboxEvaluator } from "./CodeSandboxEvaluator.d.mts";
+/**
+ * Executor for `core.flow.switch` nodes.
+ *
+ * Evaluates each case's condition in order and routes the input to the
+ * first matching case's output port. When no case matches, routes to the
+ * `default` output port.
+ *
+ * Condition evaluation:
+ * - `ConditionExpression` — evaluated via {@link ConditionExpressionEvaluator}.
+ * - `CodeCondition` — evaluated via the pluggable {@link CodeSandboxEvaluator}
+ *   from the engine's config. Throws `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`
+ *   when no evaluator is registered.
+ */
+export declare class SwitchGraphNodeExecutor implements GraphNodeExecutor {
+    private readonly engine?;
+    private readonly expressionEvaluator;
+    constructor(engine?: {
+        codeSandboxEvaluator?: CodeSandboxEvaluator;
+    } | undefined);
+    execute(input: GraphExecutionValues, context: GraphExecutionContext): Promise<GraphExecutionValues>;
+    /**
+     * Evaluates a single switch case condition.
+     */
+    private evaluateCondition;
+    /**
+     * Evaluates a code condition via the pluggable sandbox evaluator.
+     */
+    private evaluateCodeCondition;
+}

package/lib/types/graph/execution/index.d.cts

@@ -8,3 +8,5 @@ export * from "./GraphNodeExecutor.d.cts";
 export * from "./GraphExecutionResult.d.cts";
 export * from "./GraphExecutionFrame.d.cts";
 export * from "./GraphExecutionEngine.d.cts";
+export * from "./CodeSandboxEvaluator.d.cts";
+export * from "./SwitchGraphNodeExecutor.d.cts";

package/lib/types/graph/execution/index.d.mts

@@ -8,3 +8,5 @@ export * from "./GraphNodeExecutor.d.mts";
 export * from "./GraphExecutionResult.d.mts";
 export * from "./GraphExecutionFrame.d.mts";
 export * from "./GraphExecutionEngine.d.mts";
+export * from "./CodeSandboxEvaluator.d.mts";
+export * from "./SwitchGraphNodeExecutor.d.mts";

package/lib/types/graph/index.d.cts

@@ -23,6 +23,8 @@ export * from "./execution/GraphNodeExecutor.d.cts";
 export * from "./execution/GraphExecutionFrame.d.cts";
 export * from "./execution/GraphExecutionResult.d.cts";
 export * from "./execution/GraphExecutionEngine.d.cts";
+export * from "./execution/CodeSandboxEvaluator.d.cts";
+export * from "./execution/SwitchGraphNodeExecutor.d.cts";
 export * from "./registry/GraphNodeExecutorRegistry.d.cts";
 export * from "./registry/GraphNodeExecutorResolver.d.cts";
 export * from "./store/GraphValueKey.d.cts";
@@ -41,6 +43,7 @@ export * from "./validation/GraphDefinitionValidator.d.cts";
 export * from "./validation/GraphPortSchemaResolver.d.cts";
 export * from "./validation/GraphValueValidator.d.cts";
 export * from "./loops/GraphConditionEvaluator.d.cts";
+export * from "./loops/ConditionExpressionEvaluator.d.cts";
 export * from "./loops/GraphLoopExecutionContext.d.cts";
 export * from "./loops/ForeachGraphNodeExecutor.d.cts";
 export * from "./loops/WhileGraphNodeExecutor.d.cts";
@@ -50,3 +53,4 @@ export * from "./pinning/GraphPinningPolicy.d.cts";
 export * from "./pinning/GraphPinningDependencyResolver.d.cts";
 export * from "./pinning/GraphPinningService.d.cts";
 export * from "./snapshots/GraphExecutionSnapshotMapper.d.cts";
+export * from "./nodes/index.d.cts";

package/lib/types/graph/index.d.mts

@@ -23,6 +23,8 @@ export * from "./execution/GraphNodeExecutor.d.mts";
 export * from "./execution/GraphExecutionFrame.d.mts";
 export * from "./execution/GraphExecutionResult.d.mts";
 export * from "./execution/GraphExecutionEngine.d.mts";
+export * from "./execution/CodeSandboxEvaluator.d.mts";
+export * from "./execution/SwitchGraphNodeExecutor.d.mts";
 export * from "./registry/GraphNodeExecutorRegistry.d.mts";
 export * from "./registry/GraphNodeExecutorResolver.d.mts";
 export * from "./store/GraphValueKey.d.mts";
@@ -41,6 +43,7 @@ export * from "./validation/GraphDefinitionValidator.d.mts";
 export * from "./validation/GraphPortSchemaResolver.d.mts";
 export * from "./validation/GraphValueValidator.d.mts";
 export * from "./loops/GraphConditionEvaluator.d.mts";
+export * from "./loops/ConditionExpressionEvaluator.d.mts";
 export * from "./loops/GraphLoopExecutionContext.d.mts";
 export * from "./loops/ForeachGraphNodeExecutor.d.mts";
 export * from "./loops/WhileGraphNodeExecutor.d.mts";
@@ -50,3 +53,4 @@ export * from "./pinning/GraphPinningPolicy.d.mts";
 export * from "./pinning/GraphPinningDependencyResolver.d.mts";
 export * from "./pinning/GraphPinningService.d.mts";
 export * from "./snapshots/GraphExecutionSnapshotMapper.d.mts";
+export * from "./nodes/index.d.mts";

package/lib/types/graph/loops/ConditionExpressionEvaluator.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @module integrations/graph/loops/ConditionExpressionEvaluator
+ * @summary Evaluator for the ALFRED-5 `ConditionExpression` DSL (DECAF-32 §22.3).
+ * @description Evaluates declarative, serializable condition expressions with
+ * `eq`/`neq`/`gt`/`gte`/`lt`/`lte`/`and`/`or`/`not`/`exists` operators and
+ * `ExprValue` references (`{const}`, `{path}`, `{step, path}`).
+ */
+import type { ConditionExpression } from "../types.d.cts";
+/**
+ * Evaluates a {@link ConditionExpression} against the given state.
+ *
+ * `ExprValue` resolution:
+ * - `{ const: x }` → the literal value `x`.
+ * - `{ path: "a.b" }` → dotted-path lookup into `state`.
+ * - `{ step: "nodeId", path: "out" }` → cross-node reference; in v1 the state
+ *   is expected to contain a `nodes` map keyed by node id (reserved for future
+ *   multi-step evaluation; falls back to `state` lookup when absent).
+ */
+export declare class ConditionExpressionEvaluator {
+    /**
+     * Evaluates a condition expression to a boolean.
+     *
+     * @param expr - The condition expression.
+     * @param state - The current evaluation state (loop state or execution values).
+     * @returns `true` when the expression evaluates to a truthy/positive result.
+     */
+    evaluate(expr: ConditionExpression, state: unknown): boolean;
+    /**
+     * Resolves an {@link ExprValue} against the current state.
+     */
+    private resolveValue;
+    /**
+     * Resolves a dotted path into a target object.
+     */
+    private resolvePath;
+}

package/lib/types/graph/loops/ConditionExpressionEvaluator.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @module integrations/graph/loops/ConditionExpressionEvaluator
+ * @summary Evaluator for the ALFRED-5 `ConditionExpression` DSL (DECAF-32 §22.3).
+ * @description Evaluates declarative, serializable condition expressions with
+ * `eq`/`neq`/`gt`/`gte`/`lt`/`lte`/`and`/`or`/`not`/`exists` operators and
+ * `ExprValue` references (`{const}`, `{path}`, `{step, path}`).
+ */
+import type { ConditionExpression } from "../types.d.mts";
+/**
+ * Evaluates a {@link ConditionExpression} against the given state.
+ *
+ * `ExprValue` resolution:
+ * - `{ const: x }` → the literal value `x`.
+ * - `{ path: "a.b" }` → dotted-path lookup into `state`.
+ * - `{ step: "nodeId", path: "out" }` → cross-node reference; in v1 the state
+ *   is expected to contain a `nodes` map keyed by node id (reserved for future
+ *   multi-step evaluation; falls back to `state` lookup when absent).
+ */
+export declare class ConditionExpressionEvaluator {
+    /**
+     * Evaluates a condition expression to a boolean.
+     *
+     * @param expr - The condition expression.
+     * @param state - The current evaluation state (loop state or execution values).
+     * @returns `true` when the expression evaluates to a truthy/positive result.
+     */
+    evaluate(expr: ConditionExpression, state: unknown): boolean;
+    /**
+     * Resolves an {@link ExprValue} against the current state.
+     */
+    private resolveValue;
+    /**
+     * Resolves a dotted path into a target object.
+     */
+    private resolvePath;
+}

package/lib/types/graph/loops/GraphConditionEvaluator.d.cts

@@ -1,23 +1,39 @@
 /**
  * @module integrations/graph/loops/GraphConditionEvaluator
- * @summary Evaluator for built-in loop condition types.
+ * @summary Evaluator for built-in loop condition types and the `ConditionExpression` DSL.
  * @description Supports safe, built-in condition types only. Does NOT evaluate arbitrary JavaScript expressions.
+ * When the condition object carries an `op` field (ALFRED-5 §8 / DECAF-32 §22.3), dispatches to the
+ * {@link ConditionExpressionEvaluator} instead of the built-in `type`-based switch.
  */
-import type { GraphConditionDefinition } from "../types.d.cts";
+import type { ConditionExpression, GraphConditionDefinition } from "../types.d.cts";
 /**
- * Evaluates loop conditions using built-in comparison types.
+ * Evaluates loop conditions using built-in comparison types or the
+ * `ConditionExpression` DSL.
  */
 export declare class GraphConditionEvaluator {
+    private readonly expressionEvaluator;
     /**
      * Evaluates a condition against the given state.
      *
+     * When the condition object carries an `op` field, it is treated as a
+     * `ConditionExpression` (§22.3) and dispatched to the
+     * {@link ConditionExpressionEvaluator}. Otherwise the built-in `type`-based
+     * switch is used.
+     *
      * @param condition - The condition definition.
      * @param state - The current loop state.
      * @returns `true` when the condition passes.
      */
-    evaluate(condition: GraphConditionDefinition, state: unknown): boolean;
+    evaluate(condition: GraphConditionDefinition | ConditionExpression, state: unknown): boolean;
     /**
      * Resolves a value that may be a dotted path into the state object.
      */
     private resolveValue;
+    /**
+     * Detects whether a condition object is a `ConditionExpression` (§22.3) by
+     * checking for the presence of an `op` field. When true, the object is
+     * treated as a `ConditionExpression` and dispatched to the
+     * {@link ConditionExpressionEvaluator}.
+     */
+    private isConditionExpression;
 }

package/lib/types/graph/loops/GraphConditionEvaluator.d.mts

@@ -1,23 +1,39 @@
 /**
  * @module integrations/graph/loops/GraphConditionEvaluator
- * @summary Evaluator for built-in loop condition types.
+ * @summary Evaluator for built-in loop condition types and the `ConditionExpression` DSL.
  * @description Supports safe, built-in condition types only. Does NOT evaluate arbitrary JavaScript expressions.
+ * When the condition object carries an `op` field (ALFRED-5 §8 / DECAF-32 §22.3), dispatches to the
+ * {@link ConditionExpressionEvaluator} instead of the built-in `type`-based switch.
  */
-import type { GraphConditionDefinition } from "../types.d.mts";
+import type { ConditionExpression, GraphConditionDefinition } from "../types.d.mts";
 /**
- * Evaluates loop conditions using built-in comparison types.
+ * Evaluates loop conditions using built-in comparison types or the
+ * `ConditionExpression` DSL.
  */
 export declare class GraphConditionEvaluator {
+    private readonly expressionEvaluator;
     /**
      * Evaluates a condition against the given state.
      *
+     * When the condition object carries an `op` field, it is treated as a
+     * `ConditionExpression` (§22.3) and dispatched to the
+     * {@link ConditionExpressionEvaluator}. Otherwise the built-in `type`-based
+     * switch is used.
+     *
      * @param condition - The condition definition.
      * @param state - The current loop state.
      * @returns `true` when the condition passes.
      */
-    evaluate(condition: GraphConditionDefinition, state: unknown): boolean;
+    evaluate(condition: GraphConditionDefinition | ConditionExpression, state: unknown): boolean;
     /**
      * Resolves a value that may be a dotted path into the state object.
      */
     private resolveValue;
+    /**
+     * Detects whether a condition object is a `ConditionExpression` (§22.3) by
+     * checking for the presence of an `op` field. When true, the object is
+     * treated as a `ConditionExpression` and dispatched to the
+     * {@link ConditionExpressionEvaluator}.
+     */
+    private isConditionExpression;
 }

package/lib/types/graph/loops/index.d.cts

@@ -4,6 +4,7 @@
  * @description Re-exports the condition evaluator, loop execution context, and foreach/while/until executors.
  */
 export * from "./GraphConditionEvaluator.d.cts";
+export * from "./ConditionExpressionEvaluator.d.cts";
 export * from "./GraphLoopExecutionContext.d.cts";
 export * from "./ForeachGraphNodeExecutor.d.cts";
 export * from "./WhileGraphNodeExecutor.d.cts";

package/lib/types/graph/loops/index.d.mts

@@ -4,6 +4,7 @@
  * @description Re-exports the condition evaluator, loop execution context, and foreach/while/until executors.
  */
 export * from "./GraphConditionEvaluator.d.mts";
+export * from "./ConditionExpressionEvaluator.d.mts";
 export * from "./GraphLoopExecutionContext.d.mts";
 export * from "./ForeachGraphNodeExecutor.d.mts";
 export * from "./WhileGraphNodeExecutor.d.mts";