@suss/packs 0.33.1 → 0.34.1

package/README.md

@@ -8,24 +8,23 @@ Every pack suss ships, as one package with a subpath per pack.
 npm install --save-dev @suss/packs
 ```
 
-A pack is reached by its own subpath, which is the name `suss extract -f`
-takes:
+Each pack has its own subpath, and the subpath is the name that
+`suss extract -f` takes:
 
 ```ts
 import mongoose from "@suss/packs/mongoose";
 import express from "@suss/packs/express";
 ```
 
-The CLI resolves `-f mongoose` to `@suss/packs/mongoose` on its own, so
-running `suss` needs no import.
+The CLI resolves `-f mongoose` to `@suss/packs/mongoose` itself, so you
+do not need an import to run `suss`.
 
 ## Why one package
 
-npm exchanges a publishing credential against a trusted publisher that
-each package configures for itself, by hand, on npmjs.com. One package
-means that happens once rather than once per pack, so adding a pack is a
-directory and a line in the exports map.
+npm issues a publishing credential through a trusted publisher, and each
+package has to configure its trusted publisher by hand on npmjs.com.
+With one package that setup happens once for every pack. Adding a pack
+takes a directory and a line in the exports map.
 
-The packs have no dependencies outside `@suss/*`, and all of them
-together come to about 1.2 MB, so there is nothing to save by splitting
-them up.
+The packs have no dependencies outside `@suss/*`, and together they come
+to about 1.2 MB, so splitting them up would save nothing.

package/dist/activerecord.d.ts

@@ -17,6 +17,8 @@ import '@suss/framework-bigquery';
 import '@suss/framework-cloudflare-workers';
 import '@suss/framework-drizzle';
 import '@suss/framework-express';
+import '@suss/framework-fabrication';
+import '@suss/framework-factory-bot';
 import '@suss/client-faraday';
 import '@suss/framework-fastapi';
 import '@suss/framework-fastify';
@@ -26,6 +28,7 @@ import '@suss/framework-gcs';
 import '@suss/framework-graphql-ruby';
 import '@suss/framework-hono';
 import '@suss/client-httpx';
+import '@suss/framework-minitest';
 import '@suss/framework-mongoose';
 import '@suss/framework-nestjs-graphql';
 import '@suss/framework-nestjs-microservices';
@@ -37,13 +40,17 @@ import '@suss/framework-package-exports';
 import '@suss/framework-pg-ruby';
 import '@suss/framework-pg';
 import '@suss/framework-prisma';
+import '@suss/framework-pytest';
 import '@suss/framework-rails';
 import '@suss/framework-react-query';
 import '@suss/framework-react-router';
 import '@suss/framework-react';
 import '@suss/framework-redis';
 import '@suss/client-requests';
+import '@suss/framework-rspec';
 import '@suss/framework-sqlalchemy';
 import '@suss/framework-sqlmodel';
 import '@suss/framework-ts-rest';
+import '@suss/framework-typeorm';
+import '@suss/framework-vitest';
 import '@suss/framework-zustand';

package/dist/activerecord.js

@@ -1,10 +1,38 @@
 // ../framework/activerecord/dist/index.js
 import { z } from "zod";
 import { storageSystemOption } from "@suss/extractor";
+import fs from "fs";
+import path from "path";
+var STORAGE_SYSTEM_OF_ADAPTER = {
+  postgresql: "postgresql",
+  mysql2: "mysql",
+  trilogy: "mysql",
+  sqlite3: "sqlite"
+};
+function storageSystemFromDatabaseYml(projectRoot) {
+  const file = path.join(projectRoot, "config", "database.yml");
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  const systems = /* @__PURE__ */ new Set();
+  for (const match of fs.readFileSync(file, "utf8").matchAll(/^\s*adapter:\s*(.*)$/gm)) {
+    const system = STORAGE_SYSTEM_OF_ADAPTER[adapterName(match[1] ?? "")];
+    if (system === void 0) {
+      return null;
+    }
+    systems.add(system);
+  }
+  const [only] = systems;
+  return systems.size === 1 && only !== void 0 ? { storageSystem: only } : null;
+}
+function adapterName(written) {
+  const value = written.replace(/\s+#.*$/, "").trim();
+  return /^(["'])(.*)\1$/.exec(value)?.[2] ?? value;
+}
 var optionsSchema = z.object({
   /**
-   * Which database is behind the connection. ActiveRecord talks to all of
-   * them and database.yml says which, so the project supplies this.
+   * The database behind the connection. ActiveRecord works with several,
+   * and database.yml picks one, so the project has to supply it.
    */
   storageSystem: storageSystemOption
 }).strict();
@@ -196,7 +224,26 @@ function activeRecordStorage(options) {
         plural: ["has_many", "has_and_belongs_to_many"],
         classNameKeyword: "class_name"
       },
-      storageSystem: options.storageSystem
+      scopes: ["scope"],
+      storageSystem: options.storageSystem,
+      raises: [
+        {
+          exception: "ActiveRecord::RecordNotFound",
+          methods: [
+            "find",
+            "find_by!",
+            "find_sole_by",
+            "sole",
+            "first!",
+            "last!",
+            "take!"
+          ]
+        },
+        {
+          exception: "ActiveRecord::RecordInvalid",
+          methods: ["save!", "create!", "update!", "find_or_create_by!"]
+        }
+      ]
     }
   ];
 }
