pasika 0.10.14 → 0.10.15

package/dist/eslint/pasika/index.js

@@ -1093,6 +1093,7 @@ function parseModule(file) {
   const isTsx = file.endsWith(".tsx") || file.endsWith(".jsx");
   const sourceFile = ts2.createSourceFile(file, text, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TSX);
   const imports = [];
+  const reexports = [];
   const exports = [];
   const addImport = (specifierNode, names, node) => {
     if (!ts2.isStringLiteral(specifierNode)) return;
@@ -1118,6 +1119,13 @@ function parseModule(file) {
           }
         }
         addImport(statement.moduleSpecifier, names, statement);
+        if (ts2.isStringLiteral(statement.moduleSpecifier)) {
+          reexports.push({
+            specifier: statement.moduleSpecifier.text,
+            names,
+            line: lineOf(sourceFile, statement)
+          });
+        }
       }
       if (statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
         for (const element of statement.exportClause.elements) {
@@ -1160,7 +1168,7 @@ function parseModule(file) {
       });
     }
   }
-  return { file: path6.resolve(file), imports, exports };
+  return { file: path6.resolve(file), imports, reexports, exports };
 }
 
 // eslint/project/index.ts
@@ -1245,6 +1253,28 @@ function build(sourceRoot, files) {
       }
     }
   }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [file, module] of modules) {
+      for (const reexport of module.reexports) {
+        const target = resolveSpecifier(file, reexport.specifier, sourceRoot);
+        if (!target || !modules.has(target)) continue;
+        const names = reexport.names.length > 0 ? reexport.names : modules.get(target)?.exports.map((entry) => entry.name) ?? [];
+        for (const name of names) {
+          const sourceConsumers = symbolConsumers.get(symbolKey(file, name));
+          if (sourceConsumers === void 0) continue;
+          const targetConsumers = symbolConsumers.get(symbolKey(target, name)) ?? /* @__PURE__ */ new Set();
+          for (const consumer of sourceConsumers) {
+            if (targetConsumers.has(consumer)) continue;
+            targetConsumers.add(consumer);
+            changed = true;
+          }
+          symbolConsumers.set(symbolKey(target, name), targetConsumers);
+        }
+      }
+    }
+  }
   return { sourceRoot, modules, consumers, symbolConsumers };
 }
 var cache;
@@ -1763,6 +1793,7 @@ var supportFilePlacementRule = {
     if (supportFolder === void 0 || !SUPPORT_FOLDERS2.has(supportFolder)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
+    let placement = resolveSupportPlacement(supportFile, supportFolder, index);
     const groupedExportKind = EXPORT_KIND_BY_SUPPORT_FOLDER.get(supportFolder);
     if (groupedExportKind !== void 0) {
       const utilityExports = index.modules.get(supportFile)?.exports.filter((entry) => entry.kind === groupedExportKind) ?? [];
@@ -1789,8 +1820,9 @@ var supportFilePlacementRule = {
           }
         };
       }
+      const [firstPlacement] = placements;
+      if (firstPlacement !== void 0) placement = firstPlacement.placement;
     }
-    const placement = resolveSupportPlacement(supportFile, supportFolder, index);
     if (!placement || sameFolder2(currentFolder, placement.expectedFolder)) return {};
     if (isConfigModule(segmentsOf(supportFile, sourceRoot)) && CONFIG_OWNED_FOLDERS.has(supportFolder)) {
       if (placement.reason !== "config-module") return {};

package/dist/helpers/response-envelope.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+declare function responseEnvelope<TSchema extends z.ZodType>(dataSchema: TSchema): z.ZodType<{
+    success: true;
+    data: z.output<TSchema>;
+} | {
+    success: false;
+    data: null;
+    message: string;
+}, {
+    success: true;
+    data: z.input<TSchema>;
+} | {
+    success: false;
+    data: null;
+    message: string;
+}>;
+declare function responseEnvelope(dataSchema: z.ZodType): z.ZodType;
+
+export { responseEnvelope };

package/dist/helpers/response-envelope.js

@@ -0,0 +1,18 @@
+// helpers/response-envelope.ts
+import { z } from "zod";
+function responseEnvelope(dataSchema) {
+  return z.discriminatedUnion("success", [
+    z.object({
+      success: z.literal(true),
+      data: dataSchema
+    }),
+    z.object({
+      success: z.literal(false),
+      data: z.null(),
+      message: z.string()
+    })
+  ]);
+}
+export {
+  responseEnvelope
+};

package/dist/helpers/with-response.d.ts

@@ -4,7 +4,6 @@ import { z } from 'zod';
 /** Whatever a handler's own response needs to carry; a failure never inherits it. */
 type ResponseHeaders = Headers | Record<string, string>;
 type HandlerResult<TData> = {
-    message: string;
     data: TData;
     status?: number;
     headers?: ResponseHeaders;
@@ -15,7 +14,7 @@ type HandlerResult<TData> = {
 };
 /**
  * Turns a handler's result, or a failure thrown under it, into a response: the data
- * goes through the response schema, an `HttpError` becomes `{ data: null, message }`
+ * goes through the response schema, an `HttpError` becomes `{ success: false, data: null, message }`
  * at its own status and is never cached, and anything else stays an error.
  *
  * A handler whose own response is not JSON calls it with the handler alone and returns

package/dist/helpers/with-response.js

@@ -17,12 +17,12 @@ function withResponse(responseSchemaOrHandler, handler) {
         const { body, status: status2, headers: headers2 } = result;
         return new NextResponse(streamBody.parse(body), { status: status2, headers: headers2 });
       }
-      const { message, data, status, headers } = result;
-      return NextResponse.json({ data: schema.parse(data), message }, { status, headers });
+      const { data, status, headers } = result;
+      return NextResponse.json({ success: true, data: schema.parse(data) }, { status, headers });
     } catch (error) {
       if (error instanceof HttpError) {
         return NextResponse.json(
-          { data: null, message: error.message },
+          { success: false, data: null, message: error.message },
           { status: error.status, headers: { "Cache-Control": "no-store" } }
         );
       }

package/dist/helpers/zod-fetch.js

@@ -44,11 +44,7 @@ async function zodFetch(options) {
     throw new HttpError("The upstream answered without a body to decode.", BAD_GATEWAY);
   }
   const decoded = JSON.parse(body);
-  const responseEnvelopeSchema = z.object({
-    data: options.responseSchema,
-    message: z.string()
-  });
-  return responseEnvelopeSchema.parse(decoded).data;
+  return options.responseSchema.parse(decoded);
 }
 export {
   zodFetch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.14",
+  "version": "0.10.15",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",
@@ -21,6 +21,10 @@
       "types": "./dist/helpers/http-error.d.ts",
       "import": "./dist/helpers/http-error.js"
     },
+    "./response-envelope": {
+      "types": "./dist/helpers/response-envelope.d.ts",
+      "import": "./dist/helpers/response-envelope.js"
+    },
     "./zod-fetch": {
       "types": "./dist/helpers/zod-fetch.d.ts",
       "import": "./dist/helpers/zod-fetch.js"