Skip to content

fix(docusaurus): Release pending changes as 2.0.7 - #5755

Merged
marandaneto merged 1 commit into
mainfrom
fix/docusaurus-republish-2.0.7
Nov 16, 2026
Merged

marandaneto merged 1 commit into
mainfrom
fix/docusaurus-republish-2.0.7

Conversation

@marandaneto

Copy link
Copy Markdown
Member

Problem

The latest release run failed to publish posthog-docusaurus@2.0.6. npm returned Cannot publish over previously published version "2.0.6".

posthog-docusaurus@2.0.6 was published from the old standalone repository on 2025-11-24 and later removed from npm. npm never allows a removed version number to be published again. The release check missed this because it only compares against the versions npm still lists, so the workflow tried to publish 2.0.6 and npm rejected it.

The changes in the 2.0.6 changelog entry are on main but not on npm.

Changes

Adds a patch changeset for posthog-docusaurus. The next release bumps the package to 2.0.7 and publishes the changes listed under 2.0.6.

Release info Sub-libraries affected

Libraries affected

  • posthog-docusaurus

Checklist

If releasing new changes

  • Ran pnpm changeset to generate a changeset file

🤖 Agent context

Autonomy: Human-driven (agent-assisted)

Pi helped find the cause from the failed release job. The npm registry still lists a publish time for 2.0.6 but no 2.0.6 version, which shows the version was removed. npm org access was ruled out because the package is already in the posthog org.

@marandaneto marandaneto self-assigned this Nov 16, 2026
@github-actions

Copy link
Copy Markdown
Contributor
⚠️ Changeset declares `posthog-docusaurus` but no source files in that package changed

This is informational — the PR is not blocked. Click the triangle above to collapse, or push a fix and this comment will auto-delete.

Declared in a changeset but no source files modified:

  • posthog-docusaurus

Double-check this is intentional — for example, releasing a previously-merged change.

Changesets in this PR:

  • posthog-docusaurus — patch

@marandaneto

Copy link
Copy Markdown
Member Author

is already 2.0.6

@marandaneto
marandaneto marked this pull request as ready for review November 16, 2026 20:17
@marandaneto
marandaneto requested a review from a team as a code owner November 16, 2026 20:17
@veria-ai

veria-ai Bot commented Nov 16, 2026 •

Copy link
Copy Markdown

PR overview

No security issues were found in this pull request.

Reviews

@posthog-security-review-bot posthog-security-review-bot Bot added the security-review Request a security review label Nov 16, 2026
@posthog-security-review-bot

posthog-security-review-bot Bot commented Nov 16, 2026 •

Copy link
Copy Markdown

✅ Security review complete — c95a41633ede

No findings above the confidence threshold, in 3 min.

Add the security-review label to run again on the latest commit.

@github-actions

Copy link
Copy Markdown
Contributor

Coherence

📄 0 spec file errors · ⛔ 0 broken rules · 🚪 2 unchecked inputs · 🐛 0 bugs that came back

What is Coherence?

Coherence compares the code with its spec files (*.spec.md). A spec file lists the rules for one part of the code.

This check read 44 parts of the code and 7 rules.

Note

These findings do not make this check fail.

None of these findings are in files that this pull request changes. You do not need to fix them in this pull request.

🚪 Unchecked inputs (2)

  • public api in packages/web/Web.spec.md. The input comes from: host-app.
  • webpack plugin in packages/webpack-plugin/Webpack-plugin.spec.md. The input comes from: build.
What this means and how to fix it

Input from outside this code comes in at these places. The spec does not say what checks that input. 10 more places were already like this when Coherence was added. This list does not show them.

To close one of these, find the place by its name in the ## entrances section of its spec file. Add one line under it:

  • If all of the input goes through one function that a rule in the spec protects, add guard: <function>.
  • If a rule in the spec already checks input from the same source, add the place's name to the entrances: line of that rule.
  • If the input needs no check, add control: none - <reason>.

To get the line to add, run npx --no -- coherence scaffold control "<name>".

@posthog-security-review-bot posthog-security-review-bot Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Agent-driven security review - no findings.

@posthog-security-review-bot posthog-security-review-bot Bot removed the security-review Request a security review label Nov 16, 2026
@github-actions

Copy link
Copy Markdown
Contributor

SDK performance: posthog-node

Benchmarks completed. No changes flagged for review.

Flags require at least a 5% change in the median and all six pairs agreeing on direction. This is a noise filter, not proof of a performance change or a CI gate.

