deepline 0.2.55 → 0.2.57

package/dist/bundling-sources/shared_libs/plays/play-exports.ts

@@ -34,6 +34,16 @@ export type PlayFileExport = {
   name: string;
   /** Other export names that resolve to the same `definePlay` call. */
   aliases: string[];
+  /**
+   * The play's own name — `definePlay('<this>', …)` — when it is a literal.
+   *
+   * An export name is a module detail (`scalar`, `batch`); the play name is what
+   * the product, the registry and the customer call this thing. So it is a legal
+   * way to address the play, which is why an `@mermaid <name>` header may write
+   * either. Null when the first argument is not a string literal, which is only
+   * possible for a play the registry could not name either.
+   */
+  playName: string | null;
 };
 
 function getIdentifierName(node: unknown): string | null {
@@ -83,6 +93,16 @@ export function isDefinePlayCall(node: AstNode | null): boolean {
   return false;
 }
 
+/** The literal name a `definePlay('…', …)` call declares, when it is one. */
+function definePlayName(node: AstNode | null): string | null {
+  const expression = unwrapStaticExpression(node);
+  if (!expression || expression.type !== 'CallExpression') return null;
+  const first = astArray(expression.arguments)[0] ?? null;
+  return first?.type === 'Literal' && typeof first.value === 'string'
+    ? first.value
+    : null;
+}
+
 /**
  * The plays `sourceCode` exports, default first, then named exports in source
  * order. `null` means acorn could not parse the file — the caller abstains and
@@ -163,13 +183,26 @@ export function listPlayFileExports(
           .map(([exported]) => exported)
       : [];
     if (defaultLocalName) aliasedLocals.add(defaultLocalName);
-    exports.push({ name: PLAY_DEFAULT_EXPORT, aliases });
+    exports.push({
+      name: PLAY_DEFAULT_EXPORT,
+      aliases,
+      playName: definePlayName(
+        defaultLocalName
+          ? (declarations.get(defaultLocalName) ?? null)
+          : defaultExpression,
+      ),
+    });
   }
   for (const [exportedName, localName] of namedExports) {
     if (exportedName === PLAY_DEFAULT_EXPORT) continue;
     if (aliasedLocals.has(localName)) continue;
-    if (!isDefinePlayCall(declarations.get(localName) ?? null)) continue;
-    exports.push({ name: exportedName, aliases: [] });
+    const declaration = declarations.get(localName) ?? null;
+    if (!isDefinePlayCall(declaration)) continue;
+    exports.push({
+      name: exportedName,
+      aliases: [],
+      playName: definePlayName(declaration),
+    });
   }
 
   return exports;
@@ -180,6 +213,12 @@ export function listPlayFileExports(
  * canonical name. `scalar` in `export default scalar` resolves to `default`;
  * an unknown name resolves to `null` so the caller can fail loudly with the
  * available set rather than silently binding nothing.
+ *
+ * The play's own name resolves too, and is the better thing to write: a diagram
+ * headed `@mermaid scalar` names a module-local binding, while one headed
+ * `@mermaid name-and-domain-to-email-waterfall` names the play the reader came
+ * here for. Export names keep working because every diagram authored before this
+ * used one.
  */
 export function canonicalPlayExportName(
   exportName: string | null | undefined,
@@ -191,6 +230,12 @@ export function canonicalPlayExportName(
       return entry.name;
     }
   }
+  // Second pass, so an export literally named after another play's play name
+  // can never lose to it. Ambiguity between two plays' names is impossible:
+  // the registry rejects a duplicate play name before this ever runs.
+  for (const entry of exports) {
+    if (entry.playName === requested) return entry.name;
+  }
   return null;
 }
 
