catalyst-relay 0.5.14 → 0.6.1

package/dist/index.mjs

@@ -502,6 +502,12 @@ var SsoAuth = class {
   }
 };
 
+// src/core/auth/saml/browser.ts
+import { spawn } from "child_process";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
 // src/core/auth/saml/types.ts
 var DEFAULT_FORM_SELECTORS = {
   username: "#j_username",
@@ -516,9 +522,16 @@ var DEFAULT_PROVIDER_CONFIG = {
 // src/core/auth/saml/browser.ts
 var TIMEOUTS = {
   PAGE_LOAD: 6e4,
-  FORM_SELECTOR: 1e4
+  FORM_SELECTOR: 15e3,
+  NETWORK_IDLE: 3e4,
+  /** Quiet period with no in-flight requests that counts as "idle". */
+  IDLE_QUIET: 600
 };
+var isBun = typeof globalThis.Bun !== "undefined";
 async function performBrowserLogin(options) {
+  return isBun ? performBrowserLoginViaCdp(options) : performBrowserLoginViaPlaywright(options);
+}
+async function performBrowserLoginViaPlaywright(options) {
   const { baseUrl, credentials, headless = true } = options;
   const config = options.providerConfig ?? DEFAULT_PROVIDER_CONFIG;
   let playwright;
@@ -576,6 +589,222 @@ async function performBrowserLogin(options) {
     await browser.close();
   }
 }
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function resolveChromiumPath() {
+  const override = process.env["CATALYST_CHROMIUM_PATH"];
+  if (override) return [override, null];
+  try {
+    const playwright = await import("playwright");
+    const path = playwright.chromium.executablePath();
+    if (!path) {
+      return [null, new Error("Could not resolve the Chromium executable path from Playwright.")];
+    }
+    return [path, null];
+  } catch {
+    return [
+      null,
+      new Error(
+        "Playwright is required for SAML authentication but is not installed. Install it with: npm install playwright"
+      )
+    ];
+  }
+}
+async function connectCdp(wsUrl) {
+  const WebSocketCtor = globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("Native WebSocket is not available in this runtime.");
+  }
+  const ws = new WebSocketCtor(wsUrl);
+  let nextId = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const eventHandlers = [];
+  ws.onmessage = (event) => {
+    const msg = JSON.parse(String(event.data));
+    if (typeof msg.id === "number" && pending.has(msg.id)) {
+      const { resolve, reject } = pending.get(msg.id);
+      pending.delete(msg.id);
+      if (msg.error) reject(new Error(msg.error.message));
+      else resolve(msg.result ?? {});
+    } else if (msg.method) {
+      for (const handler of eventHandlers) {
+        handler({
+          method: msg.method,
+          params: msg.params ?? {},
+          ...msg.sessionId !== void 0 ? { sessionId: msg.sessionId } : {}
+        });
+      }
+    }
+  };
+  await new Promise((resolve, reject) => {
+    ws.onopen = () => resolve();
+    ws.onerror = () => reject(new Error("Failed to connect to the browser CDP endpoint."));
+  });
+  return {
+    send(method, params = {}, sessionId) {
+      return new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params, ...sessionId ? { sessionId } : {} }));
+      });
+    },
+    on(handler) {
+      eventHandlers.push(handler);
+    },
+    close() {
+      ws.close();
+    }
+  };
+}
+async function performBrowserLoginViaCdp(options) {
+  const { baseUrl, credentials, headless = true } = options;
+  const config = options.providerConfig ?? DEFAULT_PROVIDER_CONFIG;
+  const [exePath, pathError] = await resolveChromiumPath();
+  if (pathError) return err(pathError);
+  const userDataDir = mkdtempSync(join2(tmpdir(), "catalyst-saml-"));
+  const args = [
+    ...headless ? ["--headless=new"] : [],
+    "--remote-debugging-port=0",
+    "--no-first-run",
+    "--no-default-browser-check",
+    `--user-data-dir=${userDataDir}`,
+    ...config.ignoreHttpsErrors ? ["--ignore-certificate-errors"] : []
+  ];
+  const proc = spawn(exePath, args, { stdio: ["ignore", "pipe", "pipe"] });
+  let client = null;
+  const cleanup = () => {
+    try {
+      client?.close();
+    } catch {
+    }
+    try {
+      proc.kill();
+    } catch {
+    }
+    try {
+      rmSync(userDataDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    const browserWsUrl = await new Promise((resolve, reject) => {
+      let buffer = "";
+      const timer = setTimeout(
+        () => reject(new Error("Failed to launch browser: timed out waiting for the CDP endpoint.")),
+        TIMEOUTS.PAGE_LOAD
+      );
+      proc.stderr?.on("data", (chunk) => {
+        buffer += String(chunk);
+        const match = buffer.match(/DevTools listening on (ws:\/\/\S+)/);
+        if (match) {
+          clearTimeout(timer);
+          resolve(match[1]);
+        }
+      });
+      proc.on("error", (e) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to launch browser: ${e instanceof Error ? e.message : String(e)}`));
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timer);
+        reject(new Error(`Failed to launch browser: process exited early (code ${code}).`));
+      });
+    });
+    client = await connectCdp(browserWsUrl);
+    const { targetId } = await client.send("Target.createTarget", { url: "about:blank" });
+    const { sessionId } = await client.send("Target.attachToTarget", {
+      targetId,
+      flatten: true
+    });
+    let inflight = 0;
+    let lastNetworkChange = Date.now();
+    client.on((msg) => {
+      if (msg.sessionId !== sessionId) return;
+      if (msg.method === "Network.requestWillBeSent") {
+        inflight += 1;
+        lastNetworkChange = Date.now();
+      } else if (msg.method === "Network.loadingFinished" || msg.method === "Network.loadingFailed") {
+        inflight = Math.max(0, inflight - 1);
+        lastNetworkChange = Date.now();
+      }
+    });
+    await client.send("Page.enable", {}, sessionId);
+    await client.send("Network.enable", {}, sessionId);
+    await client.send("Runtime.enable", {}, sessionId);
+    const loginUrl = `${baseUrl}/sap/bc/adt/compatibility/graph`;
+    const navResult = await client.send("Page.navigate", { url: loginUrl }, sessionId);
+    if (navResult.errorText) {
+      return err(new Error("Failed to load login page. Please check if the server is online."));
+    }
+    const usernameSel = config.formSelectors.username;
+    const formFound = await waitForSelector(client, sessionId, usernameSel, TIMEOUTS.FORM_SELECTOR);
+    if (!formFound) {
+      return err(new Error("Login form not found. The page may have changed or loaded incorrectly."));
+    }
+    const fillExpr = `(() => {
+            const u = document.querySelector(${JSON.stringify(config.formSelectors.username)});
+            const p = document.querySelector(${JSON.stringify(config.formSelectors.password)});
+            const s = document.querySelector(${JSON.stringify(config.formSelectors.submit)});
+            if (!u || !p || !s) return false;
+            const set = (el, val) => {
+                el.value = val;
+                el.dispatchEvent(new Event('input', { bubbles: true }));
+                el.dispatchEvent(new Event('change', { bubbles: true }));
+            };
+            set(u, ${JSON.stringify(credentials.username)});
+            set(p, ${JSON.stringify(credentials.password)});
+            s.click();
+            return true;
+        })()`;
+    const fillResult = await client.send(
+      "Runtime.evaluate",
+      { expression: fillExpr, returnByValue: true },
+      sessionId
+    );
+    if (fillResult.result?.value !== true) {
+      return err(new Error("Login form not found. The page may have changed or loaded incorrectly."));
+    }
+    const idleStart = Date.now();
+    while (Date.now() - idleStart < TIMEOUTS.NETWORK_IDLE) {
+      if (inflight === 0 && Date.now() - lastNetworkChange > TIMEOUTS.IDLE_QUIET) break;
+      await sleep(100);
+    }
+    const { cookies } = await client.send("Network.getAllCookies", {}, sessionId);
+    return ok(cookies.map(toPlaywrightCookie));
+  } catch (e) {
+    return err(
+      new Error(`SAML browser login failed: ${e instanceof Error ? e.message : String(e)}`)
+    );
+  } finally {
+    cleanup();
+  }
+}
+async function waitForSelector(client, sessionId, selector, timeoutMs) {
+  const start = Date.now();
+  const expression = `!!document.querySelector(${JSON.stringify(selector)})`;
+  while (Date.now() - start < timeoutMs) {
+    const res = await client.send(
+      "Runtime.evaluate",
+      { expression, returnByValue: true },
+      sessionId
+    );
+    if (res.result?.value === true) return true;
+    await sleep(200);
+  }
+  return false;
+}
+function toPlaywrightCookie(c) {
+  const sameSite = c.sameSite === "Strict" || c.sameSite === "Lax" || c.sameSite === "None" ? c.sameSite : "Lax";
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    expires: typeof c.expires === "number" ? c.expires : -1,
+    httpOnly: Boolean(c.httpOnly),
+    secure: Boolean(c.secure),
+    sameSite
+  };
+}
 
 // src/core/auth/saml/cookies.ts
 function toAuthCookies(playwrightCookies) {
@@ -780,6 +1009,16 @@ function extractError(xml) {
   const message = messageElement?.textContent;
   return message || "No message found";
 }
+function extractTagText(xml, tagName) {
+  if (!xml) return null;
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return null;
+  const elements = doc.getElementsByTagName(tagName);
+  if (elements.length === 0) return null;
+  const text = elements[0]?.textContent;
+  if (!text || text.trim().length === 0) return null;
+  return text.trim();
+}
 function escapeXml(str) {
   if (!str) {
     return "";
@@ -1200,6 +1439,24 @@ var OBJECT_CONFIG_MAP = {
     type: "PROG/I",
     label: "ABAP Include" /* INCLUDE */,
     extension: "asinc"
+  },
+  "srvd": {
+    endpoint: "ddic/srvd/sources",
+    nameSpace: 'xmlns:srvd="http://www.sap.com/adt/ddic/srvdsources"',
+    rootName: "srvd:srvdSource",
+    type: "SRVD/SRV",
+    label: "Service Definition" /* SERVICE_DEFINITION */,
+    extension: "srvd",
+    rootAttributes: { "srvd:srvdSourceType": "S" }
+  },
+  "asbdef": {
+    endpoint: "bo/behaviordefinitions",
+    nameSpace: 'xmlns:blue="http://www.sap.com/wbobj/blue"',
+    rootName: "blue:blueSource",
+    type: "BDEF/BDO",
+    label: "Behavior Definition" /* BEHAVIOR_DEFINITION */,
+    extension: "asbdef",
+    requiresImplementationType: true
   }
 };
 function getConfigByExtension(extension) {
@@ -1512,11 +1769,44 @@ async function multiDeleteObjects(client, objects, transport) {
   return ok(results);
 }
 
+// src/types/requests.ts
+import { z as z2 } from "zod";
+var BehaviorImplementationType = /* @__PURE__ */ ((BehaviorImplementationType2) => {
+  BehaviorImplementationType2["Managed"] = "Managed";
+  return BehaviorImplementationType2;
+})(BehaviorImplementationType || {});
+var objectRefSchema = z2.object({
+  name: z2.string().min(1),
+  extension: z2.string().min(1)
+});
+var objectContentSchema = objectRefSchema.extend({
+  content: z2.string(),
+  description: z2.string().optional(),
+  implementationType: z2.nativeEnum(BehaviorImplementationType).optional()
+});
+var treeQuerySchema = z2.object({
+  package: z2.string().min(1).optional(),
+  path: z2.string().optional(),
+  owner: z2.string().min(1).optional()
+});
+var previewQuerySchema = z2.object({
+  objectName: z2.string().min(1),
+  objectType: z2.enum(["table", "view"]),
+  sqlQuery: z2.string().min(1),
+  limit: z2.number().positive().max(5e4).optional()
+});
+
 // src/core/adt/craud/create.ts
 async function createObject(client, object, packageName, transport, username) {
   const [config, configErr] = requireConfig(object.extension);
   if (configErr) return err(configErr);
   const description = object.description ?? "";
+  const extraAttrs = config.rootAttributes ? Object.entries(config.rootAttributes).map(([key, value]) => `
+    ${key}="${escapeXml(value)}"`).join("") : "";
+  const implementationType = object.implementationType ?? "Managed" /* Managed */;
+  const adtTemplate = config.requiresImplementationType ? `    <adtcore:adtTemplate>
+        <adtcore:adtProperty adtcore:key="implementation_type">${implementationType}</adtcore:adtProperty>
+    </adtcore:adtTemplate>` : "";
   const body = `<?xml version="1.0" encoding="UTF-8"?>
 <${config.rootName} ${config.nameSpace}
     xmlns:adtcore="http://www.sap.com/adt/core"
@@ -1524,8 +1814,8 @@ async function createObject(client, object, packageName, transport, username) {
     adtcore:language="EN"
     adtcore:name="${object.name.toUpperCase()}"
     adtcore:type="${config.type}"
-    adtcore:responsible="${username.toUpperCase()}">
-
+    adtcore:responsible="${username.toUpperCase()}"${extraAttrs}>
+${adtTemplate}
     <adtcore:packageRef adtcore:name="${packageName}"/>
 
 </${config.rootName}>`;
@@ -1577,6 +1867,33 @@ async function updateObject(client, object, lockHandle, transport) {
   return ok(void 0);
 }
 
+// src/core/adt/craud/classInclude.ts
+async function updateClassInclude(client, className, includeType, source, lockHandle, transport) {
+  const [config, configErr] = requireConfig("aclass");
+  if (configErr) return err(configErr);
+  const params = {
+    "lockHandle": lockHandle
+  };
+  if (transport) {
+    params["corrNr"] = transport;
+  }
+  debug(`Update class include ${className}/${includeType}: length=${source.length}`);
+  const [response, requestErr] = await client.request({
+    method: "PUT",
+    path: `/sap/bc/adt/${config.endpoint}/${className.toLowerCase()}/includes/${includeType}`,
+    params,
+    headers: { "Content-Type": "*/*" },
+    body: source
+  });
+  const [, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to write ${includeType} include of class ${className}`
+  );
+  if (checkErr) return err(checkErr);
+  return ok(void 0);
+}
+
 // src/core/adt/craud/activation.ts
 var MAX_POLL_ATTEMPTS = 30;
 var POLL_RETRY_DELAY_MS = 1e3;
@@ -1586,14 +1903,26 @@ async function activateObjects(client, objects) {
   if (objects.length === 0) {
     return ok([]);
   }
+  const references = [];
   for (const obj of objects) {
     const config = getConfigByExtension(obj.extension);
     if (!config) return err(new Error(`Unsupported extension: ${obj.extension}`));
+    references.push({
+      uri: `/sap/bc/adt/${config.endpoint}/${obj.name.toLowerCase()}`,
+      type: config.type,
+      name: obj.name,
+      extension: obj.extension
+    });
   }
-  const objectRefs = objects.map((obj) => {
-    const config = getConfigByExtension(obj.extension);
-    return `<adtcore:objectReference adtcore:uri="/sap/bc/adt/${config.endpoint}/${obj.name.toLowerCase()}" adtcore:type="${config.type}" adtcore:name="${obj.name}"/>`;
-  }).join("\n    ");
+  return activateByReferences(client, references);
+}
+async function activateByReferences(client, references) {
+  if (references.length === 0) {
+    return ok([]);
+  }
+  const objectRefs = references.map(
+    (ref) => `<adtcore:objectReference adtcore:uri="${ref.uri}" adtcore:type="${ref.type}" adtcore:name="${ref.name}"/>`
+  ).join("\n    ");
   const body = `<?xml version="1.0" encoding="UTF-8"?>
 <adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
     ${objectRefs}
@@ -1657,7 +1986,7 @@ async function activateObjects(client, objects) {
   if (!resultsRes.ok) {
     return err(new Error(`Failed to fetch activation results: ${extractError(resultsText)}`));
   }
-  const [results, parseErr] = extractActivationErrors(objects, resultsText);
+  const [results, parseErr] = extractActivationErrors(references, resultsText);
   if (parseErr) return err(parseErr);
   return ok(results);
 }
@@ -3018,6 +3347,203 @@ async function gitDiff(client, object) {
   });
 }
 
+// src/core/adt/businessservices/validate.ts
+var SEVERITY_OK = "OK";
+async function validateServiceBinding(client, options) {
+  const bindingType = options.bindingType ?? "ODATA";
+  const bindingVersion = options.bindingVersion ?? "V4";
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: "/sap/bc/adt/businessservices/bindings/validation",
+    params: {
+      objname: options.bindingName.toUpperCase(),
+      description: options.description ?? "",
+      serviceBindingVersion: `${bindingType}\\${bindingVersion}`,
+      serviceDefinition: options.serviceDefinition.toUpperCase(),
+      package: options.packageName.toUpperCase()
+    }
+  });
+  const [text, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to validate service binding ${options.bindingName}`
+  );
+  if (checkErr) return err(checkErr);
+  const severity = extractTagText(text, "SEVERITY");
+  if (severity && severity !== SEVERITY_OK) {
+    const shortText = extractTagText(text, "SHORT_TEXT") ?? "";
+    return err(new Error(`Service binding validation failed (${severity}): ${shortText}`));
+  }
+  return ok(void 0);
+}
+
+// src/core/adt/businessservices/create.ts
+var SERVICE_BINDING_TYPE_CODE = "SRVB/SVB";
+var BINDING_CATEGORY = "1";
+var CONTENT_VERSION = "0001";
+async function createServiceBindingObject(client, options, username) {
+  const bindingType = options.bindingType ?? "ODATA";
+  const bindingVersion = options.bindingVersion ?? "V4";
+  const description = options.description ?? "";
+  const bindingName = options.bindingName.toUpperCase();
+  const serviceDefinition = options.serviceDefinition.toUpperCase();
+  const packageName = options.packageName.toUpperCase();
+  const body = `<?xml version="1.0" encoding="UTF-8"?>
+<srvb:serviceBinding xmlns:srvb="http://www.sap.com/adt/ddic/ServiceBindings" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:description="${escapeXml(description)}" adtcore:language="EN" adtcore:name="${bindingName}" adtcore:type="${SERVICE_BINDING_TYPE_CODE}" adtcore:masterLanguage="EN" adtcore:responsible="${username.toUpperCase()}">
+  <adtcore:packageRef adtcore:name="${packageName}"/>
+  <srvb:services srvb:name="${serviceDefinition}">
+    <srvb:content srvb:version="${CONTENT_VERSION}">
+      <srvb:serviceDefinition adtcore:name="${serviceDefinition}"/>
+    </srvb:content>
+  </srvb:services>
+  <srvb:binding srvb:category="${BINDING_CATEGORY}" srvb:type="${bindingType}" srvb:version="${bindingVersion}">
+    <srvb:implementation adtcore:name=""/>
+  </srvb:binding>
+</srvb:serviceBinding>`;
+  const params = {};
+  if (options.transport) {
+    params["corrNr"] = options.transport;
+  }
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: "/sap/bc/adt/businessservices/bindings",
+    params,
+    headers: { "Content-Type": "application/*" },
+    body
+  });
+  const [, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to create service binding ${options.bindingName}`
+  );
+  if (checkErr) return err(checkErr);
+  return ok(void 0);
+}
+
+// src/core/adt/businessservices/activate.ts
+var SERVICE_BINDING_TYPE_CODE2 = "SRVB/SVB";
+async function activateServiceBinding(client, bindingName) {
+  return activateByReferences(client, [{
+    uri: `/sap/bc/adt/businessservices/bindings/${bindingName.toLowerCase()}`,
+    type: SERVICE_BINDING_TYPE_CODE2,
+    name: bindingName.toUpperCase(),
+    extension: ""
+  }]);
+}
+
+// src/core/adt/businessservices/helpers.ts
+var BINDINGS_BASE_PATH = "/sap/bc/adt/businessservices/bindings";
+var LOCK_ACCEPT_HEADER = "application/*,application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result";
+var PUBLISH_JOBS_PATH = "/sap/bc/adt/businessservices/odatav4/publishjobs";
+var UNPUBLISH_JOBS_PATH = "/sap/bc/adt/businessservices/odatav4/unpublishjobs";
+var SEVERITY_OK2 = "OK";
+function bindingPath(bindingName) {
+  return `${BINDINGS_BASE_PATH}/${bindingName.toLowerCase()}`;
+}
+async function lockServiceBinding(client, bindingName) {
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: bindingPath(bindingName),
+    params: {
+      "_action": "LOCK",
+      "accessMode": "MODIFY"
+    },
+    headers: { "Accept": LOCK_ACCEPT_HEADER }
+  });
+  const [text, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to lock service binding ${bindingName}`
+  );
+  if (checkErr) return err(checkErr);
+  const [lockHandle, extractErr] = extractLockHandle(text);
+  if (extractErr) return err(new Error(`Failed to extract lock handle: ${extractErr.message}`));
+  return ok(lockHandle);
+}
+async function unlockServiceBinding(client, bindingName, lockHandle) {
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: bindingPath(bindingName),
+    params: {
+      "_action": "UNLOCK",
+      "lockHandle": lockHandle
+    }
+  });
+  const [, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to unlock service binding ${bindingName}`
+  );
+  if (checkErr) return err(checkErr);
+  return ok(void 0);
+}
+async function submitServiceBindingJob(client, bindingName, action) {
+  const path = action === "publish" ? PUBLISH_JOBS_PATH : UNPUBLISH_JOBS_PATH;
+  const body = `<?xml version="1.0" encoding="UTF-8"?>
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:type="SCGR" adtcore:name="${bindingName.toUpperCase()}"/>
+</adtcore:objectReferences>`;
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path,
+    headers: { "Content-Type": "application/xml" },
+    body
+  });
+  const [text, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to ${action} service binding ${bindingName}`
+  );
+  if (checkErr) return err(checkErr);
+  const severity = extractTagText(text, "SEVERITY");
+  if (severity && severity !== SEVERITY_OK2) {
+    const shortText = extractTagText(text, "SHORT_TEXT") ?? "";
+    return err(new Error(`Service binding ${action} failed (${severity}): ${shortText}`));
+  }
+  return ok(extractTagText(text, "SHORT_TEXT") ?? "");
+}
+
+// src/core/adt/businessservices/publish.ts
+async function publishServiceBinding(client, bindingName) {
+  return runBindingJob(client, bindingName, "publish");
+}
+async function runBindingJob(client, bindingName, action) {
+  const [lockHandle, lockErr] = await lockServiceBinding(client, bindingName);
+  if (lockErr) return err(lockErr);
+  debug(`Service binding lock acquired for ${action}: handle=${lockHandle}`);
+  const [message, jobErr] = await submitServiceBindingJob(client, bindingName, action);
+  const [, unlockErr] = await unlockServiceBinding(client, bindingName, lockHandle);
+  if (jobErr) return err(jobErr);
+  if (unlockErr) return err(unlockErr);
+  return ok(message);
+}
+
+// src/core/adt/businessservices/delete.ts
+async function deleteServiceBinding(client, bindingName, transport) {
+  const [lockHandle, lockErr] = await lockServiceBinding(client, bindingName);
+  if (lockErr) return err(lockErr);
+  const [, unpublishErr] = await submitServiceBindingJob(client, bindingName, "unpublish");
+  if (unpublishErr) debug(`Unpublish before delete skipped: ${unpublishErr.message}`);
+  const params = { lockHandle };
+  if (transport) params["corrNr"] = transport;
+  const [response, requestErr] = await client.request({
+    method: "DELETE",
+    path: bindingPath(bindingName),
+    params,
+    headers: { "Accept": "text/plain" }
+  });
+  const [, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to delete service binding ${bindingName}`
+  );
+  if (checkErr) {
+    await unlockServiceBinding(client, bindingName, lockHandle);
+    return err(checkErr);
+  }
+  return ok(void 0);
+}
+
 // src/client/methods/craud/read.ts
 async function read(state, requestor, objects) {
   if (!state.session) return err(new Error("Not logged in"));
@@ -3058,6 +3584,19 @@ async function update(state, requestor, object, transport) {
   return ok(void 0);
 }
 
+// src/client/methods/craud/specialcases/classes/writeClassInclude.ts
+async function writeClassInclude(state, requestor, className, includeType, source, transport) {
+  if (!state.session) return err(new Error("Not logged in"));
+  const objRef = { name: className, extension: "aclass" };
+  const [lockHandle, lockErr] = await lockObject(requestor, objRef);
+  if (lockErr) return err(lockErr);
+  const [, updateErr] = await updateClassInclude(requestor, className, includeType, source, lockHandle, transport);
+  const [, unlockErr] = await unlockObject(requestor, objRef, lockHandle);
+  if (updateErr) return err(updateErr);
+  if (unlockErr) return err(unlockErr);
+  return ok(void 0);
+}
+
 // src/client/methods/craud/upsert.ts
 async function upsertSingle(state, requestor, object, packageName, transport) {
   if (!state.session) return err(new Error("Not logged in"));
@@ -3234,6 +3773,41 @@ function getObjectConfig() {
   return Object.values(OBJECT_CONFIG_MAP);
 }
 
+// src/client/methods/craud/specialcases/businessservices/createServiceBinding.ts
+async function createServiceBinding(state, requestor, options) {
+  if (!state.session) return err(new Error("Not logged in"));
+  const [, validateErr] = await validateServiceBinding(requestor, options);
+  if (validateErr) return err(validateErr);
+  const [, createErr] = await createServiceBindingObject(requestor, options, state.session.username);
+  if (createErr) return err(createErr);
+  const [activation, activateErr] = await activateServiceBinding(requestor, options.bindingName);
+  if (activateErr) return err(activateErr);
+  if (activation.some((result2) => result2.status === "error")) {
+    return err(new Error(`Service binding ${options.bindingName} failed activation`));
+  }
+  const result = {
+    name: options.bindingName.toUpperCase(),
+    serviceDefinition: options.serviceDefinition.toUpperCase(),
+    created: true,
+    activation,
+    published: false
+  };
+  if (options.publish === false) {
+    return ok(result);
+  }
+  const [publishMessage, publishErr] = await publishServiceBinding(requestor, options.bindingName);
+  if (publishErr) return err(publishErr);
+  result.published = true;
+  if (publishMessage) result.publishMessage = publishMessage;
+  return ok(result);
+}
+
+// src/client/methods/craud/specialcases/businessservices/deleteServiceBinding.ts
+async function deleteServiceBinding2(state, requestor, bindingName, transport) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return deleteServiceBinding(requestor, bindingName, transport);
+}
+
 // src/client/methods/internal/cookies.ts
 function storeCookies(cookies, response) {
   const setCookieHeader = response.headers.get("set-cookie");
@@ -3546,6 +4120,9 @@ var ADTClientImpl = class {
   async update(object, transport) {
     return update(this.state, this.requestor, object, transport);
   }
+  async writeClassInclude(className, includeType, source, transport) {
+    return writeClassInclude(this.state, this.requestor, className, includeType, source, transport);
+  }
   async upsert(objects, packageName, transport) {
     return upsert(this.state, this.requestor, objects, packageName, transport);
   }
@@ -3611,6 +4188,13 @@ var ADTClientImpl = class {
   async gitDiff(objects) {
     return gitDiff2(this.state, this.requestor, objects);
   }
+  // --- Business Services ---
+  async createServiceBinding(options) {
+    return createServiceBinding(this.state, this.requestor, options);
+  }
+  async deleteServiceBinding(bindingName, transport) {
+    return deleteServiceBinding2(this.state, this.requestor, bindingName, transport);
+  }
   // --- Configuration ---
   getObjectConfig() {
     return getObjectConfig();
@@ -3627,6 +4211,7 @@ function createClient(config) {
   return ok(new ADTClientImpl(config));
 }
 export {
+  BehaviorImplementationType,
   ExternalReferencesError,
   activateLogging,
   buildSQLQuery,