View all results
Test Measurement Before PR With PR Change Assessment
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Queue an event (32-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Queue an event (4,096-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate all 10 flags
Shard: flags-scaling
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate all 100 flags
Shard: flags-scaling
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate all 1,000 flags
Shard: flags-scaling
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate one boolean flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a cohort-filtered flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a flag (early match)
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a flag (late match)
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a flag (no match)
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a property-filtered flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a regex-filtered flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a rollout flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Evaluate a multivariate flag
Shard: flags-single
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ V8 samples do not expose total allocation count; sample count is not object count.​; head:​ V8 samples do not expose total allocation count; sample count is not object count.​
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocated memory per operation (estimated) 10.49 KiB/op 10.13 KiB/op 3.4% less memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Time per operation 22.63 µs/op 21.08 µs/op 6.8% less time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Idle process memory (RSS) 102.4 MiB 102.52 MiB 0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 106.4 MiB 106.55 MiB 0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Managed heap after settling 10.15 MiB 10.15 MiB <0.1% less memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 106.05 MiB 106.25 MiB 0.2% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process CPU time per operation 38.82 µs/op 36.06 µs/op 7.1% less time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 106.64 MiB 106.8 MiB 0.2% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocated memory per operation (estimated) 18.03 KiB/op 17.5 KiB/op 2.9% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Time per operation 36.73 µs/op 36.37 µs/op 1% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Idle process memory (RSS) 102.49 MiB 102.57 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 113.92 MiB 113.88 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Managed heap after settling 10.16 MiB 10.16 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 109.89 MiB 109.73 MiB 0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process CPU time per operation 53.22 µs/op 52.86 µs/op 0.7% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 116.26 MiB 116.11 MiB 0.1% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocated memory per operation (estimated) 10.01 KiB/op 9.66 KiB/op 3.5% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Time per operation 22.69 µs/op 21.91 µs/op 3.4% less time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Idle process memory (RSS) 102.71 MiB 102.74 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 107.25 MiB 106.97 MiB 0.3% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Managed heap after settling 10.23 MiB 10.23 MiB <0.1% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 107.31 MiB 107.04 MiB 0.3% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process CPU time per operation 40.06 µs/op 37.84 µs/op 5.6% less time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 107.25 MiB 107.11 MiB 0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocated memory per operation (estimated) 18.37 KiB/op 17.74 KiB/op 3.5% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Time per operation 33.21 µs/op 33.54 µs/op 1% more time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Idle process memory (RSS) 102.99 MiB 103.03 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 109.67 MiB 109.25 MiB 0.4% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Managed heap after settling 10.24 MiB 10.24 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 108.18 MiB 108.06 MiB 0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process CPU time per operation 50.29 µs/op 50.83 µs/op 1.1% more time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 109.68 MiB 109.26 MiB 0.4% less memory Not flagged
Queue an event (32-byte payload)
Shard: capture
Allocated memory per operation (estimated) 8.86 KiB/op 9.38 KiB/op 5.8% more memory Not flagged
Queue an event (32-byte payload)
Shard: capture
Time per operation 15.75 µs/op 15.49 µs/op 1.6% less time Not flagged
Queue an event (32-byte payload)
Shard: capture
Process CPU time per operation 30.14 µs/op 30.52 µs/op 1.3% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Allocated memory per operation (estimated) 8.99 KiB/op 8.89 KiB/op 1.1% less memory Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Time per operation 15.01 µs/op 15.54 µs/op 3.6% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Process CPU time per operation 28.73 µs/op 28.75 µs/op <0.1% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Allocated memory per operation (estimated) 131.93 KiB/op 132.07 KiB/op 0.1% more memory Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Time per operation 233.7 µs/op 234.93 µs/op 0.5% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Process CPU time per operation 396.37 µs/op 396.42 µs/op <0.1% more time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Allocated memory per operation (estimated) 1.22 MiB/op 1.22 MiB/op <0.1% less memory Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Time per operation 2.01 ms/op 2.01 ms/op 0.1% less time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Process CPU time per operation 3.38 ms/op 3.38 ms/op <0.1% less time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Allocated memory per operation (estimated) 12.16 MiB/op 12.12 MiB/op 0.3% less memory Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Time per operation 20.74 ms/op 20.93 ms/op 0.9% more time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Process CPU time per operation 33.3 ms/op 33.35 ms/op 0.1% more time Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Idle process memory (RSS) 286.33 MiB 286.43 MiB <0.1% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Observed peak process memory (RSS) 297.62 MiB 297.67 MiB <0.1% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Managed heap after settling 9.77 MiB 9.77 MiB <0.1% less memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Process memory after settling (RSS) 297.43 MiB 297.31 MiB <0.1% less memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Lifetime peak process memory (RSS) 298.15 MiB 297.98 MiB <0.1% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Idle process memory (RSS) 225.58 MiB 222.54 MiB 1.3% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Observed peak process memory (RSS) 239.54 MiB 238.61 MiB 0.4% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Managed heap after settling 11.8 MiB 11.8 MiB <0.1% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Process memory after settling (RSS) 234.71 MiB 234.36 MiB 0.1% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Lifetime peak process memory (RSS) 241.29 MiB 240.68 MiB 0.3% less memory Not flagged
Evaluate one boolean flag
Shard: flags-single
Allocated memory per operation (estimated) 17.2 KiB/op 17.1 KiB/op 0.6% less memory Not flagged
Evaluate one boolean flag
Shard: flags-single
Time per operation 64.52 µs/op 63.66 µs/op 1.3% less time Not flagged
Evaluate one boolean flag
Shard: flags-single
Process CPU time per operation 61.73 µs/op 59.37 µs/op 3.8% less time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Allocated memory per operation (estimated) 14.24 KiB/op 14.14 KiB/op 0.7% less memory Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Time per operation 35.78 µs/op 35.21 µs/op 1.6% less time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Process CPU time per operation 37.95 µs/op 37.33 µs/op 1.6% less time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Allocated memory per operation (estimated) 17.51 KiB/op 17.61 KiB/op 0.6% more memory Not flagged
Evaluate a flag (early match)
Shard: flags-single
Time per operation 35.91 µs/op 37 µs/op 3% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Process CPU time per operation 37.76 µs/op 37.71 µs/op 0.1% less time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Allocated memory per operation (estimated) 22.27 KiB/op 22.2 KiB/op 0.3% less memory Not flagged
Evaluate a flag (late match)
Shard: flags-single
Time per operation 37.16 µs/op 37.08 µs/op 0.2% less time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Process CPU time per operation 38.38 µs/op 37.67 µs/op 1.9% less time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Allocated memory per operation (estimated) 17.08 KiB/op 16.91 KiB/op 1% less memory Not flagged
Evaluate a flag (no match)
Shard: flags-single
Time per operation 4.27 µs/op 4.35 µs/op 1.8% more time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Process CPU time per operation 8.11 µs/op 8.14 µs/op 0.4% more time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Allocated memory per operation (estimated) 12.64 KiB/op 12.64 KiB/op <0.1% more memory Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Time per operation 35.36 µs/op 34.62 µs/op 2.1% less time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Process CPU time per operation 35.42 µs/op 36.07 µs/op 1.8% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Allocated memory per operation (estimated) 18.19 KiB/op 18.21 KiB/op <0.1% more memory Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Time per operation 67.83 µs/op 67.38 µs/op 0.7% less time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Process CPU time per operation 64.59 µs/op 65.12 µs/op 0.8% more time Not flagged
Evaluate a rollout flag
Shard: flags-single
Allocated memory per operation (estimated) 14.26 KiB/op 14.2 KiB/op 0.5% less memory Not flagged
Evaluate a rollout flag
Shard: flags-single
Time per operation 49.12 µs/op 49.77 µs/op 1.3% more time Not flagged
Evaluate a rollout flag
Shard: flags-single
Process CPU time per operation 47.14 µs/op 48.52 µs/op 2.9% more time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Allocated memory per operation (estimated) 17.44 KiB/op 17.38 KiB/op 0.3% less memory Not flagged
Evaluate a multivariate flag
Shard: flags-single
Time per operation 66.15 µs/op 66.29 µs/op 0.2% more time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Process CPU time per operation 61.5 µs/op 63.25 µs/op 2.8% more time Not flagged

Values are medians of paired measurements. Not flagged does not mean unchanged. Unavailable means a measurement could not be provided, not zero. Estimated allocation measurements retain their instrumentation uncertainty. RSS measures the whole process, not just SDK allocations; observed peaks are sampled checkpoints. Paired ranges in the diagnostics describe variability, not confidence intervals.

Each shard uses its own runner; compare Before PR against With PR within a row, not across shards.

Compared 8a7e4c820fd880ed34b24a1af16d4cb83a161190 → c95a41633ede74166a9c6dec86e34c2986652ecf.

Full report and diagnostics

102 metric rows; 102 rows shown in all results. Omitted or shortened data remain in comparison.json, including per-runner environments, resource limits, measurement methods, samples and checkpoints.

@marandaneto
marandaneto added this pull request to the merge queue Nov 16, 2026
Merged via the queue into main with commit 89d7726 Nov 16, 2026
77 checks passed
@marandaneto
marandaneto deleted the fix/docusaurus-republish-2.0.7 branch November 16, 2026 20:41
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants