@quickback-dev/cli 0.61.0 → 0.63.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/commands/compile.d.ts +11 -0
- package/dist/commands/compile.d.ts.map +1 -1
- package/dist/commands/compile.js +57 -13
- package/dist/commands/compile.js.map +1 -1
- package/dist/index.js +4 -2
- package/dist/index.js.map +1 -1
- package/dist/lib/compiler-stubs.d.ts +4 -0
- package/dist/lib/compiler-stubs.d.ts.map +1 -1
- package/dist/lib/compiler-stubs.js +4 -0
- package/dist/lib/compiler-stubs.js.map +1 -1
- package/dist/lib/file-loader.d.ts +11 -0
- package/dist/lib/file-loader.d.ts.map +1 -1
- package/dist/lib/file-loader.js +35 -0
- package/dist/lib/file-loader.js.map +1 -1
- package/dist/skill/SKILL.md +3 -0
- package/dist/skill/docs/api/crud.md +17 -0
- package/dist/skill/docs/changelog/index.md +112 -0
- package/dist/skill/docs/configure/auth.md +2 -1
- package/dist/skill/docs/configure/index.md +1 -1
- package/dist/skill/docs/define/actions/defining.md +55 -6
- package/dist/skill/docs/define/actions/index.md +73 -0
- package/dist/skill/docs/define/feature.md +2 -1
- package/dist/skill/docs/define/scopes.md +9 -4
- package/dist/skill/docs/platform/api-contract/index.md +19 -1
- package/dist/skill/docs/platform/auth/jwt-optimization.md +2 -2
- package/dist/skill/docs/platform/email/index.md +112 -0
- package/dist/skill/docs/platform/index.md +1 -0
- package/dist/skill/docs/tooling/cloud-compiler/endpoints.md +3 -1
- package/dist/skill/docs/tooling/output.md +21 -0
- package/package.json +2 -10
- package/src/skill/SKILL.md +3 -0
- package/src/skill/docs/api/crud.md +17 -0
- package/src/skill/docs/changelog/index.md +112 -0
- package/src/skill/docs/configure/auth.md +2 -1
- package/src/skill/docs/configure/index.md +1 -1
- package/src/skill/docs/define/actions/defining.md +55 -6
- package/src/skill/docs/define/actions/index.md +73 -0
- package/src/skill/docs/define/feature.md +2 -1
- package/src/skill/docs/define/scopes.md +9 -4
- package/src/skill/docs/platform/api-contract/index.md +19 -1
- package/src/skill/docs/platform/auth/jwt-optimization.md +2 -2
- package/src/skill/docs/platform/email/index.md +112 -0
- package/src/skill/docs/platform/index.md +1 -0
- package/src/skill/docs/tooling/cloud-compiler/endpoints.md +3 -1
- package/src/skill/docs/tooling/output.md +21 -0
|
@@ -60,10 +60,14 @@ The server probes **every declared role** for the proposed instance (one DB touc
|
|
|
60
60
|
|
|
61
61
|
```jsonc
|
|
62
62
|
// a shuttle driver who is also a confirmed guest
|
|
63
|
-
"scope": { "event": { "id": "evt_123", "roles": ["attendee", "shuttleDriver"], "shuttleId": "shA" } }
|
|
63
|
+
"scope": { "event": { "id": "evt_123", "roles": ["attendee", "shuttleDriver"], "shuttleId": "shA", "sctMs": "m1700000000000" } }
|
|
64
64
|
```
|
|
65
65
|
|
|
66
|
-
|
|
66
|
+
`sctMs` is on **every** entry: the server's proof timestamp for that kind (epoch milliseconds, written `m<ms>`) — see [Revocation & TTL](#revocation--ttl). The examples below elide it to keep the key under discussion in view.
|
|
67
|
+
|
|
68
|
+
The client sends that JWT as `Authorization: Bearer …` on subsequent requests. The auth middleware verifies the signature and sets `ctx.scope` — **no DB**. The claim is carried forward on every authed call (rolling refresh) for up to **15 minutes from the last actual relationship proof** — the mint stamps a proof timestamp that the refresh carries forward verbatim and checks against the carry-forward cap. Past the cap the refresh stops, the token expires within one TTL, and the client re-proves via `enter` (or any namespace route that mints) to restart the window.
|
|
69
|
+
|
|
70
|
+
The proof timestamp is **per scope kind**. A mint proves the kind it was asked for and carries every other kind forward *with the stamp it already had* (`sctMs` on the entry, epoch milliseconds written `m<ms>`), so entering one relationship never extends — or resurrects — another. Re-proving `event` restarts `event`'s window and nothing else.
|
|
67
71
|
|
|
68
72
|
> **Invariant:** the client only *proposes* the instance id (from the URL). The server proves membership before signing. No client-asserted scope is ever trusted.
|
|
69
73
|
|
|
@@ -631,11 +635,11 @@ the socket gate stay identical for accountless principals too.
|
|
|
631
635
|
The scope claim is trusted between proofs — it is never re-checked against the database while it rides. Two bounds keep that window finite:
|
|
632
636
|
|
|
633
637
|
- **The TTL** (default 180s, `auth.jwt.expiresIn`, clamped ≤180s on scope-bearing tokens) bounds an *idle* client: a token that stops being used dies within one TTL.
|
|
634
|
-
- **The carry-forward cap** (15 minutes) bounds an *active* client: the rolling refresh re-signs the claim on every authed call, but only while
|
|
638
|
+
- **The carry-forward cap** (15 minutes) bounds an *active* client: the rolling refresh re-signs the claim on every authed call, but only while its proof timestamp (stamped exclusively by the proven mint sites) is younger than the cap. The cap is applied **per scope kind** — a kind whose own proof is past it is dropped from the re-signed claim, so re-proving one relationship cannot roll another forward. Past the cap the refresh refuses, the token expires, and the next `enter` (or namespace-route mint) re-probes the relationship — which won't re-mint a revoked role.
|
|
635
639
|
|
|
636
640
|
So removing a guest/staff row takes effect within **cap + one TTL** for a client that keeps polling, and within one TTL once it goes idle. Two ways to tighten that:
|
|
637
641
|
|
|
638
|
-
- **`auth.jwt.revocationCheck: 'kv'`** (v0.45+, Cloudflare runtime) — sub-TTL revocation: updating or deleting a conferring relationship row stamps a revocation timestamp in KV, and the bearer fast-path rejects a carried scope claim whose proof
|
|
642
|
+
- **`auth.jwt.revocationCheck: 'kv'`** (v0.45+, Cloudflare runtime) — sub-TTL revocation: updating or deleting a conferring relationship row stamps a revocation timestamp in KV, and the bearer fast-path rejects a carried scope claim whose proof is at or before it — no same-second gap. Each kind is compared against **its own** proof time (`sctMs` on the entry; older tokens without one fall back to the token-level `sct`/`sctMs`), so a mint of one kind can't carry a revoked kind past its marker. Neither the refresh nor a re-mint ever substitutes its own clock for a proof it didn't take. The check fails closed — a scope claim whose revocation state can't be read is not trusted either. See [auth config](/configure/auth).
|
|
639
643
|
- **`via` arms** — for tables where any caching is too wide, gate with a `via` arm instead of a bare `ctx.scope.<kind>` arm: `via` emits a live subquery against the relationship table on every request, immune to a stale claim entirely.
|
|
640
644
|
|
|
641
645
|
## Reference
|
|
@@ -662,6 +666,7 @@ ctx.mintScope(opts: { via: string; subject: string; setAuthToken?: boolean }):
|
|
|
662
666
|
- `requestField` must equal every role-relationship's `resource.column`.
|
|
663
667
|
- Each relationship's `from` table must exist and ship a generated firewall (it can't be `exception`).
|
|
664
668
|
- A `subKeys` entry ending in `[]` is **set-valued** (lowers to `inArray`, minted as `string[]`); without the marker it's scalar (`eq`, minted as `string`).
|
|
669
|
+
- `id`, `roles`, `subjectId`, and `sctMs` are **reserved** on the claim entry — the mint owns them, so a `subKeys` entry of that name is a compile error rather than a row value overwriting proven state.
|
|
665
670
|
- `subject` defaults to `'user'`. `'supplied'`/`'both'` enable [`ctx.mintScope`](#sessionless-scope-mint--ctxmintscope) (sessionless mint); `'supplied'` is **not** mintable via `/scope/v1/enter`.
|
|
666
671
|
- `ctx.mintScope({ via, subject })` mints a **scope-only** token (no user identity, `ctx.userId` undefined) from the `from`-row whose PK is `subject` — reading the role, resource id, sub-keys, and `subjectId` off that row.
|
|
667
672
|
- `subjectId` is the conferring row's primary key, populated on **both** proof paths — scope self-data on `ctx.scope.<kind>.subjectId`.
|
|
@@ -111,6 +111,24 @@ export default defineAction({
|
|
|
111
111
|
});
|
|
112
112
|
```
|
|
113
113
|
|
|
114
|
+
## The default becomes v2 in v0.64.0
|
|
115
|
+
|
|
116
|
+
`contract.version` resolves to `'v1'` when unset. That default becomes `'v2'`
|
|
117
|
+
in Quickback **v0.64.0**. Every project without an explicit `contract.version`
|
|
118
|
+
moves the entire matrix below on its next compile after that release.
|
|
119
|
+
|
|
120
|
+
Pin the current wire:
|
|
121
|
+
|
|
122
|
+
```typescript
|
|
123
|
+
{/* doc-compile: skip — config fragment */}
|
|
124
|
+
contract: { version: "v1" }
|
|
125
|
+
```
|
|
126
|
+
|
|
127
|
+
**Pinning your CLI version does not pin the contract.** The default lives in the
|
|
128
|
+
compiler, which is a hosted service — an older CLI inherits the flip too. The
|
|
129
|
+
config key is the only pin. v0.63.0 warns on every compile that leaves
|
|
130
|
+
`contract.version` unset.
|
|
131
|
+
|
|
114
132
|
## Contract version matrix
|
|
115
133
|
|
|
116
134
|
Flipping `contract.version` moves the **entire** contract at once — plan the
|
|
@@ -128,7 +146,7 @@ client migration as one move:
|
|
|
128
146
|
| Aggregate changesets (`application/vnd.quickback.changeset+json` on PATCH/POST, [`owns`](/define/changesets)) | not available | available where `owns` is declared |
|
|
129
147
|
| Bare `?fields=` unknown names | silently dropped | **400** |
|
|
130
148
|
| `fields[<fk>]=` unknown names | n/a | **400** |
|
|
131
|
-
| Action input schemas |
|
|
149
|
+
| Action input schemas | complete client-side harvest **required** (since v0.63.0) | complete client-side harvest **required** |
|
|
132
150
|
|
|
133
151
|
Sequencing a migration: ship clients that speak the v2 paths, CloudEvents
|
|
134
152
|
frames, and session-first auth (or declare `auth.jwt`); confirm webhook
|
|
@@ -31,7 +31,7 @@ The JWT encodes everything needed for auth middleware:
|
|
|
31
31
|
| `iatMs` | Issued-at in epoch **milliseconds** — Quickback ordering metadata, not a standard claim. Same clock sample as `iat`, set by the signer only. Lets [revocation](#revocation--revocationcheck-kv) order a token against a marker written in the same second |
|
|
32
32
|
| `exp` | Expiry — **180 seconds** (3 minutes) after `iat` by default; set via [`auth.jwt.expiresIn`](/configure/auth) |
|
|
33
33
|
|
|
34
|
-
Scope-bearing tokens also carry `sct` (proof timestamp, unix seconds) and its millisecond companion `sctMs` —
|
|
34
|
+
Scope-bearing tokens also carry `sct` (proof timestamp, unix seconds) and its millisecond companion `sctMs`, plus a per-kind `sctMs` stamp (`m<ms>`) inside each `scope.<kind>` entry — a mint proves one kind and carries the others forward with the proof time they already had. See [Scopes](/define/scopes). Read `iat` / `sct` from external tooling; the millisecond values exist only so revocation can break ties inside a second.
|
|
35
35
|
|
|
36
36
|
### Signing
|
|
37
37
|
|
|
@@ -116,7 +116,7 @@ auth: {
|
|
|
116
116
|
},
|
|
117
117
|
```
|
|
118
118
|
|
|
119
|
-
The fast-path then consults per-principal revocation timestamps in your project's existing `KV` binding (keys prefixed `qbrev:`, self-expiring) *before* trusting a token. A token is rejected when its mint timestamp (`iat`/`iatMs`, or
|
|
119
|
+
The fast-path then consults per-principal revocation timestamps in your project's existing `KV` binding (keys prefixed `qbrev:`, self-expiring) *before* trusting a token. A token is rejected when its mint timestamp (`iat`/`iatMs`, or the proof time of the scope kind being checked) is **at or before** the stored timestamp. Cost: 2+ edge-cached KV reads per bearer verify.
|
|
120
120
|
|
|
121
121
|
There is no same-second gap: markers are epoch milliseconds (written `m<ms>`, v0.61.0+), tokens carry millisecond companions, and the comparison denies a tie — so a token minted a few milliseconds *before* the revocation is rejected, while one legitimately re-minted *after* it in that same second is still accepted. Pre-v0.61.0 workers don't understand that marker format and read it as "not revoked" — don't roll back across the upgrade or share one KV namespace between versions; see [`revocationCheck`](/configure/auth#revocationcheck-none--kv--token-revocation-strategy).
|
|
122
122
|
|
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
# Email (Inbound)
|
|
2
|
+
|
|
3
|
+
`defineEmail` is the inbound-mail mirror of [`defineSchedule`](/platform/schedules). Drop a file in `services/email/` and the compiler emits a shared `deliverInboundEmail()` dispatcher. **Execute is provider-agnostic** — you parse RFC 822 bytes and write the store. Ingress is an adapter:
|
|
4
|
+
|
|
5
|
+
| Provider | Ingress | How it reaches `execute` |
|
|
6
|
+
|----------|---------|--------------------------|
|
|
7
|
+
| Cloudflare (`email.provider: 'cloudflare'`, default) | Email Routing → Worker `email()` | Compiler emits `email` on the Worker export. Buffers `message.raw` once, then calls `deliverInboundEmail`. |
|
|
8
|
+
| Amazon SES (`email.provider: 'aws-ses'`) | Receipt rule → S3 + SNS | Build the same `InboundEmailMessage` (`provider: 'ses'`, `raw` = the `.eml` bytes) and call `deliverInboundEmail(message, env)`. |
|
|
9
|
+
|
|
10
|
+
Outbound sending is a separate surface (`email.provider` already switches Cloudflare `send_email` vs AWS SES) — see [Email Configuration](/configure#email-configuration).
|
|
11
|
+
|
|
12
|
+
## Define a handler
|
|
13
|
+
|
|
14
|
+
```typescript
|
|
15
|
+
// services/email/inbound.ts
|
|
16
|
+
import { defineEmail } from "quickback";
|
|
17
|
+
import { ingestMessage } from "../../features/mail/lib/ingest";
|
|
18
|
+
|
|
19
|
+
export default defineEmail({
|
|
20
|
+
name: "inbound", // identifier + audit actor (system:email-<name>)
|
|
21
|
+
to: "paul@kardoe.com", // optional; omit to match every recipient
|
|
22
|
+
description: "Ingest inbound mail",
|
|
23
|
+
execute: async ({ message, db, env, services }) => {
|
|
24
|
+
// message.raw is already-buffered RFC 822 bytes (not a stream).
|
|
25
|
+
await ingestMessage(db, env, services, message.raw);
|
|
26
|
+
},
|
|
27
|
+
});
|
|
28
|
+
```
|
|
29
|
+
|
|
30
|
+
One file per handler under `services/email/*.ts`. Files prefixed with `_` are ignored. `name` must be a valid camelCase identifier (it's used as a generated symbol and the audit actor). The same file is what runs on Cloudflare and on SES — do not import `ForwardableEmailMessage` or SES receipt types in `execute`.
|
|
31
|
+
|
|
32
|
+
## Envelope matching
|
|
33
|
+
|
|
34
|
+
| `to` | Behavior |
|
|
35
|
+
|------|----------|
|
|
36
|
+
| omitted | Handler runs for every inbound message |
|
|
37
|
+
| `"user@example.com"` | Exact, case-insensitive match against `message.to` |
|
|
38
|
+
|
|
39
|
+
Multiple handlers can match the same message (a catch-all plus an address-specific handler). Failures are isolated so one throwing handler does not abort the others.
|
|
40
|
+
|
|
41
|
+
If **no** handler matches, the runner logs a warning and returns. It does **not** call Cloudflare `setReject()` — Email Routing can still fall through, and SES has already accepted the message.
|
|
42
|
+
|
|
43
|
+
## Importing feature code
|
|
44
|
+
|
|
45
|
+
Email files live at `quickback/services/email/<name>.ts`, so imports are relative to **that** location. To reach a feature table, a feature `lib/` helper, or `db/`, climb up to the `quickback/` root first (`../../`):
|
|
46
|
+
|
|
47
|
+
```typescript
|
|
48
|
+
// quickback/services/email/inbound.ts
|
|
49
|
+
import { messages } from "../../features/mail/messages";
|
|
50
|
+
import { ingestMessage } from "../../features/mail/lib/ingest";
|
|
51
|
+
import { parseRfc822 } from "../../lib/rfc822";
|
|
52
|
+
```
|
|
53
|
+
|
|
54
|
+
Two `../` — up from `services/email/` to `quickback/`, then down into `features/` (or `lib/`, `db/`). The compiler relocates the handler into the generated `src/lib/email.ts` and **rewrites these paths to resolve from there automatically** — you always write them relative to your own source file, exactly as your editor resolves them.
|
|
55
|
+
|
|
56
|
+
> A single `../features/…` is the common mistake — from `services/email/` that resolves to `services/features/…`, which doesn't exist. Use `../../features/…`.
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
## What the compiler emits
|
|
60
|
+
|
|
61
|
+
1. **`deliverInboundEmail(message, env)`** in `src/lib/email.ts` — the shared dispatcher.
|
|
62
|
+
2. **`email(cfMessage, env, ctx)`** on the Worker default export — Cloudflare adapter. Regenerated on every `quickback compile`.
|
|
63
|
+
3. **No wrangler inbound binding.** Cloudflare: configure Email Routing in the dashboard. SES: Receipt rule + S3 + SNS; call `deliverInboundEmail` with the fetched `.eml`.
|
|
64
|
+
4. The existing outbound `[[send_email]]` binding (Cloudflare) / SES plugin (aws-ses) is unchanged.
|
|
65
|
+
|
|
66
|
+
## Execute context
|
|
67
|
+
|
|
68
|
+
| Field | Type | Notes |
|
|
69
|
+
|-------|------|-------|
|
|
70
|
+
| `message` | `InboundEmailMessage` | `{ provider, from, to, headers, raw }`. `raw` is `ArrayBuffer`. |
|
|
71
|
+
| `message.provider` | `'cloudflare' \| 'ses'` | Ingress tag for logs. Parse `raw`, don't branch on this. |
|
|
72
|
+
| `db` | Drizzle instance | The same DB the queue/schedule handlers get |
|
|
73
|
+
| `env` | `CloudflareBindings` | All worker bindings |
|
|
74
|
+
| `services` | `Services` | The services layer (`createServices(env)`) |
|
|
75
|
+
| `withInternalContext` | helper | Opt into the `INTERNAL` trust zone for `roles: ['INTERNAL']`-gated rows |
|
|
76
|
+
|
|
77
|
+
Cloudflare-only methods (`setReject`, `forward`, `reply`) are **not** on `InboundEmailMessage`. SES has already accepted the mail; Cloudflare fall-through is the adapter's job (it does not reject unmatched recipients).
|
|
78
|
+
|
|
79
|
+
## Amazon SES inbound
|
|
80
|
+
|
|
81
|
+
SES cannot invoke a Worker `email()` export — receipt is S3 + SNS. After you verify the SNS signature and fetch the object:
|
|
82
|
+
|
|
83
|
+
```typescript
|
|
84
|
+
import { deliverInboundEmail } from "../lib/email";
|
|
85
|
+
|
|
86
|
+
await deliverInboundEmail({
|
|
87
|
+
provider: "ses",
|
|
88
|
+
from: receipt.mail.source,
|
|
89
|
+
to: receipt.receipt.recipients[0],
|
|
90
|
+
headers: new Headers(/* from the .eml or commonHeaders */),
|
|
91
|
+
raw: await s3.getObject(bucket, key).arrayBuffer(),
|
|
92
|
+
}, env);
|
|
93
|
+
```
|
|
94
|
+
|
|
95
|
+
`execute` does not change. MX, Receipt rules, the S3 bucket, and the SNS subscription stay in AWS — the compiler does not emit those.
|
|
96
|
+
|
|
97
|
+
## Audit & trust
|
|
98
|
+
|
|
99
|
+
Inbound email runs are **server-internal**: there's no authenticated user, no request, no org scope. A delivered message gets a plain `db` (unscoped Drizzle) plus a `withInternalContext` helper:
|
|
100
|
+
|
|
101
|
+
```typescript
|
|
102
|
+
execute: async ({ db, withInternalContext, message }) => {
|
|
103
|
+
// `db` here is unscoped — no firewall WHERE, no audit actor.
|
|
104
|
+
|
|
105
|
+
await withInternalContext(async ({ ctx, db, services }) => {
|
|
106
|
+
// ctx.internal = true, ctx.userId = "system:email-<name>"
|
|
107
|
+
// audited writes are attributable to e.g. system:email-inbound
|
|
108
|
+
});
|
|
109
|
+
},
|
|
110
|
+
```
|
|
111
|
+
|
|
112
|
+
`withInternalContext` builds a context with `internal: true` and `userId: "system:email-<name>"`, so audited writes made through it are attributable to the handler and can reach `roles: ['INTERNAL']`-gated rows.
|
|
@@ -11,6 +11,7 @@
|
|
|
11
11
|
| [Realtime](/platform/realtime) | Durable Objects | WebSocket for live updates |
|
|
12
12
|
| [Queues](/platform/queues) | Cloudflare Queues | Background jobs, webhook delivery |
|
|
13
13
|
| [Schedules](/platform/schedules) | Cron Triggers | `defineSchedule` cron jobs, server-internal |
|
|
14
|
+
| [Email](/platform/email) | Email Workers | `defineEmail` inbound handlers, server-internal |
|
|
14
15
|
| [Vector & AI](/platform/vector) | Workers AI | Embeddings, semantic search |
|
|
15
16
|
| [Webhooks](/platform/webhooks) | Hono + Queues | Signed inbound, retried outbound |
|
|
16
17
|
| [Push](/platform/push) | Web Push | VAPID subscriptions, typed payloads |
|
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
# Endpoints
|
|
2
2
|
|
|
3
|
-
The cloud compiler API is hosted at `https://compiler.quickback.dev
|
|
3
|
+
The cloud compiler API is hosted at `https://compiler.quickback.dev`
|
|
4
|
+
(alias: `https://build.quickback.dev` — same Worker, same auth via
|
|
5
|
+
`quickback-api`, identical `/health` / `/templates` / `/compile`).
|
|
4
6
|
|
|
5
7
|
## Public (No Auth)
|
|
6
8
|
|
|
@@ -184,6 +184,27 @@ authentication behavior. Quickback preserves unrelated overrides already in
|
|
|
184
184
|
your package manifest, but the compiler-owned Lodash security pin wins if an
|
|
185
185
|
existing override conflicts.
|
|
186
186
|
|
|
187
|
+
A project that declares an in-worker Durable Object also gets `hono-party`
|
|
188
|
+
plus a second entry in the same block:
|
|
189
|
+
|
|
190
|
+
```json
|
|
191
|
+
{
|
|
192
|
+
"overrides": {
|
|
193
|
+
"hono-party": {
|
|
194
|
+
"@cloudflare/workers-types": "$@cloudflare/workers-types"
|
|
195
|
+
}
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
```
|
|
199
|
+
|
|
200
|
+
`hono-party` still declares a peer dependency on `@cloudflare/workers-types`
|
|
201
|
+
major 4, which cannot be satisfied alongside the major 5 the compiler pins, so
|
|
202
|
+
a plain `npm install` would fail with `ERESOLVE`. The override is scoped to
|
|
203
|
+
`hono-party` — nothing else in the tree is relaxed — and the `$` form resolves
|
|
204
|
+
to whatever your `package.json` already declares, so it tracks the pin instead
|
|
205
|
+
of drifting from it. Projects without an in-worker Durable Object do not get
|
|
206
|
+
this entry.
|
|
207
|
+
|
|
187
208
|
After recompiling, run your package manager's install command so its lockfile
|
|
188
209
|
records the patched transitive version. Use `npm audit --omit=dev` when
|
|
189
210
|
evaluating the production dependency tree; development-tool advisories are a
|