@@ -233,12 +280,13 @@ var declares = {
     { ecosystem: "rubygems", name: "activerecord" },
     { ecosystem: "rubygems", name: "rails" }
   ],
-  reads: "ActiveRecord calls (Ruby): a call matches when its method is one ActiveRecord defines as a read or a write and the class behind its receiver reaches `ActiveRecord::Base`, following what each class extends through the project. Statements the project wrote itself are read for the tables they touch, whether they went through `find_by_sql` and `count_by_sql` or through the connection. A write also runs the model's callbacks, and what they reach lands on the body that did the write.",
+  reads: "ActiveRecord calls (Ruby): a call matches when its method is one ActiveRecord defines as a read or a write and the class behind its receiver reaches `ActiveRecord::Base`, following what each class extends through the project. Statements the project wrote itself are read for the tables they touch, whether they went through `find_by_sql` and `count_by_sql` or through the connection. A write also runs the model's callbacks, and what they reach is recorded on the body that did the write.",
   configuration: {
     file: "suss.activerecord.json",
     example: { storageSystem: "postgresql" },
     required: true,
-    why: "which database is behind the connection: postgresql, mysql, or sqlite. ActiveRecord talks to all of them and database.yml settles which, so the pack cannot."
+    why: "which database is behind the connection: postgresql, mysql, or sqlite. ActiveRecord talks to all of them and database.yml settles which, so the pack cannot.",
+    readFromProject: storageSystemFromDatabaseYml
   }
 };
 var index_default = activeRecordFramework;

package/dist/aiohttp.js

@@ -1,32 +1,43 @@
 // ../client/aiohttp/dist/index.js