@@ -198,5 +243,9 @@ export function canonicalPlayExportName(
 export function playExportNamesForMessage(
   exports: readonly PlayFileExport[],
 ): string[] {
-  return exports.flatMap((entry) => [entry.name, ...entry.aliases]);
+  return exports.flatMap((entry) => [
+    ...(entry.playName ? [entry.playName] : []),
+    entry.name,
+    ...entry.aliases,
+  ]);
 }

package/dist/bundling-sources/shared_libs/security/safe-fetch.ts

@@ -19,6 +19,10 @@ function removeHeader(headers: Headers, name: string) {
   if (headers.has(name)) headers.delete(name);
 }
 
+function cancelResponseBodyBestEffort(response: Response): void {
+  void response.body?.cancel().catch(() => undefined);
+}
+
 function requestInitForRedirect(
   init: RequestInit,
   from: URL,
@@ -83,6 +87,7 @@ export async function safePublicFetch(
       return response;
     }
     if (redirectMode === 'error') {
+      cancelResponseBodyBestEffort(response);
       throw new Error(
         `Redirect blocked while fetching ${currentUrl.toString()}.`,
       );
@@ -96,11 +101,15 @@ export async function safePublicFetch(
       return response;
     }
     if (redirectCount === maxRedirects) {
+      cancelResponseBodyBestEffort(response);
       throw new Error(
         `Too many redirects while fetching ${currentUrl.toString()}.`,
       );
     }
 
+    // A redirect response can stream an unbounded body. The next request must
+    // not leave that body/socket flowing in the background.
+    cancelResponseBodyBestEffort(response);
     const nextUrl = resolveRedirectUrl(location, currentUrl);
     currentInit = requestInitForRedirect(
       currentInit,

package/dist/bundling-sources/shared_libs/security/safe-outbound-fetch.ts

@@ -14,6 +14,8 @@ import {
 type NodeSafeFetchOptions = {
   maxRedirects?: number;
   maxResponseBytes?: number;
+  /** Return after validated headers so the caller can enforce a body deadline. */
+  streamResponseBody?: boolean;
   truncateResponseBody?: boolean;
   sensitiveHeaders?: Iterable<string>;
   validateUrl?: (url: URL) => void;
@@ -219,62 +221,83 @@ function createRequest(
           );
           return;
         }
-
-        const chunks: Buffer[] = [];
-        let receivedBytes = 0;
-        let settled = false;
-        const resolveResponse = () => {
-          if (settled) return;
-          settled = true;
+        if (noBodyResponse) {
+          response.resume();
           resolve(
-            new Response(noBodyResponse ? null : Buffer.concat(chunks), {
+            new Response(null, {
               status,
               statusText: response.statusMessage,
               headers: response.headers as HeadersInit,
             }),
           );
-        };
-        response.on('data', (chunk) => {
-          if (settled) return;
-          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-          const previousReceivedBytes = receivedBytes;
-          receivedBytes += buffer.byteLength;
-          if (
-            maxResponseBytes !== undefined &&
-            receivedBytes > maxResponseBytes &&
-            !truncateResponseBody
-          ) {
-            response.destroy(
-              new Error(
-                `Response body exceeds ${maxResponseBytes} byte limit.`,
-              ),
-            );
-            return;
-          }
-          if (!noBodyResponse) {
-            if (maxResponseBytes !== undefined && truncateResponseBody) {
-              const remainingBytes = Math.max(
-                0,
-                maxResponseBytes - previousReceivedBytes,
-              );
-              if (remainingBytes > 0) {
-                chunks.push(buffer.subarray(0, remainingBytes));
+          return;
+        }
+
+        let receivedBytes = 0;
+        let bodySettled = false;
+        const body = new ReadableStream<Uint8Array>({
+          start(controller) {
+            response.on('data', (chunk) => {
+              if (bodySettled) return;
+              const buffer = Buffer.isBuffer(chunk)
+                ? chunk
+                : Buffer.from(chunk);
+              const previousReceivedBytes = receivedBytes;
+              receivedBytes += buffer.byteLength;
+              if (
+                maxResponseBytes !== undefined &&
+                receivedBytes > maxResponseBytes &&
+                !truncateResponseBody
+              ) {
+                bodySettled = true;
+                const error = new Error(
+                  `Response body exceeds ${maxResponseBytes} byte limit.`,
+                );
+                controller.error(error);
+                response.destroy(error);
+                return;
               }
-              if (receivedBytes >= maxResponseBytes) {
-                resolveResponse();
-                response.destroy();
+              if (maxResponseBytes !== undefined && truncateResponseBody) {
+                const remainingBytes = Math.max(
+                  0,
+                  maxResponseBytes - previousReceivedBytes,
+                );
+                if (remainingBytes > 0) {
+                  controller.enqueue(buffer.subarray(0, remainingBytes));
+                }
+                if (receivedBytes >= maxResponseBytes) {
+                  bodySettled = true;
+                  controller.close();
+                  response.destroy();
+                }
+                return;
               }
-            } else {
-              chunks.push(buffer);
-            }
-          }
+              controller.enqueue(buffer);
+            });
+            response.on('error', (error) => {
+              if (bodySettled) return;
+              bodySettled = true;
+              controller.error(error);
+            });
+            response.on('end', () => {
+              if (bodySettled) return;
+              bodySettled = true;
+              controller.close();
+            });
+          },
+          cancel(reason) {
+            if (bodySettled) return;
+            bodySettled = true;
+            response.destroy(reason instanceof Error ? reason : undefined);
+          },
         });
-        response.on('error', (error) => {
-          if (settled) return;
-          settled = true;
-          reject(error);
-        });
-        response.on('end', resolveResponse);
+        resolve(
+          new Response(body, {
+            status,
+            statusText: response.statusMessage,
+            headers: response.headers as HeadersInit,
+          }),
+        );
       },
     );
 
@@ -359,9 +382,21 @@ export async function safeOutboundFetch(
     });
 
     if (!isRedirectStatus(response.status)) {
-      return response;
+      if (options.streamResponseBody) return response;
+      const body = response.body ? await response.arrayBuffer() : null;
+      const buffered = new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+      Object.defineProperty(buffered, 'url', {
+        configurable: true,
+        value: response.url,
+      });
+      return buffered;
     }
     if (redirectMode === 'error') {
+      void response.body?.cancel().catch(() => undefined);
       throw new Error(
         `Redirect blocked while fetching ${currentUrl.toString()}.`,
       );
@@ -375,11 +410,13 @@ export async function safeOutboundFetch(
       return response;
     }
     if (redirectCount === maxRedirects) {
+      void response.body?.cancel().catch(() => undefined);
       throw new Error(
         `Too many redirects while fetching ${currentUrl.toString()}.`,
       );
     }
 
+    void response.body?.cancel().catch(() => undefined);
     const nextUrl = resolveRedirectUrl(location, currentUrl);
     currentInit = initForRedirect(
       currentInit,