arc-1 1.2.0 → 1.3.0

package/dist/handlers/write/create.js

@@ -2,23 +2,23 @@
  * SAPWrite actions — create + batch_create.
  */
 import { createObject, lockObject, safeUpdateObject, safeUpdateSource, unlockObject, updateObject, } from '../../adt/crud.js';
-import { normalizeAdtLanguage, rewriteKtdText } from '../../adt/ddic-xml.js';
+import { formatKtdWriteReport, normalizeAdtLanguage, rewriteKtdDocument, } from '../../adt/ddic-xml.js';
 import { activate, activateBatch } from '../../adt/devtools.js';
-import { AdtApiError } from '../../adt/errors.js';
+import { AdtApiError, AdtSafetyError } from '../../adt/errors.js';
 import { spliceFmSignature } from '../../adt/fm-signature.js';
-import { checkPackage } from '../../adt/safety.js';
+import { checkOperation, checkPackage, OperationType } from '../../adt/safety.js';
 import { isServerDrivenObjectType } from '../../adt/server-driven.js';
-import { getTransport, getTransportInfo } from '../../adt/transport.js';
+import { getTransport } from '../../adt/transport.js';
 import { escapeXmlAttr, parseFunctionModuleProperties } from '../../adt/xml-parser.js';
 import { validateAffHeader } from '../../aff/validator.js';
-import { logger } from '../../server/logger.js';
-import { buildBatchActivationStatuses, formatBatchActivationStatuses, } from '../activate.js';
-import { invalidateInactiveList } from '../cache-security.js';
+import { activationDetailMatchesObject } from '../activation-results.js';
 import { guardCdsSyntax } from '../cds-hints.js';
 import { getCachedFeatures, isDomainsEndpointAvailable, isTablesEndpointAvailable, isTableTypesEndpointAvailable, } from '../feature-cache.js';
-import { functionGroupObjectUrl, functionModuleObjectUrl, normalizeObjectType, normalizeWriteObjectType, objectBasePath, objectUrlForType, sourceUrlForType, } from '../object-types.js';
+import { canonicalTablType, functionGroupObjectUrl, functionModuleObjectUrl, normalizeWriteObjectType, objectBasePath, objectUrlForType, sourceUrlForType, } from '../object-types.js';
 import { errorResult, textResult } from '../shared.js';