-var VERB_METHODS = {
+var VERB_METHODS_THAT_FOLLOW = {
   get: "GET",
   post: "POST",
   put: "PUT",
   patch: "PATCH",
   delete: "DELETE",
-  head: "HEAD",
   options: "OPTIONS"
 };
+function verbCalls(verbs, redirectDelivery) {
+  return {
+    type: "clientCall",
+    importModule: ["aiohttp"],
+    verbAttributeNames: verbs,
+    url: { position: 0, keyword: "url" },
+    receiverConstructors: ["ClientSession"],
+    response: {
+      redirectDelivery,
+      redirectOption: { name: "allow_redirects", handsBack: [false] }
+    }
+  };
+}
 function aiohttpClient() {
   return {
     name: "aiohttp",
     protocol: "http",
     discovery: [],
+    // `head` defaults `allow_redirects` to False, and every other call,
+    // `request("HEAD", url)` included, defaults it to True.
     clients: [
       {
-        type: "clientCall",
-        importModule: ["aiohttp"],
-        verbAttributeNames: VERB_METHODS,
-        url: { position: 0, keyword: "url" },
+        ...verbCalls(VERB_METHODS_THAT_FOLLOW, "followed"),
         methodCall: {
           attribute: "request",
           methodPosition: 0,
           methodKeyword: "method",
           urlPosition: 1
-        },
-        receiverConstructors: ["ClientSession"]
-      }
+        }
+      },
+      verbCalls({ head: "HEAD" }, "response")
     ],
     // `ClientSession.__aenter__` returns the session, so `async with
     // aiohttp.ClientSession() as s` puts the constructed session in s.

package/dist/apollo-client.js

@@ -11,20 +11,18 @@ var DOCUMENT_HOOKS = [
 ];
 var optionsSchema = z.object({
   /**
-   * Which service each client talks to, keyed by the endpoint the
-   * client is constructed with: the uri string itself, or the written
-   * expression when the value is computed (an env read like
-   * `import.meta.env.VITE_GRAPHQL_URL`). The value is the provider
-   * workspace name. One line per client separates two GraphQL services
-   * that share root field names.
+   * The provider workspace each client talks to, keyed by the endpoint
+   * the client is constructed with. The key is the uri string, or the
+   * expression as written when the value is computed, such as
+   * `import.meta.env.VITE_GRAPHQL_URL`. One entry per client keeps
+   * apart two GraphQL services that share root field names.
    */
   clients: z.record(z.string(), z.string()).optional(),
   /**
-   * Which service the operations in a set of files talk to, for a
-   * frontend that uses two clients. A hook call does not say which
-   * client it goes through, so these globs decide by file: an
-   * operation whose file matches gets the entry's workspace. First
-   * matching entry wins.
+   * The workspace for operations in a set of files, for a frontend
+   * that uses two clients. A hook call does not show which client it
+   * goes through, so the pack decides by file. The first entry whose
+   * globs match the operation's file wins.
    */
   operationScopes: z.array(
     z.object({ files: z.array(z.string()), workspace: z.string() }).strict()
@@ -34,10 +32,8 @@ function apolloClientPack(options = {}) {
   return {
     name: "apollo-client",
     languages: ["typescript", "javascript"],
-    // Apollo Client sits over HTTP (or WebSocket for subscriptions;
-    // subscriptions reported separately via operationType but the
-    // transport tag stays "http" for v0, the Apollo HttpLink is the
-    // default path).
+    // Subscriptions can run over WebSocket, but operationType already
+    // records them, and HttpLink is Apollo's default transport.
     protocol: "http",
     discovery: [
       {
@@ -47,15 +43,11 @@ function apolloClientPack(options = {}) {
           importModule: "@apollo/client",
           hooks: [...DOCUMENT_HOOKS]
         },
-        // Prefix match: covers `@apollo/client` AND `@apollo/client/react`
-        // AND `@apollo/client/...` sub-paths in one go. The `importModule`
-        // on the match itself stays exact-match for discovery's own
-        // gating.
+        // requiresImport matches by prefix, so it also admits
+        // `@apollo/client/react`. importModule above matches exactly.
         requiresImport: ["@apollo/client"]
       },
-      // Newer re-exports split per-runtime ("@apollo/client/react").
-      // Apollo's current stable major is one path; the react-only
-      // export is here to handle projects that pin per-runtime.
+      // For projects that import the hooks from the React entry point.
       {
         kind: "client",
         match: {
@@ -65,13 +57,9 @@ function apolloClientPack(options = {}) {
         },
         requiresImport: ["@apollo/client"]
       },
-      // Imperative client: covers server-side data fetching,
-      // Next.js getServerSideProps, Node scripts, anywhere calling
-      // `client.query(...)` / `client.mutate(...)` directly rather
-      // than via a hook. The client identifier can be any name,
-      // we gate on the `ApolloClient` constructor being imported
-      // so random `.query()` method calls in unrelated code don't
-      // light up.
+      // `client.query(...)` outside a hook, as in server-side fetching.
+      // The client variable can have any name, so the match requires an
+      // `ApolloClient` import to skip unrelated `.query()` calls.
       {
         kind: "client",
         match: {
@@ -99,16 +87,16 @@ function apolloClientPack(options = {}) {
         requiresImport: ["@apollo/client"]
       }
     ],
-    // The constructions an operation's calls go through. `uri` is
-    // Apollo's own option, on the client shorthand and on the links.
+    // The endpoint an operation goes to comes from the `uri` option on
+    // whichever of these built its client.
     graphqlClients: [
       {
         importModule: "@apollo/client",
         importName: "ApolloClient",
         uriProperty: "uri",
-        // `createFragmentRegistry` hands the registry to the cache's
-        // `fragments` option; a document can then spread a fragment it
-        // does not define and the client fills it in at run time.
+        // With a registry from `createFragmentRegistry` on the cache, a
+        // document can spread a fragment it does not define, and the
+        // client fills it in at run time.
         fragmentRegistry: {
           cacheProperty: "cache",
           cacheConstructor: {
@@ -144,10 +132,9 @@ function apolloClientPack(options = {}) {
       }
     ],
     inputMapping: {
-      // Apollo hooks take no positional params we track, the surface
-      // inputs are the operation-header `$variables`, which the adapter
-      // reads from the resolved document and stamps onto the summary
-      // directly (role "variable"), independent of this mapping.
+      // The inputs are the `$variables` in the operation header. The
+      // adapter reads them from the resolved document, so no positional
+      // parameter is mapped here.
       type: "positionalParams",
       params: []
     }
@@ -157,7 +144,7 @@ var declares = {
   kind: "client",
   package: "@suss/client-apollo",
   dependencies: [{ ecosystem: "npm", name: "@apollo/client" }],
-  reads: "`@apollo/client` hooks + imperative `client.query`."
+  reads: "`@apollo/client` hooks and imperative `client.query` calls."
 };
 var index_default = apolloClientPack;
 export {

package/dist/apollo.js

@@ -3,9 +3,8 @@ function apolloFramework() {
   return {
     name: "apollo",
     languages: ["typescript", "javascript"],
-    // Apollo Server runs over HTTP; GraphQL semantics are discriminated
-    // at the resolver level (decision: resolver-level, not field-level)
-    // and surfaced via `graphql-resolver` semantics in the binding.
+    // Apollo Server runs over HTTP. The GraphQL type and field are set
+    // per resolver, on the `graphql-resolver` binding.
     protocol: "http",
     discovery: [
       {
@@ -14,14 +13,12 @@ function apolloFramework() {
           type: "resolverMap",
           importModule: "@apollo/server",
           importName: "ApolloServer",
-          // Apollo v4 convention: the config key is `resolvers`.
           mapProperty: "resolvers"
         },
         requiresImport: ["@apollo/server"]
       },
-      // Pre-v4 path: `import { ApolloServer } from "apollo-server"` /
-      // `"apollo-server-express"` / similar. Same shape, different
-      // module. Covers the bulk of real-world Apollo code before v4.
+      // Apollo before v4 exported the same `ApolloServer` from
+      // `apollo-server` and `apollo-server-express`.
       {
         kind: "resolver",
         match: {
@@ -44,10 +41,8 @@ function apolloFramework() {
       }
     ],
     terminals: [
-      // Resolvers return a value; errors propagate as thrown
-      // exceptions (Apollo maps them to `errors[]` on the outgoing
-      // response). No framework-specific response-call shape to
-      // match; return + throw cover the observable behavior.
+      // A resolver has no response call. It returns a value or throws,
+      // and Apollo turns a thrown error into `errors[]`.
       {
         kind: "return",
         match: { type: "returnStatement" },
@@ -58,21 +53,18 @@ function apolloFramework() {
         match: { type: "throwExpression" },
         extraction: {}
       },
-      // Resolvers often fall off the end without an explicit return,
-      // a type resolver can delegate to the default-resolver behavior
-      // by returning nothing. Keep the default transition so
-      // `transitions: []` isn't the shape we ship.
+      // A resolver that returns nothing hands off to Apollo's default
+      // resolver. Without this terminal it would come out with no
+      // transitions.
       {
         kind: "return",
         match: { type: "functionFallthrough" },
         extraction: {}
       }
     ],
-    // Apollo resolvers have a fixed 4-positional shape:
-    //   (parent, args, context, info) => ...
-    // Most resolvers ignore `parent` / `info`. We surface all four by
-    // role so downstream checks can distinguish "uses args" from
-    // "delegates to context" etc.
+    // All four positions get a role, even though most resolvers ignore
+    // `parent` and `info`, so a check can tell a resolver that reads
+    // `args` from one that hands off to `context`.
     inputMapping: {
       type: "positionalParams",
       params: [

package/dist/aws-dynamodb.js

@@ -214,9 +214,9 @@ function updateExpressionAttributes(expression, names) {
 }
 var optionsSchema = z.object({
   /**
-   * Further modules whose presence makes a file worth reading. A helper
-   * imported by a relative path gives the gate nothing to match on; the
-   * signing library that helper imports gives it something.
+   * More modules that get a file read when it imports them. A relative
+   * import of a helper matches no module, so the usual entry is the
+   * signing library the helper imports.
    */
   requiresImport: z.array(z.string()).optional()
 }).strict();
@@ -335,7 +335,7 @@ var declares = {
     { ecosystem: "npm", name: "@aws-sdk/lib-dynamodb" },
     { ecosystem: "npm", name: "@aws-sdk/client-dynamodb" }
   ],
-  reads: "AWS SDK v3 DynamoDB calls, emits storage-access interactions."
+  reads: "AWS SDK v3 DynamoDB calls. Each one becomes a storage-access interaction."
 };
 var index_default = dynamoFramework;
 export {

package/dist/aws-eventbridge.js

@@ -7,8 +7,8 @@ import { constructedFrom, messageSends, pack } from "@suss/recognize";
 var EVENTBRIDGE = "@aws-sdk/client-eventbridge";
 var optionsSchema = z.object({
   /**
-   * Publishers this project emits through. Each one adds a recognizer
-   * and widens the import gate to that publisher's module.
+   * Each publisher adds a recognizer, and the pack also reads files that
+   * import the publisher's module.
    */
   producers: z.array(configuredCallOption).optional()
 }).strict();
@@ -92,7 +92,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-eventbridge",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-eventbridge" }],
-  reads: "AWS EventBridge `PutEvents` producer calls, emits message-bus interactions."
+  reads: "AWS EventBridge `PutEvents` producer calls. Each one becomes a message-bus interaction."
 };
 var index_default = eventBridgeFramework;
 export {

package/dist/aws-lambda.js

@@ -146,9 +146,9 @@ function templatesForFiles(files) {
 }
 var HTTP_TERMINALS = [
   {
-    // `return { statusCode, body, headers? }`, written at the return site or
-    // built by a helper the adapter follows into. `body` contains the
-    // serialized payload, so unwrap `JSON.stringify(x)` to the shape of `x`.
+    // `return { statusCode, body, headers? }`, at the return or in a helper
+    // the adapter follows. `body` contains the serialized payload, so
+    // `JSON.stringify(x)` is unwrapped to the shape of `x`.
     kind: "response",
     match: { type: "returnShape", requiredProperties: ["statusCode"] },
     extraction: {
@@ -157,9 +157,9 @@ var HTTP_TERMINALS = [
     }
   },
   {
-    // `return { batchItemFailures }`, which is how a consumer tells Lambda
-    // which records to retry and which to drop. Lambda defines this shape, so
-    // the pack can match on it, the same way it matches the envelope above.
+    // `return { batchItemFailures }` makes Lambda retry the records it
+    // lists. Lambda defines this shape, so the pack can match on it the
+    // same way it matches the envelope above.
     kind: "return",
     match: {
       type: "returnShape",
@@ -168,9 +168,8 @@ var HTTP_TERMINALS = [
     extraction: {}
   },
   {
-    // `throw new SomeError(...)`. An uncaught throw becomes a
-    // throw-output transition; API Gateway maps it to a 5xx, but the
-    // specific status is the platform's, not the handler's.
+    // An uncaught throw becomes a throw-output transition. API Gateway
+    // turns it into a 5xx, and the platform picks which one.
     kind: "throw",
     match: { type: "throwExpression" },
     extraction: {}
@@ -184,10 +183,9 @@ var NON_HTTP_TERMINALS = [
     extraction: {}
   },
   {
-    // A queue consumer acknowledges a batch by not throwing: it processes the
-    // records, falls off the end, and Lambda reads the absence of an error as
-    // the ack. Without this the handler has no terminal, so it gets no
-    // transition, and everything it does goes with it.
+    // A queue consumer acknowledges a batch by returning without an error.
+    // Without this pattern the handler has no terminal, so it gets no
+    // transition and everything it does is lost with it.
     kind: "return",
     match: { type: "functionFallthrough" },
     extraction: {}
@@ -367,45 +365,25 @@ function awsLambdaFramework(_options = {}) {
   return {
     name: "aws-lambda",
     protocol: "http",
-    // Sentry's wrapper is a library call whose body the adapter cannot
-    // read, so the pack states the judgment: the handler is argument 0.
-    // Project-local wrappers need no declaration; the adapter derives
-    // those by reading the factory body.
+    // The adapter cannot read Sentry's wrapper inside the library, so the
+    // pack declares that the handler is argument 0. A wrapper written in
+    // the project needs no entry, because the adapter reads its body.
     transparentWrappers: [
-      {
-        callee: "Sentry.wrapHandler",
-        argument: 0,
-        module: "@sentry/aws-serverless"
-      }
+      { module: "@sentry/aws-serverless", name: "wrapHandler", argument: 0 }
     ],
     languages: ["typescript", "javascript"],
-    // No data-driven discovery: routing lives in the SAM/CFN template,
-    // not in code. The callback resolves handlers against the template.
+    // The routing is in the template, so the callback finds handlers
+    // there and the pattern list stays empty.
     discovery: [],
     discoverUnits: awsLambdaDiscovery(),
-    // Everything this pack discovers comes off the template, so the
-    // cache has to key on it the way it keys on a pack's config.
+    // Discovery reads the templates, so they go into the cache key and an
+    // edited template makes the next run read the project again.
     discoveryInputs: templatesForFiles,
-    // No import gate, on purpose.
-    //
-    // A TypeScript handler writes `import type { APIGatewayProxyHandlerV2 }
-    // from "aws-lambda"`, which TypeScript resolves to
-    // `@types/aws-lambda`, to annotate its export. A JavaScript handler
-    // has nothing to annotate and writes no such import. Gating
-    // discovery on it therefore meant "TypeScript handlers that bothered
-    // to annotate", and every JavaScript Lambda service extracted
-    // nothing.
-    //
-    // The SAM template is the gate instead, and a better one, because it
-    // says which handlers outright. `discoverUnits` looks each file up in
-    // the template reachable from it, and a directory with no template
-    // resolves to null once and stays memoized.
-    // Route units extract against these. Non-HTTP accounting units get their
-    // own wider list, attached per unit by the discovery callback.
+    // No import gate: a JavaScript handler imports nothing from
+    // `aws-lambda`, so the template acts as the gate. See the README.
+    // A unit that is not HTTP gets a longer list from the discovery
+    // callback in place of this one.
     terminals: HTTP_TERMINALS,
-    // Lambda's handler signature is `(event, context, callback?)`. The
-    // HTTP request data (path params, query, body) lives on `event`;
-    // decomposing it into typed inputs is a follow-up.
     inputMapping: {
       type: "positionalParams",
       params: [
@@ -413,9 +391,9 @@ function awsLambdaFramework(_options = {}) {
         { position: 1, role: "context" }
       ]
     },
-    // A proxy integration hands the handler API Gateway's event. The
-    // body arrives on it as a string the handler parses, so a read of
-    // it says the body was taken whole and never which field.
+    // A proxy integration passes the handler API Gateway's event, with the
+    // body as a string the handler parses. A read of the body records that
+    // the handler took all of it, with no field name.
     requestSpelling: {
       headers: { path: ["event", "headers"], saysWhichField: true },
       query: {
@@ -425,17 +403,16 @@ function awsLambdaFramework(_options = {}) {
       params: { path: ["event", "pathParameters"], saysWhichField: true },
       body: { path: ["event", "body"], saysWhichField: false }
     },
-    // The powertools read their configuration from inside node_modules,
-    // so a template that declares these has a reader no walk ever sees.
+    // Powertools reads these variables from inside node_modules, where no
+    // walk over the project goes, so without this entry they look unread.
     libraryEnvVars: [
       {
         module: "@aws-lambda-powertools/",
         prefixes: ["POWERTOOLS_"]
       }
     ],
-    // Still no pack-level `requiresImport`: it would gate
-    // `discoverUnits` as well, and each declaration checks the SDK its
-    // command came from anyway.
+    // A pack-level `requiresImport` would gate `discoverUnits` too. Each
+    // declaration already checks which SDK its command class came from.
     invocationRecognizers: invokes.map(
       (match) => compile(match.declared, "@suss/framework-aws-lambda")
     ),
@@ -446,7 +423,7 @@ var declares = {
   kind: "framework",
   package: "@suss/framework-aws-lambda",
   dependencies: [{ ecosystem: "npm", name: "@types/aws-lambda" }],
-  reads: "AWS Lambda HTTP handlers, paired to SAM / CloudFormation-declared routes."
+  reads: "AWS Lambda HTTP handlers, paired with the routes a SAM or CloudFormation template declares."
 };
 var index_default = awsLambdaFramework;
 export {

package/dist/aws-s3.js

@@ -38,7 +38,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-s3",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-s3" }],
-  reads: "AWS SDK v3 S3 object calls, emits storage-access interactions."
+  reads: "AWS SDK v3 S3 object calls. Each one becomes a storage-access interaction."
 };
 var index_default = s3Framework;
 export {

package/dist/aws-secrets-manager.js

@@ -32,7 +32,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-secrets-manager",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-secrets-manager" }],
-  reads: "AWS Secrets Manager calls, emits storage-access interactions against the secret."
+  reads: "AWS Secrets Manager calls. Each one becomes a storage-access interaction on the secret."
 };
 var index_default = secretsManagerFramework;
 export {

package/dist/aws-sns.js

@@ -30,7 +30,7 @@ var PUBLISH_BATCH = messageSends({
   wire: "aws.sns",
   client: constructedFrom(SNS),
   messages: { each: "in", property: "PublishBatchRequestEntries" },
-  // A batch states the topic once beside the list of messages.
+  // The topic is on the command input, once, beside the list of messages.
   channel: [{ property: TOPIC, on: "theInput" }],
   routingKey: "Subject",
   body: "Message"
@@ -48,7 +48,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-sns",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-sns" }],
-  reads: "AWS SDK v3 SNS `Publish` and `PublishBatch` calls, emits message-send interactions on the topic."
+  reads: "AWS SDK v3 SNS `Publish` and `PublishBatch` calls. Each one becomes a message-send interaction on the topic."
 };
 var index_default = snsFramework;
 export {