@suss/packs 0.33.0 → 0.34.0

package/dist/prisma.js

@@ -1,10 +1,11 @@
 // ../framework/prisma/dist/index.js
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import {
   Node as N
 } from "ts-morph";
 import { z } from "zod";
+import { receiverTypesOf, writtenNodeOf } from "@suss/adapter-typescript";
 import { storageBinding } from "@suss/behavioral-ir";
 import { scopeOption, storageSystemOption } from "@suss/extractor";
 import {
@@ -13,6 +14,191 @@ import {
   declaredBy,
   sqlStatements
 } from "@suss/recognize";
+import fs from "fs";
+import path from "path";
+import { getSchema } from "@mrleebo/prisma-ast";
+import { ts } from "ts-morph";
+var CONFIG_FILES = [
+  "prisma.config.ts",
+  "prisma.config.mts",
+  "prisma.config.cts",
+  "prisma.config.js",
+  "prisma.config.mjs",
+  "prisma.config.cjs",
+  path.join(".config", "prisma.ts")
+];
+var DEFAULT_SCHEMAS = [path.join("prisma", "schema.prisma"), "schema.prisma"];
+var readProjects = /* @__PURE__ */ new Map();
+function generatedClientDirs(fromDir) {
+  const root = projectRootOf(fromDir);
+  if (root === null) {
+    return [];
+  }
+  const known = readProjects.get(root);
+  if (known !== void 0 && unchanged(known.readFrom)) {
+    return known.dirs;
+  }
+  const schemaFiles = schemaFilesOf(root);
+  const readFrom = /* @__PURE__ */ new Map();
+  for (const file of [...projectFilesOf(root), ...schemaFiles]) {
+    readFrom.set(file, changedAt(file));
+  }
+  const dirs = schemaFiles.flatMap(outputDirsIn);
+  readProjects.set(root, { dirs, readFrom });
+  return dirs;
+}
+function isInGeneratedClient(filePath) {
+  return generatedClientDirs(path.dirname(filePath)).some(
+    (dir) => filePath.startsWith(`${dir}${path.sep}`)
+  );
+}
+function projectFilesOf(root) {
+  return [
+    path.join(root, "package.json"),
+    ...CONFIG_FILES.map((name) => path.join(root, name)),
+    ...DEFAULT_SCHEMAS.map((name) => path.join(root, name))
+  ];
+}
+function changedAt(file) {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+function unchanged(readFrom) {
+  for (const [file, at] of readFrom) {
+    if (changedAt(file) !== at) {
+      return false;
+    }
+  }
+  return true;
+}
+var rootsByDir = /* @__PURE__ */ new Map();
+function projectRootOf(fromDir) {
+  const known = rootsByDir.get(fromDir);
+  if (known !== void 0) {
+    return known;
+  }
+  const root = findProjectRoot(fromDir);
+  rootsByDir.set(fromDir, root);
+  return root;
+}
+function findProjectRoot(fromDir) {
+  let dir = path.resolve(fromDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, "package.json")) || configFileIn(dir) !== null) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function configFileIn(dir) {
+  for (const name of CONFIG_FILES) {
+    const candidate = path.join(dir, name);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function schemaFilesOf(root) {
+  const stated = [configuredSchema(root), packageJsonSchema(root)];
+  for (const schema of [
+    ...stated.filter((one) => one !== null),
+    ...DEFAULT_SCHEMAS.map((name) => path.join(root, name))
+  ]) {
+    const files = prismaFilesAt(schema);
+    if (files.length > 0) {
+      return files;
+    }
+  }
+  return [];
+}
+function prismaFilesAt(schemaPath) {
+  let stat;
+  try {
+    stat = fs.statSync(schemaPath);
+  } catch {
+    return [];
+  }
+  if (stat.isFile()) {
+    return [schemaPath];
+  }
+  if (!stat.isDirectory()) {
+    return [];
+  }
+  return fs.readdirSync(schemaPath, { recursive: true, encoding: "utf8" }).filter((name) => name.endsWith(".prisma")).map((name) => path.join(schemaPath, name)).sort();
+}
+function configuredSchema(root) {
+  const config = configFileIn(root);
+  if (config === null) {
+    return null;
+  }
+  const source = ts.createSourceFile(
+    config,
+    fs.readFileSync(config, "utf8"),
+    ts.ScriptTarget.Latest
+  );
+  let found = null;
+  const visit = (node) => {
+    if (found !== null) {
+      return;
+    }
+    if (ts.isPropertyAssignment(node) && node.name.getText(source) === "schema" && ts.isStringLiteralLike(node.initializer)) {
+      found = node.initializer.text;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return found === null ? null : path.resolve(root, found);
+}
+function packageJsonSchema(root) {
+  const file = path.join(root, "package.json");
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  try {
+    const manifest = JSON.parse(fs.readFileSync(file, "utf8"));
+    const schema = manifest.prisma?.schema;
+    return typeof schema === "string" ? path.resolve(root, schema) : null;
+  } catch {
+    return null;
+  }
+}
+function outputDirsIn(schemaFile) {
+  let list;
+  try {
+    list = getSchema(fs.readFileSync(schemaFile, "utf8")).list;
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const block of list) {
+    const output = generatorOutput(block);
+    if (output !== null) {
+      dirs.push(path.resolve(path.dirname(schemaFile), output));
+    }
+  }
+  return dirs;
+}
+function generatorOutput(block) {
+  const generator = block;
+  if (generator.type !== "generator") {
+    return null;
+  }
+  for (const assignment of generator.assignments ?? []) {
+    if (assignment.type === "assignment" && assignment.key === "output" && typeof assignment.value === "string") {
+      return assignment.value.replace(/^"|"$/g, "");
+    }
+  }
+  return null;
+}
 var PRISMA_READ_METHODS = /* @__PURE__ */ new Set([
   "findUnique",
   "findFirst",
@@ -33,15 +219,14 @@ var PRISMA_WRITE_METHODS = /* @__PURE__ */ new Set([
 ]);
 var optionsSchema = z.object({
   /**
-   * Storage system the recognized calls target. Must match the
-   * `storageSystem` on schema-reader provider summaries; otherwise
-   * pairing keys won't match. Defaults to `"postgresql"` since that's
-   * the dominant Prisma deployment.
+   * The storage system the calls target, `"postgresql"` when unset. It
+   * has to match the `storageSystem` on the schema reader's summaries,
+   * or the calls do not pair.
    */
   storageSystem: storageSystemOption.optional(),
   /**
-   * Scope label that must match the schema reader's scope. Defaults
-   * to `"default"` to align with `prismaSchemaToSummaries`'s default.
+   * Has to match the schema reader's scope. It is `"default"` when
+   * unset, the same default `prismaSchemaToSummaries` uses.
    */
   scope: scopeOption.optional()
 }).strict();
@@ -68,7 +253,7 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
     return null;
   }
   const receiverExpr = delegateExpr.getExpression();
-  if (!isPrismaClientReceiver(receiverExpr)) {
+  if (!isPrismaClientReceiver(receiverExpr, recognizerCtx.resolution)) {
     return null;
   }
   const delegateName = delegateExpr.getName();
@@ -88,19 +273,24 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
     container: tableName
   });
   const callee = callNode.getExpression().getText();
+  const access = {
+    type: "interaction",
+    binding,
+    callee,
+    interaction: {
+      class: "storage-access",
+      kind,
+      fields,
+      ...selector !== null ? { selector } : {},
+      operation: method
+    }
+  };
+  statePayloadSlots(recognizerCtx.ops, access, {
+    fields: kind === "write" ? fields : [],
+    selector: selector ?? []
+  });
   return [
-    {
-      type: "interaction",
-      binding,
-      callee,
-      interaction: {
-        class: "storage-access",
-        kind,
-        fields,
-        ...selector !== null ? { selector } : {},
-        operation: method
-      }
-    },
+    access,
     ...nestedReads(optionsArg).map(
       (nested) => ({
         type: "interaction",
@@ -126,15 +316,34 @@ function recognizePrismaCall(call, ctx, storageSystem, scope) {
           fields: nested.fields,
           relationPath: nested.relationPath,
           ...nested.relationKey === true ? { relationKey: true } : {},
-          // What reaches the other model is the nested operation, so
-          // that is what the effect records. The outer method belongs
-          // to the model in the binding.
+          // The outer method acts on the model in the binding. The model
+          // across the relation gets the nested operation.
           operation: nested.operation
         }
       })
     )
   ];
 }
+function statePayloadSlots(ops, effect, columns) {
+  const options = ops?.statesSlots === void 0 ? null : ops.valueAt(0);
+  if (ops === void 0 || options === null) {
+    return;
+  }
+  const slots = [
+    ...slotsUnder(options, ["where"], "selector", columns.selector),
+    ...slotsUnder(options, WRITE_PAYLOAD_KEYS, "field", columns.fields)
+  ];
+  if (slots.length > 0) {
+    ops.statesSlots?.(effect, slots);
+  }
+}
+function slotsUnder(options, keys, slot, columns) {
+  return keys.flatMap(
+    (key) => (options.property(key)?.entries("nothing") ?? []).flatMap(
+      (entry) => entry.key !== null && columns.includes(entry.key) ? [{ slot, name: entry.key, value: entry.value }] : []
+    )
+  );
+}
 function nestedReads(optionsArg) {
   if (optionsArg === null) {
     return [];
@@ -143,7 +352,7 @@ function nestedReads(optionsArg) {
   collectRelations(optionsArg, [], found);
   return found;
 }
-function collectRelations(shape, path2, found) {
+function collectRelations(shape, path3, found) {
   const select = readObjectArg(shape.fields.select);
   if (select !== null) {
     for (const [name, value] of Object.entries(select.fields)) {
@@ -151,7 +360,7 @@ function collectRelations(shape, path2, found) {
       if (nested === null) {
         continue;
       }
-      recordRelation(name, nested, path2, found);
+      recordRelation(name, nested, path3, found);
     }
   }
   const include = readObjectArg(shape.fields.include);
@@ -161,14 +370,14 @@ function collectRelations(shape, path2, found) {
   for (const [name, value] of Object.entries(include.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
-      found.push({ relationPath: [...path2, name], fields: ["*"] });
+      found.push({ relationPath: [...path3, name], fields: ["*"] });
       continue;
     }
-    recordRelation(name, nested, path2, found);
+    recordRelation(name, nested, path3, found);
   }
 }
-function recordRelation(name, nested, path2, found) {
-  const relationPath = [...path2, name];
+function recordRelation(name, nested, path3, found) {
+  const relationPath = [...path3, name];
   found.push({ relationPath, fields: extractFields(nested, "read") });
   collectRelations(nested, relationPath, found);
 }
@@ -222,13 +431,13 @@ function nestedWrites(optionsArg) {
   }
   return found;
 }
-function collectNestedWrites(row, path2, found) {
+function collectNestedWrites(row, path3, found) {
   for (const [field, value] of Object.entries(row.fields)) {
     const nested = readObjectArg(value);
     if (nested === null) {
       continue;
     }
-    const relationPath = [...path2, field];
+    const relationPath = [...path3, field];
     for (const [operation, payload] of Object.entries(nested.fields)) {
       const does = NESTED_OPERATIONS.get(operation);
       if (does === void 0) {
@@ -279,29 +488,51 @@ function fieldsOfRows(read) {
   }
   return out.size === 0 ? ["*"] : [...out];
 }
-function isPrismaClientReceiver(node) {
-  return extendsPrismaClient(node.getType(), /* @__PURE__ */ new Set());
+function isPrismaClientReceiver(node, resolution) {
+  if (receiverTypesOf(node).some(
+    (type) => declaredByPrisma(type) || extendsImportedClient(type, resolution)
+  )) {
+    return true;
+  }
+  return node.getType().isAny() && madeFromImportedClient(node, resolution);
 }
-function extendsPrismaClient(type, seen) {
-  if (seen.has(type)) {
+function madeFromImportedClient(node, resolution) {
+  if (resolution === void 0) {
     return false;
   }
-  seen.add(type);
-  const declarations = type.getSymbol()?.getDeclarations() ?? [];
-  if (declarations.some(
-    (declaration) => isPrismaClientPath(declaration.getSourceFile().getFilePath())
-  )) {
+  if (importedAsClient(node, resolution)) {
     return true;
   }
-  return type.getBaseTypes().some((base) => extendsPrismaClient(base, seen));
+  const written = writtenNodeOf(node, resolution);
+  return written !== null && written !== node && importedAsClient(written, resolution);
+}
+function importedAsClient(value, resolution) {
+  return resolution.importOriginsOf(value, clientModulesFor(value)).some((origin) => origin.path.join(".") === CLIENT_CLASS);
+}
+function clientModulesFor(value) {
+  return [
+    CLIENT_MODULE,
+    ...generatedClientDirs(path2.dirname(value.getSourceFile().getFilePath()))
+  ];
+}
+function declaredByPrisma(type) {
+  return type.declaredIn.some((filePath) => isPrismaClientPath(filePath));
+}
+var CLIENT_MODULE = "@prisma/client";
+var CLIENT_CLASS = "PrismaClient";
+function extendsImportedClient(type, resolution) {
+  if (resolution === void 0) {
+    return false;
+  }
+  return type.extendsWritten.some((base) => importedAsClient(base, resolution));
 }
 var GENERATED_CLIENT_MARKER = "schema.prisma";
 function isPrismaClientPath(filePath) {
   if (filePath.includes("/@prisma/client/") || filePath.includes("/.prisma/client/")) {
     return true;
   }
-  const beside = path.join(path.dirname(filePath), GENERATED_CLIENT_MARKER);
-  return fs.existsSync(beside);
+  const beside = path2.join(path2.dirname(filePath), GENERATED_CLIENT_MARKER);
+  return fs2.existsSync(beside) || isInGeneratedClient(filePath);
 }
 function capitalizeFirst(name) {
   if (name.length === 0) {
@@ -406,12 +637,14 @@ function prismaFramework(options = {}) {
     discovery: [],
     terminals: [],
     inputMapping: { type: "positionalParams", params: [] },
-    // Skip files that don't import from @prisma/client: the
-    // recognizer's type-resolution check would reject them anyway.
+    // The type check would reject every call in a file that does not
+    // import `@prisma/client`, so those files are skipped.
     requiresImport: ["@prisma/client"],
     // A generator with its own `output` puts the client in the project,
-    // where the only way to reach it is a relative path.
+    // where the only way to reach it is a relative path. Prisma 7's
+    // `prisma-client` generator writes no schema beside it.
     generatedModuleMarkers: [GENERATED_CLIENT_MARKER],
+    generatedModuleDirs: generatedClientDirs,
     invocationRecognizers: [makeRecognizer(options)],
     // A tagged template is not an invocation, so the raw chain runs on
     // the access walk, which visits calls as well.
@@ -423,7 +656,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-prisma",
   dependencies: [{ ecosystem: "npm", name: "@prisma/client" }],
-  reads: "Prisma client calls, emits storage-access interactions per read / write."
+  reads: "Prisma client calls. Each read and each write becomes a storage-access interaction."
 };
 var index_default = prismaFramework;
 export {

package/dist/pytest.d.ts

@@ -0,0 +1 @@
+export { declares, default, optionsSchema } from '@suss/framework-pytest';

package/dist/pytest.js

@@ -0,0 +1,81 @@
+// ../framework/pytest/dist/index.js
+import path from "path";
+import { z } from "zod";
+var optionsSchema = z.object({
+  /**
+   * The test files to read, matched on whole path segments from the
+   * end. `suss extract --intent` fills it in from the tests the PRDs
+   * list, so a run reads those files and no others. Left out, every
+   * file pytest would collect is read.
+   */
+  files: z.array(z.string().min(1)).optional()
+}).strict();
+var SHARED_FIXTURE_FILE = "conftest.py";
+function pytestFramework(options = {}) {
+  return {
+    name: "pytest",
+    protocol: "in-process",
+    discovery: [],
+    // A test's fixtures can come from a conftest.py in any directory
+    // above it, so an edit to one has to re-read the tests below it.
+    discoveryInputs: (files) => files.filter((file) => path.basename(file) === SHARED_FIXTURE_FILE),
+    tests: [
+      {
+        filePatterns: ["test_*.py", "*_test.py"],
+        functionPrefix: "test",
+        classPrefix: "Test",
+        caseBaseClasses: [
+          "unittest.TestCase",
+          "unittest.IsolatedAsyncioTestCase"
+        ],
+        setUp: {
+          module: ["setup_module"],
+          function: ["setup_function"],
+          testClass: ["setup_class", "setup_method"],
+          caseClass: ["setUpClass", "setUp", "asyncSetUp"]
+        },
+        usesFixtureMarkers: ["pytest.mark.usefixtures"],
+        fixtureDecorators: ["pytest.fixture"],
+        fixtureNameKeyword: "name",
+        autouseKeyword: "autouse",
+        sharedFixtureFiles: [SHARED_FIXTURE_FILE],
+        skipDecorators: [
+          "pytest.mark.skip",
+          "pytest.mark.skipif",
+          "pytest.mark.xfail",
+          "unittest.skip",
+          "unittest.skipIf",
+          "unittest.skipUnless",
+          "unittest.expectedFailure"
+        ],
+        markerVariable: "pytestmark",
+        reservedParameters: ["self", "cls", "request"],
+        mocks: {
+          patchers: [
+            "unittest.mock.patch",
+            "unittest.mock.patch.object",
+            "mock.patch",
+            "mock.patch.object"
+          ],
+          fixturePatchers: [
+            { fixture: "mocker", methods: ["patch", "patch.object"] },
+            { fixture: "monkeypatch", methods: ["setattr"] }
+          ]
+        },
+        ...options.files !== void 0 ? { files: options.files } : {}
+      }
+    ]
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-pytest",
+  dependencies: [],
+  reads: "pytest tests (Python), named by their node ids, so a PRD scenario can say which test covers it."
+};
+var index_default = pytestFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};

package/dist/rails.js

@@ -304,20 +304,20 @@ var RouteAccumulator = class {
   drawDirectory;
   byKey = /* @__PURE__ */ new Map();
   unread = /* @__PURE__ */ new Map();
-  /** Per file, each gem block call whose body was walked as though the call changed nothing about it. */
+  /** Per file, the gem block calls whose bodies were walked as if the call were not there. */
   walkedBlocks = /* @__PURE__ */ new Map();
   missingDrawn = [];
   /** The block each `concern :name do ... end` declared, for `concerns` to replay. */
   concerns = /* @__PURE__ */ new Map();
   /** Files `draw(:name)` has already read, so a file drawing itself stops. */
   drawn = /* @__PURE__ */ new Set();
-  /** Every engine a `mount` may refer to, by the class name it is written with. */
+  /** Every engine a `mount` may refer to, keyed by class name. */
   engines = /* @__PURE__ */ new Map();
   /** Engines whose route set is being walked, so an engine that mounts itself stops. */
   mounting = /* @__PURE__ */ new Set();
-  /** The file whose statements are being walked, as a gap writes it. */
+  /** The file whose statements are being walked, as a gap message prints it. */
   file = "";
-  /** The first route written for an action wins, the way Rails matches the first route it declared. */
+  /** The first route written for an action wins, because Rails matches routes in the order they are declared. */
   add(controllerKey, action, route) {
     const key = `${controllerKey}#${action}`;
     if (!this.byKey.has(key)) {
@@ -880,37 +880,46 @@ var RACK_STATUS_CODE_NAMES = {
   network_authentication_required: 511
 };
 var optionsSchema = z.object({
-  /** The app directory a bare controller name is looked up under. Every Rails app scaffolds this at `app`. */
+  /**
+   * The directory a bare controller name is looked up under, `app` in a
+   * scaffolded Rails app.
+   */
   root: z.string().optional(),
   /**
-   * The directory a relative `root` or `routesFile` is read against: the
-   * config file's own directory, or the directory the run reads when the
-   * options came without one. The CLI supplies this; it is not written in
-   * the file itself.
+   * The CLI fills this in with the config file's directory, or with the
+   * directory the run reads when there is no file. A relative `root` or
+   * `routesFile` resolves against it. A config file does not set it.
    */
   configDirectory: z.string().optional(),
-  /** Base classes beyond `ApplicationController` that also mark a class as a controller. */
+  /**
+   * Base classes beyond `ApplicationController` whose subclasses are
+   * controllers. A config file may not set this; a dependency stub
+   * fills it.
+   */
   baseClassNames: z.array(z.string()).optional(),
   /**
-   * Methods beyond Rails' own that every controller in this project
-   * gets without defining them, from a gem such as Devise. They are
-   * left off an action's effects the same way Rails' own are.
+   * Controller methods a gem such as Devise adds, beyond the ones Rails
+   * defines. They are left off an action's effects the same way Rails'
+   * own are.
    */
   inheritedMethodNames: z.array(z.string()).optional(),
-  /** Where this project's routes live, relative to `configDirectory` when there is one. Every Rails app scaffolds this at `config/routes.rb`. */
+  /**
+   * The routes file, `config/routes.rb` in a scaffolded app. A relative
+   * path resolves against `configDirectory` when there is one.
+   */
   routesFile: z.string().optional(),
   /**
-   * Directories the project keeps its own engines under, each one the
-   * root a `Rails::Engine` subclass has its `lib/` and `config/routes.rb`
-   * in. A `*` in a segment matches any one directory, so `plugins/*`
-   * covers every plugin. Relative to `configDirectory`.
+   * Directories that each contain an engine, with its `Rails::Engine`
+   * class under `lib/` and its routes in `config/routes.rb`. A `*` in a
+   * segment matches any one directory, so `plugins/*` covers every
+   * plugin. Relative paths resolve against `configDirectory`.
    */
   engineRoots: z.array(z.string()).optional(),
   /**
-   * Files beyond the routes file that add routes through a
-   * `Rails.application.routes.draw`, `.append` or `.prepend` block,
-   * a plugin's `plugin.rb` being the usual one. Same `*` rule as
-   * `engineRoots`. Relative to `configDirectory`.
+   * Other files that add routes through a `Rails.application.routes.draw`,
+   * `.append` or `.prepend` block, most often a plugin's `plugin.rb`.
+   * They take `*` the same way `engineRoots` does, and relative paths
+   * resolve against `configDirectory`.
    */
   routesFiles: z.array(z.string()).optional()
 }).strict();
@@ -1063,9 +1072,18 @@ function railsFramework(options = {}) {
     discovery: [pattern],
     bodyBlocks: BODY_BLOCKS,
     inflections,
-    // Every file routing or naming is read from decides an action's
-    // binding without being walked, so the cache key has to read them
-    // here. This runs before the grammar loads, so nothing parses Ruby.
+    // An action reads the request through these, and is handed nothing.
+    requestAccessors: ["params", "request"],
+    // Rails merges the path, the query string and the body into `params`,
+    // so an action's read of one cannot be told from the others and all
+    // of them are spelled `params`.
+    requestSpelling: {
+      headers: { path: ["request", "headers"], saysWhichField: true },
+      params: { path: ["params"], saysWhichField: true }
+    },
+    // These files change an action's binding without being walked, so the
+    // cache key has to list them. This runs before the grammar loads, so
+    // nothing here parses Ruby.
     discoveryInputs: () => [
       routesFile,
       ...drawableRoutesFiles(routesFile),
@@ -1096,7 +1114,7 @@ var declares = {
     { ecosystem: "rubygems", name: "rails" },
     { ecosystem: "rubygems", name: "railties" }
   ],
-  reads: "Rails controller actions (Ruby), bound to the method and path `config/routes.rb` gives each one; an action the routes file does not reach is discovered with no boundary.",
+  reads: "Rails controller actions (Ruby), bound to the method and path `config/routes.rb` gives each one. An action the routes file does not reach is still discovered, with no boundary.",
   configuration: {
     file: "suss.rails.json",
     example: {
@@ -1106,7 +1124,8 @@ var declares = {
       routesFiles: ["plugins/*/plugin.rb"]
     },
     required: false,
-    why: "the app directory a controller is defined under and the routes file suss reads each action's method and path from; rails new scaffolds both at these paths. engineRoots lists where the project keeps engines it mounts, and routesFiles any other file that adds routes, when it has either."
+    why: "the app directory a controller is defined under and the routes file suss reads each action's method and path from; rails new scaffolds both at these paths. engineRoots lists where the project keeps engines it mounts, and routesFiles any other file that adds routes, when it has either.",
+    defaults: { root: "app", routesFile: "config/routes.rb" }
   }
 };
 var index_default = railsFramework;

package/dist/react-query.js

@@ -134,7 +134,7 @@ var declares = {
   kind: "framework",
   package: "@suss/framework-react-query",
   dependencies: [{ ecosystem: "npm", name: "@tanstack/react-query" }],
-  reads: "TanStack Query hooks: ties a component to the query function its `useQuery` / `useMutation` call runs."
+  reads: "TanStack Query hooks. The pack links a component to the query function that its `useQuery` or `useMutation` call runs."
 };
 var index_default = reactQueryFramework;
 export {