-import { buildCreateXml, createContentTypeForType, DOMA_WRITE_UNAVAILABLE_HINT, dtelNeedsPostCreateUpdate, getMetadataWriteProperties, isMetadataWriteType, mergePreWriteWarnings, resolveWriteSystemType, runPreWriteLint, runRapPreflightValidation, SKTD_V2_CONTENT_TYPE, stripFmParamCommentBlock, TABL_DT_WRITE_UNAVAILABLE_HINT, TTYP_WRITE_UNAVAILABLE_HINT, tryPostSaveSyntaxCheck, vendorContentTypeForType, } from '../write-helpers.js';
+import { buildCreateXml, createContentTypeForType, DOMA_WRITE_UNAVAILABLE_HINT, getMetadataWriteProperties, isMetadataWriteType, mergePreWriteWarnings, resolveWriteSystemType, runPreWriteLint, runRapPreflightValidation, SKTD_V2_CONTENT_TYPE, stripFmParamCommentBlock, TABL_DT_WRITE_UNAVAILABLE_HINT, TTYP_WRITE_UNAVAILABLE_HINT, tryPostSaveSyntaxCheck, vendorContentTypeForType, } from '../write-helpers.js';
+import { batchCreateResult, batchEntryResult, batchFailureMessage, failBatchEntry, } from './batch-results.js';
+import { resolveCreateTransport } from './create-transport.js';
 const FUNCTION_MODULE_MEDIA_TYPE = /^application\/vnd\.sap\.adt\.functions\.fmodules(?:\.v\d+)?\+xml\b/i;
 function normalizePackageOverride(rawPackage, fallback) {
     if (rawPackage === undefined || rawPackage === null) {
@@ -300,7 +300,7 @@ function isKtdCreateEndpointUnavailable(err) {
     return combined.includes('resource') && combined.includes('/sap/bc/adt/documentation/ktd/documents');
 }
 export async function writeActionCreate(ctx) {
-    const { client, args, config, type, name, source, transport, lintOverride, preflightOverride, objectUrl, srcUrl, invalidateWrittenObject, } = ctx;
+    const { client, args, config, type, name, source, hasSource, transport, lintOverride, preflightOverride, objectUrl, srcUrl, invalidateWrittenObject, } = ctx;
     // FUNC and FUGR structural includes both INHERIT the parent group's package — SAP ignores
     // _package for them — so the allowlist must be checked against the group's real package.
     // Gating on args.package here would let a caller write into a disallowed package by claiming $TMP.
@@ -311,39 +311,12 @@ export async function writeActionCreate(ctx) {
         : String(args.package ?? '$TMP');
     await checkPackage(client.safety, pkg, client.getPackageHierarchyResolver());
     const description = String(args.description ?? name);
-    // Pre-flight: check transport requirements for non-$TMP packages when no transport provided.
-    // SAP requires a transport number for objects in transportable packages.
-    // Instead of letting SAP return a cryptic error, we detect this early and return
-    // an actionable error message guiding the LLM to use SAPTransport first.
     let effectiveTransport = transport;
-    if (!transport && pkg.toUpperCase() !== '$TMP') {
-        try {
-            const transportInfo = await getTransportInfo(client.http, client.safety, objectUrl, pkg, 'I');
-            if (transportInfo.lockedTransport) {
-                // Object is already locked in a transport — use it automatically
-                effectiveTransport = transportInfo.lockedTransport;
-            }
-            else if (!transportInfo.isLocal && transportInfo.recording) {
-                // Transport IS required but none provided — return guidance
-                const existingList = transportInfo.existingTransports.length > 0
-                    ? `\n\nExisting transports for this package:\n${transportInfo.existingTransports
-                        .slice(0, 10)
-                        .map((t) => `  - ${t.id}: ${t.description} (${t.owner})`)
-                        .join('\n')}`
-                    : '';
-                return errorResult(`Package "${pkg}" requires a transport number for object creation, but none was provided.\n\n` +
-                    `To fix this, either:\n` +
-                    `1. Use SAPTransport(action="list") to find an existing modifiable transport\n` +
-                    `2. Use SAPTransport(action="create", description="...") to create a new one\n` +
-                    `3. Then retry SAPWrite(action="create", ..., transport="<transport_id>")` +
-                    existingList);
-            }
-            // isLocal=true or recording=false → no transport needed, proceed without one
-        }
-        catch {
-            // If transportInfo check fails (older system, permissions, etc.), proceed without it.
-            // SAP will return its own error if a transport is actually needed.
-        }
+    if (!transport) {
+        const resolved = await resolveCreateTransport(client, objectUrl, pkg, config.minimalErrors);
+        if (resolved.error)
+            return errorResult(resolved.error);
+        effectiveTransport = resolved.transport;
     }
     // MSAG transport-vs-task guard. Some SAP releases silently drop message inserts when
     // given a task number as corrNr — CL_ADT_MESSAGE_CLASS_API=>create() passes corrNr to
@@ -412,19 +385,36 @@ export async function writeActionCreate(ctx) {
             }
             throw err;
         }
-        // If initial Markdown was provided, follow up with an update PUT to write it.
-        // Same envelope contract as the update path: fetch-then-rewrite ensures we
-        // PUT back exactly the shape SAP gave us (with all the server-assigned
-        // metadata), only swapping <sktd:text>.
-        if (source) {
-            const { source: currentEnvelope } = await client.getKtd(name);
-            const body = rewriteKtdText(currentEnvelope, source);
-            await safeUpdateObject(client.http, client.safety, objectUrl, body, SKTD_V2_CONTENT_TYPE, effectiveTransport, getCachedFeatures()?.abapRelease);
+        // Bodies and/or short texts require a follow-up PUT of the server-provided envelope.
+        // The POST already succeeded, so every later failure is reported as partial success.
+        const shortTexts = args.shortTexts;
+        if (hasSource || shortTexts?.length) {
+            let summary;
+            try {
+                const { source: currentEnvelope } = await client.getKtd(name);
+                const report = { proseHeadings: [] };
+                const body = rewriteKtdDocument(currentEnvelope, hasSource ? source : undefined, shortTexts, report);
+                summary = formatKtdWriteReport(currentEnvelope, body, report);
+                await safeUpdateObject(client.http, client.safety, objectUrl, body, SKTD_V2_CONTENT_TYPE, effectiveTransport, getCachedFeatures()?.abapRelease);
+            }
+            catch (err) {
+                // The POST above already succeeded, so the KTD exists. Say so — a generic
+                // read/rewrite/PUT failure invites the same create again, which 409s.
+                invalidateWrittenObject(type, name);
+                const documentationPart = shortTexts?.length ? 'documentation' : 'documentation body';
+                return errorResult(`Created SKTD ${name} in package ${pkg}, but the ${documentationPart} was NOT written: ` +
+                    `${err instanceof Error ? err.message : String(err)}\n` +
+                    `The object exists — verify it with SAPRead. Inspect the reported cause: correct or remove invalid ` +
+                    `${[hasSource && 'source', shortTexts?.length && 'shortTexts'].filter(Boolean).join(' and ')} input, ` +
+                    `or wait for a transient read/PUT failure to recover. Then use ` +
+                    `SAPWrite(action="update", type="SKTD", name="${name}", …); do not retry create.`);
+            }
             invalidateWrittenObject(type, name);
-            return textResult(`Created SKTD ${name} in package ${pkg} and wrote Markdown content.\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
+            const writtenPart = shortTexts?.length ? 'its documentation' : 'Markdown content';
+            return textResult(`Created SKTD ${name} in package ${pkg} and wrote ${writtenPart}.\n${summary}\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
         }
         invalidateWrittenObject();
-        return textResult(`Created SKTD ${name} in package ${pkg} (no Markdown content written — pass "source" to write the body).\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
+        return textResult(`Created SKTD ${name} in package ${pkg} (no Markdown content written — pass "source" for node bodies, and optionally "shortTexts" for per-node short texts).\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
     }
     // Build type-specific creation XML body.
     // SAP ADT requires the root element to match the object type —
@@ -472,10 +462,11 @@ export async function writeActionCreate(ctx) {
         await persistFunctionModuleProcessingMetadata(client, objectUrl, name, metadataProperties.processingType, metadataProperties.updateTaskKind, effectiveTransport);
     }
     if (isMetadataWriteType(type)) {
-        // SAP's DTEL POST ignores labels, searchHelp, etc. — they require a follow-up PUT.
+        // SAP's DTEL POST stores only a shell without the description, labels or custom lengths, so
+        // every DTEL create needs this follow-up PUT.
         // Use withStatefulSession directly (not safeUpdateObject) to keep the lock cycle
         // on the main client's session, avoiding lock contention with subsequent operations.
-        if (type === 'DTEL' && dtelNeedsPostCreateUpdate(metadataProperties)) {
+        if (type === 'DTEL') {
             const ct = vendorContentTypeForType(type);
             await client.http.withStatefulSession(async (session) => {
                 const lock = await lockObject(session, client.safety, objectUrl, 'MODIFY', getCachedFeatures()?.abapRelease, systemType);
@@ -543,420 +534,292 @@ export async function writeActionCreate(ctx) {
     return textResult(`Created ${type} ${name} in package ${pkg}.\n${result}`);
 }
 export async function writeActionBatchCreate(ctx) {
-    const { client, args, config, cachingLayer, cacheSecurity, transport, lintOverride, preflightOverride, invalidateWrittenObject, } = ctx;
+    const { client, args, config, transport, lintOverride, preflightOverride, invalidateWrittenObject } = ctx;
     const objects = args.objects;
     if (!objects || !Array.isArray(objects) || objects.length === 0) {
         return errorResult('"objects" array is required and must be non-empty for batch_create action.');
     }
-    // Opt-in deferred-activation: writes every object as an inactive draft first,
-    // then issues a single terminal activateBatch over the written subset. Use case:
-    // composition-linked DDLS / interdependent RAP graphs where per-object inline
-    // activate() can't resolve cross-references to not-yet-active siblings.
+    checkOperation(client.safety, OperationType.Create, 'CreateObject');
     const activateAtEnd = args.activateAtEnd === true || String(args.activateAtEnd) === 'true';
     const defaultPackage = normalizePackageOverride(args.package, '$TMP');
-    const batchPlan = objects.map((obj) => {
-        const objType = normalizeWriteObjectType(String(obj.type ?? ''));
-        const objName = String(obj.name ?? '');
-        const objPackage = normalizePackageOverride(obj.package, defaultPackage);
-        const explicitTransport = normalizeTransportOverride(obj.transport) ?? transport;
-        const group = objType === 'FUNC' ? String(obj.group ?? args.group ?? '').trim() : undefined;
-        const objectUrl = objType === 'FUNC' ? (group ? functionModuleObjectUrl(group, objName) : '') : objectUrlForType(objType, objName);
-        return { obj, type: objType, name: objName, packageName: objPackage, explicitTransport, group, objectUrl };
+    const warnings = [];
+    const batchPlan = objects.map((obj, index) => {
+        const type = normalizeWriteObjectType(String(obj.type ?? ''));
+        const name = String(obj.name ?? '');
+        const packageName = normalizePackageOverride(obj.package, defaultPackage);
+        const group = type === 'FUNC' ? String(obj.group ?? args.group ?? '').trim() : undefined;
+        const objectUrl = type === 'FUNC' ? (group ? functionModuleObjectUrl(group, name) : '') : objectUrlForType(type, name);
+        const metadata = getMetadataWriteProperties(obj);
+        if (type === 'FUNC')
+            metadata.group = group;
+        const source = obj.source ? String(obj.source) : undefined;
+        return {
+            obj,
+            type,
+            name,
+            packageName,
+            group,
+            objectUrl,
+            metadata,
+            source,
+            transport: normalizeTransportOverride(obj.transport) ?? transport,
+            description: String(obj.description ?? name),
+            metadataObject: isMetadataWriteType(type),
+            body: '',
+            contentType: '',
+            sourceUrl: '',
+            result: batchEntryResult(index, type, name, packageName),
+        };
     });
-    const functionWithoutGroup = batchPlan.find((item) => item.type === 'FUNC' && !item.group);
-    if (functionWithoutGroup) {
-        return errorResult(`FUNC ${functionWithoutGroup.name} in batch_create requires "group" on the object entry or top-level request.`);
-    }
-    // A FUNC is contained by its FUGR and inherits the parent's package. Resolve
-    // that package before any safety or transport check; trusting the batch's
-    // caller-supplied/default package would gate the wrong object boundary.
-    try {
-        for (const plan of batchPlan) {
+    const results = batchPlan.map((plan) => plan.result);
+    const activationMessages = [];
+    const report = (preflight = false) => batchCreateResult(results, { preflight, activateAtEnd, warnings, activationMessages });
+    const seen = new Map();
+    // Validate the complete input before package/transport reads or the first create.
+    for (const plan of batchPlan) {
+        const errors = [];
+        try {
+            if (!plan.name.trim() || plan.name !== plan.name.trim() || plan.name !== plan.name.toUpperCase()) {
+                errors.push(`Object name "${plan.name}" must be non-empty, uppercase, and have no surrounding whitespace (e.g. "${plan.name.trim().toUpperCase()}"); source may stay mixed case.`);
+            }
+            const keyType = plan.type === 'INCL' ? 'PROG' : ['CLAS', 'INTF'].includes(plan.type) ? 'OO' : canonicalTablType(plan.type);
+            const key = `${keyType}\0${plan.name.toUpperCase()}`;
+            const previous = seen.get(key);
+            if (previous !== undefined)
+                errors.push(`Duplicate object: entry ${plan.result.index + 1} repeats entry ${previous + 1}.`);
+            else
+                seen.set(key, plan.result.index);
+            if (plan.type === 'FUNC' && !plan.group) {
+                errors.push(`FUNC ${plan.name} in batch_create requires "group" on the object entry or top-level request.`);
+            }
+            if (isServerDrivenObjectType(plan.type)) {
+                errors.push(`batch_create does not support server-driven object type ${plan.type}. Create it with a single SAPWrite(action="create", type="${plan.type}", name="${plan.name}") call.`);
+            }
+            if ((plan.type === 'TABL' || plan.type === 'TABL/DT') && isTablesEndpointAvailable() === false)
+                errors.push(TABL_DT_WRITE_UNAVAILABLE_HINT);
+            if (plan.type === 'DOMA' && isDomainsEndpointAvailable() === false)
+                errors.push(DOMA_WRITE_UNAVAILABLE_HINT);
+            if (plan.type === 'TTYP' && isTableTypesEndpointAvailable() === false)
+                errors.push(TTYP_WRITE_UNAVAILABLE_HINT);
+            if (plan.type === 'INCL' && plan.name.startsWith('L')) {
+                errors.push('Function-group structural includes require a single SAPWrite create with group; batch_create does not support them.');
+            }
+            const aff = validateAffHeader(plan.type, { description: plan.description, originalLanguage: 'en' });
+            if (!aff.valid)
+                errors.push(`AFF metadata validation failed:\n- ${(aff.errors ?? []).join('\n- ')}`);
             if (plan.type === 'FUNC') {
-                plan.packageName = await resolveFunctionGroupCreatePackage(client, plan.group, 
-                // The top-level package is the default for ordinary batch entries,
-                // not a claim about a contained FUNC. Only an item-level package is
-                // explicit enough to assert the inherited FUGR package.
-                plan.obj.package);
+                const prepared = prepareFunctionModuleCreateSource(plan.name, plan.source, plan.obj.parameters);
+                plan.source = prepared.shouldWrite ? prepared.source : undefined;
+                warnings.push(...prepared.warnings.map((warning) => `${plan.type} ${plan.name}: ${warning}`));
+            }
+            if (!plan.metadataObject && plan.source && !isServerDrivenObjectType(plan.type)) {
+                const cds = guardCdsSyntax(plan.type, plan.source, getCachedFeatures());
+                if (cds)
+                    errors.push(cds.content[0].text);
+                const rap = runRapPreflightValidation(plan.source, plan.type, plan.name, getCachedFeatures(), config.systemType, preflightOverride);
+                if (rap.blocked)
+                    errors.push(rap.result.content[0].text);
+                if (rap.warnings)
+                    warnings.push(`${plan.type} ${plan.name}: ${rap.warnings}`);
+                const lint = runPreWriteLint(plan.source, plan.type, plan.name, config, lintOverride);
+                if (lint.blocked)
+                    errors.push(`source rejected by lint: ${lint.result.content[0].text}`);
+                if (lint.warnings)
+                    warnings.push(`${plan.type} ${plan.name}: ${lint.warnings}`);
+            }
+            if (!isServerDrivenObjectType(plan.type)) {
+                plan.sourceUrl =
+                    plan.type === 'FUNC' ? `${plan.objectUrl}/source/main` : sourceUrlForType(plan.type, plan.name);
+            }
+            if (plan.type === 'DTEL' ||
+                plan.type === 'TTYP' ||
+                (plan.type === 'FUNC' && plan.metadata.processingType !== undefined) ||
+                (!plan.metadataObject && plan.source)) {
+                plan.result.write = 'not_attempted';
             }
         }
-    }
-    catch (err) {
-        return errorResult(err instanceof Error ? err.message : String(err));
-    }
-    // Check every target package before starting any creates.
-    // Resolver is shared across the loop so subtree BFS happens once even when
-    // many objects target descendants of the same `ZFOO/**` root.
-    {
-        const resolver = client.getPackageHierarchyResolver();
-        for (const pkg of new Set(batchPlan.map((item) => item.packageName))) {
-            await checkPackage(client.safety, pkg, resolver);
+        catch (err) {
+            errors.push(batchFailureMessage(err, false));
         }
+        if (errors.length)
+            failBatchEntry(plan.result, 'preflight', errors.join('\n'));
     }
-    // Pre-flight transport check for batch_create (same logic as single create),
-    // but keyed by each effective package because objects can override package.
-    const autoTransportByPackage = new Map();
-    const firstPlanNeedingTransportByPackage = new Map();
+    if (results.some((entry) => entry.status === 'failed'))
+        return report(true);
+    // Resolve FUNC's actual inherited package and enforce every package before mutations.
     for (const plan of batchPlan) {
-        if (!plan.explicitTransport &&
-            plan.packageName.toUpperCase() !== '$TMP' &&
-            !firstPlanNeedingTransportByPackage.has(plan.packageName)) {
-            firstPlanNeedingTransportByPackage.set(plan.packageName, plan);
-        }
-    }
-    for (const [pkg, plan] of firstPlanNeedingTransportByPackage) {
         try {
-            const transportInfo = await getTransportInfo(client.http, client.safety, plan.objectUrl, pkg, 'I');
-            if (transportInfo.lockedTransport) {
-                autoTransportByPackage.set(pkg, transportInfo.lockedTransport);
-            }
-            else if (!transportInfo.isLocal && transportInfo.recording) {
-                const existingList = transportInfo.existingTransports.length > 0
-                    ? `\n\nExisting transports for this package:\n${transportInfo.existingTransports
-                        .slice(0, 10)
-                        .map((t) => `  - ${t.id}: ${t.description} (${t.owner})`)
-                        .join('\n')}`
-                    : '';
-                return errorResult(`Package "${pkg}" requires a transport number for object creation, but none was provided.\n\n` +
-                    `To fix this, either:\n` +
-                    `1. Use SAPTransport(action="list") to find an existing modifiable transport\n` +
-                    `2. Use SAPTransport(action="create", description="...") to create a new one\n` +
-                    `3. Then retry SAPWrite(action="batch_create", ..., transport="<transport_id>")` +
-                    existingList);
+            if (plan.type === 'FUNC') {
+                plan.packageName = await resolveFunctionGroupCreatePackage(client, plan.group, plan.obj.package);
+                plan.result.packageName = plan.packageName;
             }
+            await checkPackage(client.safety, plan.packageName, client.getPackageHierarchyResolver());
         }
         catch (err) {
-            logger.warn('SAPWrite batch_create transport preflight failed; continuing without auto transport', {
-                package: pkg,
-                type: plan.type,
-                name: plan.name,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            // If transportInfo check fails, proceed — SAP will return its own error if needed.
+            failBatchEntry(plan.result, 'preflight', batchFailureMessage(err, config.minimalErrors));
         }
     }
-    const results = [];
-    const batchWarnings = [];
-    // Per-batch cache for the MSAG transport-vs-task guard. The bug is universal so the
-    // guard fires for every MSAG entry, but a batch typically shares one transport — cache
-    // the lookup result to avoid one HTTP roundtrip per object.
-    const transportLookupCache = new Map();
-    // Accumulated objects whose create + source-write phase succeeded — used by the
-    // terminal activateBatch when activateAtEnd=true. Order matches the input order.
-    const writtenObjects = [];
-    // BTP/Steampunk needs cloud-correct create XML (G-3) + a real responsible user (G-5);
-    // constant across the batch, so resolve once.
+    if (results.some((entry) => entry.status === 'failed'))
+        return report(true);
+    const autoTransportByPackage = new Map();
+    for (const plan of batchPlan) {
+        if (plan.transport || autoTransportByPackage.has(plan.packageName))
+            continue;
+        autoTransportByPackage.set(plan.packageName, undefined);
+        try {
+            const resolved = await resolveCreateTransport(client, plan.objectUrl, plan.packageName, config.minimalErrors);
+            if (resolved.error)
+                failBatchEntry(plan.result, 'preflight', resolved.error);
+            else
+                autoTransportByPackage.set(plan.packageName, resolved.transport);
+        }
+        catch (error) {
+            failBatchEntry(plan.result, 'preflight', batchFailureMessage(error, config.minimalErrors));
+        }
+    }
+    if (results.some((entry) => entry.status === 'failed'))
+        return report(true);
     const systemType = resolveWriteSystemType(config, client);
     const cloud = systemType === 'btp';
     const responsible = config.username || (await client.getEffectiveUser());
+    const transportLookupCache = new Map();
     for (const plan of batchPlan) {
-        const { obj, type: objType, name: objName, packageName: objPackage, objectUrl: objUrl } = plan;
-        const objTransport = plan.explicitTransport ?? autoTransportByPackage.get(objPackage);
-        const metadataObject = isMetadataWriteType(objType);
-        let objSource = obj.source ? String(obj.source) : undefined;
-        const objDescription = String(obj.description ?? objName);
-        if (objType === 'FUNC') {
-            const prepared = prepareFunctionModuleCreateSource(objName, objSource, obj.parameters);
-            objSource = prepared.shouldWrite ? prepared.source : undefined;
-            batchWarnings.push(...prepared.warnings.map((warning) => `${objType} ${objName}: ${warning}`));
-        }
-        // Mixed-case object name rejection (matches the create-path check above).
-        // Universal SAP convention — TADIR is uppercase on every release.
-        // Cheap check first: no HTTP call, fail fast on bad names.
-        if (objName && objName !== objName.toUpperCase()) {
-            results.push({
-                type: objType,
-                name: objName,
-                packageName: objPackage,
-                status: 'failed',
-                error: `Object name "${objName}" contains lowercase characters. SAP object names must be uppercase (e.g. "${objName.toUpperCase()}"). Source code inside the object can use mixed case.`,
-            });
-            break;
-        }
-        // MSAG transport-vs-task guard (per-batch cache to avoid per-object roundtrip).
-        if (objType === 'MSAG' && objTransport) {
-            let tr = transportLookupCache.get(objTransport);
-            if (tr === undefined) {
-                tr = await getTransport(client.http, client.safety, objTransport);
-                transportLookupCache.set(objTransport, tr);
-            }
-            if (!tr) {
-                results.push({
-                    type: objType,
-                    name: objName,
-                    packageName: objPackage,
-                    status: 'failed',
-                    error: `Transport "${objTransport}" is not a valid transport request. MSAG creation requires a transport request number, not a task number.`,
-                });
-                break;
+        try {
+            plan.transport ??= autoTransportByPackage.get(plan.packageName);
+            if (plan.type === 'MSAG' && plan.transport) {
+                if (!transportLookupCache.has(plan.transport))
+                    transportLookupCache.set(plan.transport, await getTransport(client.http, client.safety, plan.transport));
+                if (!transportLookupCache.get(plan.transport)) {
+                    failBatchEntry(plan.result, 'preflight', `Transport "${plan.transport}" is not a valid transport request. MSAG creation requires a transport request number, not a task number.`);
+                    continue;
+                }
             }
         }
-        // AFF header validation per object (if schema available)
-        const affResult = validateAffHeader(objType, { description: objDescription, originalLanguage: 'en' });
-        if (!affResult.valid) {
-            results.push({
-                type: objType,
-                name: objName,
-                packageName: objPackage,
-                status: 'failed',
-                error: `AFF metadata validation failed:\n- ${(affResult.errors ?? []).join('\n- ')}`,
-            });
-            break;
+        catch (err) {
+            failBatchEntry(plan.result, 'preflight', batchFailureMessage(err, config.minimalErrors));
+            continue;
         }
         try {
-            // Pre-validate source with lint BEFORE creating the object to avoid orphaned objects.
-            // Metadata objects (DOMA/DTEL) are XML-only and intentionally skip source lint.
-            if (!metadataObject && objSource) {
-                const cdsGuard = guardCdsSyntax(objType, objSource, getCachedFeatures());
-                if (cdsGuard) {
-                    results.push({
-                        type: objType,
-                        name: objName,
-                        packageName: objPackage,
-                        status: 'failed',
-                        error: cdsGuard.content[0].text,
-                    });
-                    break;
-                }
-                const preflightWarnings = runRapPreflightValidation(objSource, objType, objName, getCachedFeatures(), config.systemType, preflightOverride);
-                if (preflightWarnings.blocked) {
-                    results.push({
-                        type: objType,
-                        name: objName,
-                        packageName: objPackage,
-                        status: 'failed',
-                        error: preflightWarnings.result.content[0].text,
-                    });
-                    break;
-                }
-                if (preflightWarnings.warnings) {
-                    batchWarnings.push(`${objType} ${objName}: ${preflightWarnings.warnings}`);
-                }
-                const lintWarnings = runPreWriteLint(objSource, objType, objName, config, lintOverride);
-                if (lintWarnings.blocked) {
-                    results.push({
-                        type: objType,
-                        name: objName,
-                        packageName: objPackage,
-                        status: 'failed',
-                        error: `source rejected by lint: ${lintWarnings.result.content[0].text}`,
-                    });
-                    break;
-                }
-            }
-            // Step 1: Create the object (per-entry transparent-table discovery gate;
-            // mirrors the single-create site above. TABL/DS skips it — /structures/ always exists.)
-            if ((objType === 'TABL' || objType === 'TABL/DT') && isTablesEndpointAvailable() === false) {
-                results.push({
-                    type: objType,
-                    name: objName,
-                    packageName: objPackage,
-                    status: 'failed',
-                    error: TABL_DT_WRITE_UNAVAILABLE_HINT,
-                });
-                break;
-            }
-            // DOMA create needs /ddic/domains/ (absent wholesale on NW 7.50/7.51) — mirror the gate above.
-            if (objType === 'DOMA' && isDomainsEndpointAvailable() === false) {
-                results.push({
-                    type: objType,
-                    name: objName,
-                    packageName: objPackage,
-                    status: 'failed',
-                    error: DOMA_WRITE_UNAVAILABLE_HINT,
-                });
-                break;
-            }
-            // TTYP create needs /ddic/tabletypes/ (absent on NW 7.50) — mirror the TABL/DT gate above.
-            if (objType === 'TTYP' && isTableTypesEndpointAvailable() === false) {
-                results.push({
-                    type: objType,
-                    name: objName,
-                    packageName: objPackage,
-                    status: 'failed',
-                    error: TTYP_WRITE_UNAVAILABLE_HINT,
-                });
-                break;
-            }
-            // Server-driven objects need the AFF engine (handleServerDrivenObjectWrite), which only runs on
-            // the single-object path. objectBasePath() has no SDO case and silently falls through to the
-            // PROG path, so without this guard a batched SDO would POST a program create body.
-            if (isServerDrivenObjectType(objType)) {
-                results.push({
-                    type: objType,
-                    name: objName,
-                    packageName: objPackage,
-                    status: 'failed',
-                    error: `batch_create does not support server-driven object type ${objType}. Create it with a single SAPWrite(action="create", type="${objType}", name="${objName}") call.`,
-                });
-                break;
-            }
-            const createUrl = objUrl.replace(/\/[^/]+$/, '');
-            const objMetadataProps = getMetadataWriteProperties(obj);
-            if (objType === 'FUNC') {
-                objMetadataProps.group = plan.group;
-            }
-            // Sets behaviorExtension + baseBdef on the metadata so buildCreateXml emits the adtTemplate;
-            // the return value (used for the optional read-back warning) isn't needed in the batch path.
-            applyBdefBehaviorExtensionMetadata(objType, objSource, objMetadataProps);
-            const body = buildCreateXml(objType, objName, objPackage, objDescription, objMetadataProps, config.language, responsible, cloud);
-            const contentType = createContentTypeForType(objType, cloud);
-            const needsPackageParam = objType === 'BDEF' || objType === 'TABL' || objType === 'TABL/DT' || objType === 'TABL/DS';
+            applyBdefBehaviorExtensionMetadata(plan.type, plan.source, plan.metadata);
+            plan.body = buildCreateXml(plan.type, plan.name, plan.packageName, plan.description, plan.metadata, config.language, responsible, cloud);
+            plan.contentType = createContentTypeForType(plan.type, cloud);
+        }
+        catch (err) {
+            // Construction errors are local input diagnostics, not SAP response details.
+            failBatchEntry(plan.result, 'preflight', batchFailureMessage(err, false));
+        }
+    }
+    if (results.some((entry) => entry.status === 'failed'))
+        return report(true);
+    const writtenPlans = [];
+    for (const plan of batchPlan) {
+        const entry = plan.result;
+        let phase = 'create';
+        try {
+            const needsPackage = plan.type === 'BDEF' || canonicalTablType(plan.type) === 'TABL';
+            entry.creation = 'unknown';
             try {
-                await createObject(client.http, client.safety, createUrl, body, contentType, objTransport, needsPackageParam ? objPackage : undefined, getCachedFeatures()?.abapRelease, systemType, objName);
+                await createObject(client.http, client.safety, plan.objectUrl.replace(/\/[^/]+$/, ''), plan.body, plan.contentType, plan.transport, needsPackage ? plan.packageName : undefined, getCachedFeatures()?.abapRelease, systemType, plan.name);
             }
-            catch (createErr) {
-                if (createErr instanceof AdtApiError && (createErr.statusCode === 400 || createErr.statusCode === 409)) {
-                    const syntaxDetail = await tryPostSaveSyntaxCheck(client, objType, objName);
-                    if (syntaxDetail) {
-                        createErr.message += syntaxDetail;
-                    }
+            catch (err) {
+                if (err instanceof AdtSafetyError)
+                    entry.creation = 'not_attempted';
+                // Keep the original create failure even if the optional diagnostic cannot run.
+                if (!config.minimalErrors && err instanceof AdtApiError && [400, 409].includes(err.statusCode)) {
+                    const detail = await tryPostSaveSyntaxCheck(client, plan.type, plan.name).catch(() => undefined);
+                    if (detail)
+                        err.message += detail;
                 }
-                throw createErr;
+                throw err;
             }
-            if (objType === 'FUNC' && objMetadataProps.processingType !== undefined) {
-                await persistFunctionModuleProcessingMetadata(client, objUrl, objName, objMetadataProps.processingType, objMetadataProps.updateTaskKind, objTransport);
+            entry.creation = 'confirmed';
+            phase = 'write';
+            if (entry.write !== 'not_required')
+                entry.write = 'unknown';
+            if (plan.type === 'FUNC' && plan.metadata.processingType !== undefined) {
+                await persistFunctionModuleProcessingMetadata(client, plan.objectUrl, plan.name, plan.metadata.processingType, plan.metadata.updateTaskKind, plan.transport);
             }
-            // Step 1b: DTEL POST ignores labels — follow up with PUT on main session
-            if (objType === 'DTEL' && dtelNeedsPostCreateUpdate(objMetadataProps)) {
+            if (plan.type === 'DTEL') {
                 await client.http.withStatefulSession(async (session) => {
-                    const lock = await lockObject(session, client.safety, objUrl, 'MODIFY', getCachedFeatures()?.abapRelease);
-                    const lockTransport = objTransport ?? (lock.corrNr || undefined);
+                    const lock = await lockObject(session, client.safety, plan.objectUrl, 'MODIFY', getCachedFeatures()?.abapRelease);
                     try {
-                        await updateObject(session, client.safety, objUrl, body, lock.lockHandle, contentType, lockTransport);
+                        await updateObject(session, client.safety, plan.objectUrl, plan.body, lock.lockHandle, plan.contentType, plan.transport ?? (lock.corrNr || undefined));
                     }
                     finally {
-                        await unlockObject(session, objUrl, lock.lockHandle);
+                        await unlockObject(session, plan.objectUrl, lock.lockHandle);
                     }
                 });
             }
-            // TTYP POST creates SAP's default table-type shell; PUT the real row type before activation.
-            if (objType === 'TTYP') {
-                await putTtypMetadataAfterCreate(client, objUrl, objName, body, contentType, objTransport);
-            }
-            // Step 2: Write source if provided
-            if (!metadataObject && objSource) {
-                const srcUrl = objType === 'FUNC' ? `${objUrl}/source/main` : sourceUrlForType(objType, objName);
-                await safeUpdateSource(client.http, client.safety, objUrl, srcUrl, objSource, objTransport, getCachedFeatures()?.abapRelease);
+            if (plan.type === 'TTYP')
+                await putTtypMetadataAfterCreate(client, plan.objectUrl, plan.name, plan.body, plan.contentType, plan.transport);
+            if (!plan.metadataObject && plan.source) {
+                await safeUpdateSource(client.http, client.safety, plan.objectUrl, plan.sourceUrl, plan.source, plan.transport, getCachedFeatures()?.abapRelease);
             }
-            // objUrl is already subtype-aware (including parent-group routing for FUNC),
-            // so source and activation share one canonical address.
-            const activationUrl = objUrl;
+            if (entry.write !== 'not_required')
+                entry.write = 'confirmed';
             if (activateAtEnd) {
-                // Step 3 deferred: track this object for the terminal activateBatch call.
-                // Cache invalidation also moves to AFTER the terminal activate succeeds —
-                // invalidating now would let the next read see a draft we couldn't activate.
-                writtenObjects.push({ type: objType, name: objName, url: activationUrl });
-                results.push({ type: objType, name: objName, packageName: objPackage, status: 'success' });
+                writtenPlans.push(plan);
             }
             else {
-                // Step 3: Activate the object (inline, default behavior).
-                const activationResult = await activate(client.http, client.safety, activationUrl);
-                if (!activationResult.success) {
-                    results.push({
-                        type: objType,
-                        name: objName,
-                        packageName: objPackage,
-                        status: 'failed',
-                        error: `activation failed: ${activationResult.messages.join('; ')}`,
-                    });
+                phase = 'activate';
+                entry.activation = 'unknown';
+                const outcome = await activate(client.http, client.safety, plan.objectUrl);
+                if (!outcome.success) {
+                    entry.activation = 'failed';
+                    failBatchEntry(entry, phase, `activation failed: ${batchFailureMessage(outcome.messages.join('; '), config.minimalErrors)}`);
                     break;
                 }
-                invalidateWrittenObject(objType, objName);
-                results.push({ type: objType, name: objName, packageName: objPackage, status: 'success' });
+                entry.activation = 'confirmed';
             }
+            entry.status = 'success';
         }
         catch (err) {
-            results.push({
-                type: objType,
-                name: objName,
-                packageName: objPackage,
-                status: 'failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
+            failBatchEntry(entry, phase, batchFailureMessage(err, config.minimalErrors));
             break;
         }
+        finally {
+            if (entry.creation !== 'not_attempted')
+                invalidateWrittenObject(plan.type, plan.name);
+        }
     }
-    // Add 'skipped' entries for objects that were never attempted due to early break
-    for (let i = results.length; i < objects.length; i++) {
-        const skippedPlan = batchPlan[i];
-        const skipped = skippedPlan?.obj ?? objects[i];
-        results.push({
-            type: skippedPlan?.type ?? normalizeObjectType(String(skipped?.type ?? '')),
-            name: skippedPlan?.name ?? String(skipped?.name ?? ''),
-            packageName: skippedPlan?.packageName ?? normalizePackageOverride(skipped?.package, defaultPackage),
-            status: 'failed',
-            error: 'skipped — stopped after previous failure',
-        });
-    }
-    // ── Terminal activateBatch (activateAtEnd=true) ─────────────────────
-    // After every write-phase succeeded (or broke off early), issue ONE batch
-    // activate over the already-written subset. This is the killer feature
-    // for composition-linked DDLS and RAP behavior stacks — SAP's activator
-    // sees the whole graph in a single POST and resolves cross-references
-    // internally, so parent → child siblings activate cleanly.
-    let terminalActivationFailure;
-    if (activateAtEnd && writtenObjects.length > 0) {
-        const activationOutcome = await activateBatch(client.http, client.safety, writtenObjects);
-        if (activationOutcome.success) {
-            // Defensive: per-object status was already 'success' from the write phase.
-            // Cache invalidation moves here so a failed terminal activate doesn't strand
-            // a stale 'active' cache entry. Invalidate inactive-lists once for the user.
-            for (const o of writtenObjects) {
-                cachingLayer?.invalidate(o.type, o.name, 'all');
+    if (activateAtEnd && writtenPlans.length > 0) {
+        for (const plan of writtenPlans)
+            plan.result.activation = 'unknown';
+        try {
+            const outcome = await activateBatch(client.http, client.safety, writtenPlans.map((plan) => ({ type: plan.type, name: plan.name, url: plan.objectUrl })));
+            if (!outcome.success) {
+                activationMessages.push(`${writtenPlans.length}/${writtenPlans.length} written, batch activation failed.`);
+                const unassigned = outcome.details.filter((detail) => !writtenPlans.some((plan) => activationDetailMatchesObject(detail.uri, plan.objectUrl)));
+                // Flat messages duplicate structured details; retain only otherwise-unrepresented messages.
+                const messages = [
+                    ...unassigned.map((detail) => detail.text),
+                    ...outcome.messages.filter((message) => !outcome.details.some((detail) => detail.text === message)),
+                ];
+                if (messages.length)
+                    activationMessages.push(batchFailureMessage([...new Set(messages)].join('; '), config.minimalErrors));
             }
-            invalidateInactiveList(cachingLayer, client, cacheSecurity);
-        }
-        else {
-            // Flip every written-but-not-yet-activated entry to 'failed', preserving the
-            // "create + source-write succeeded" context. Reuse the existing per-object
-            // diagnostic mapper so callers see the activation messages keyed by object name.
-            const batchStatuses = buildBatchActivationStatuses(writtenObjects, activationOutcome);
-            const statusDetails = formatBatchActivationStatuses(batchStatuses);
-            terminalActivationFailure = statusDetails;
-            const statusByName = new Map(batchStatuses.map((s) => [`${s.type}\x00${s.name}`, s]));
-            for (const result of results) {
-                if (result.status !== 'success')
+            for (const plan of writtenPlans) {
+                if (outcome.success) {
+                    plan.result.activation = 'confirmed';
                     continue;
-                const key = `${result.type}\x00${result.name}`;
-                const matched = statusByName.get(key);
-                if (!matched)
-                    continue;
-                // Some entries may still report status 'active' if the activator returned
-                // success: false but had no per-object error details — keep them as 'success'.
-                if (matched.status === 'active')
-                    continue;
-                result.status = 'failed';
-                const detail = matched.messages.length > 0 ? ` — ${matched.messages.join('; ')}` : '';
-                // Preserve the "create + source-write succeeded" context so the user sees that
-                // the failure was specifically the activation step, not the write step.
-                result.error = `${writtenObjects.length}/${writtenObjects.length} written, batch activation failed${detail}`;
+                }
+                const errors = outcome.details.filter((detail) => detail.severity === 'error' && activationDetailMatchesObject(detail.uri, plan.objectUrl));
+                plan.result.activation = errors.length ? 'failed' : 'unknown';
+                const message = errors.length
+                    ? batchFailureMessage(errors.map((detail) => detail.text).join('; '), config.minimalErrors)
+                    : 'Activation remains unknown: batch activation failed without an object-specific error.';
+                failBatchEntry(plan.result, 'activate', message);
             }
         }
+        catch (err) {
+            for (const plan of writtenPlans)
+                failBatchEntry(plan.result, 'activate', batchFailureMessage(err, config.minimalErrors));
+        }
+        finally {
+            for (const plan of writtenPlans)
+                invalidateWrittenObject(plan.type, plan.name);
+        }
     }
-    // ────────────────────────────────────────────────────────────────────
-    const summary = results
-        .map((r) => r.status === 'success'
-        ? `${r.name} (${r.type}) ✓ [${r.packageName}]`
-        : `${r.name} (${r.type}) ✗ [${r.packageName}] — ${r.error}`)
-        .join(', ');
-    const successCount = results.filter((r) => r.status === 'success').length;
-    const hasFailure = results.some((r) => r.status === 'failed');
-    const warningSuffix = batchWarnings.length > 0 ? `\n\nRAP preflight warnings:\n- ${batchWarnings.join('\n- ')}` : '';
-    const activateAtEndSuffix = terminalActivationFailure !== undefined ? `\n\nBatch activation diagnostics:${terminalActivationFailure}` : '';
-    const packageNames = [...new Set(batchPlan.map((item) => item.packageName))];
-    const packageSummary = packageNames.length === 1
-        ? `in package ${packageNames[0]}`
-        : packageNames.length <= 3
-            ? `across packages [${packageNames.join(', ')}]`
-            : `across ${packageNames.length} packages`;
-    const activateAtEndPrefix = activateAtEnd ? '; activated as a single batch' : '';
-    if (hasFailure) {
-        const cleanupHint = successCount > 0
-            ? ` Note: ${successCount} already-created object(s) remain on the SAP system and may need manual cleanup.`
-            : '';
-        return errorResult(`Batch created ${successCount}/${objects.length} objects ${packageSummary}${activateAtEndPrefix}: ${summary}${cleanupHint}${warningSuffix}${activateAtEndSuffix}`);
-    }
-    return textResult(`Batch created ${successCount} objects ${packageSummary}${activateAtEndPrefix}: ${summary}${warningSuffix}${activateAtEndSuffix}`);
+    return report();
 }
 //# sourceMappingURL=create.js.map