Introducing a new way to review your PRs.

Read the announcement

storybookjs / storybook

Storybook is the industry standard workshop for building, documenting, and testing UI components in isolation

View on GitHub

20 documents · Updated Nov 20, 2026

docs / repository-automation

Repository automation and release tooling

Repository automation coordinates the Storybook monorepo from source changes to validated packages, test sandboxes, and published releases. It joins Yarn workspaces, Nx task graphs, shared scripts, CI helpers, and release tools so local work and CI use the same broad paths. This page is a child of Developer workflows and relates to Project setup and migration, Testing fixtures and sandboxes, Agent evaluation platform, and Ecosystem quality assurance.

Automation model

The repository uses the @storybook/scripts workspace as a control layer. Root commands delegate to this workspace, while Nx supplies dependency order, caching, and project-wide task selection. The result is one task model that can build packages, check them, prepare a local package registry, and drive sandbox-based tests.

Workspace boundaries

The root workspace covers the code packages, framework and renderer packages, libraries, addons, evaluation work, ecosystem quality checks, and the scripts workspace. The scripts workspace stays private because it supports repository work rather than product use. Yarn 4.18 provides the shared package-manager contract, while root commands expose task execution, package checks, sandbox generation, local publishing, and release actions. References: package.json• L4-18, package.json• L20-42, package.json• L79-94, scripts/package.json• L1-47

Task coordination

The task runner presents repository tasks and sandbox tasks through one command. It resolves prerequisites in dependency order, skips work that is already ready, keeps service tasks alive for later work, and can emit JUnit results for CI. Nx calls the same task runner for template-based work, so a package build or check can lead into a registry-backed sandbox flow without a second orchestration model. References: scripts/task.ts• L58-105, scripts/task.ts• L280-339, scripts/task.ts• L411-472, nx.json• L51-120

Nx workspace

Nx describes the repository as a graph of projects and targets. Target defaults connect package compilation and checks to their dependencies, then connect publishing, registry startup, sandbox creation, builds, serving, visual, integration, and end-to-end work into a usable progression.

Target graph

The main path moves from package compilation to package checks and local publishing. Sandbox work then starts the internal registry, creates or reuses a project template, and runs build, serving, visual, integration, or end-to-end work against that project. Nx marks cacheable outputs and knows which source groups invalidate those results. References: nx.json• L24-78, nx.json• L80-160, nx.json• L163-180

Generated sandbox project definitions connect each template to its framework, CI group, and supported validation targets. This keeps the Nx graph aligned with the template set instead of maintaining a separate project description for every sandbox. References: scripts/create-nx-sandbox-projects.ts• L10-66, scripts/create-nx-sandbox-projects.ts• L67-89

The following diagram shows the main repository-to-sandbox path.

flowchart LR
  Source[Workspace source] --> Compile[Compile packages]
  Compile --> Check[Check packages]
  Compile --> Publish[Publish to local registry]
  Publish --> Registry[Run local registry]
  Registry --> Sandbox[Create sandbox]
  Sandbox --> Verify[Build or test sandbox]

CI selection

The Nx workflow selects task groups by CI label or branch context. It can distribute work through Nx Cloud and reports both an overall result and task-level failures back to GitHub. In the current repository state, automatic triggers for this workflow are disabled because the Nx Cloud license has expired; it remains manually dispatchable. References: .github/…/nx.yml• L1-16, .github/…/nx.yml• L17-31, .github/…/nx.yml• L58-70, .github/…/nx.yml• L93-103, .github/…/nx.yml• L105-161

Affected validation

Affected validation narrows pull-request work without removing the baseline build. It carries the changed file set into related type checks and unit tests, checks changed files for format and lint, and selects representative sandboxes for the changed framework, renderer, builder, or shared dependency. Configuration and other global inputs widen the work back to the full check where a file-level view is unsafe.

Global inputs and test fixtures widen this selection because they can affect work across package boundaries. Focused sandboxes also add Chromatic siblings and path-triggered jobs when shared stories, internal Storybook paths, initialization paths, or special test areas change. The focus tests protect the rule that each affected workspace reaches a suitable normal sandbox while internal, prerelease, and nightly-only work stays out of focused runs. References: scripts/…/focus.ts• L27-35, scripts/…/focus.ts• L62-109, scripts/…/focus.ts• L112-180, scripts/…/focus.ts• L190-209, scripts/…/common-jobs.ts• L440-583, scripts/…/focus.test.ts• L57-107, scripts/…/focus.test.ts• L146-221, scripts/…/global-inputs.test.ts• L5-53

The affected unit-test job does not run ecosystem quality checks because that workspace has its own dependency setup. This keeps focused validation from using the root dependency tree for a workspace with nested dependencies. References: scripts/…/common-jobs.ts• L559-586

Package lifecycle

Package automation turns workspace source into distributable packages, checks package types, and publishes only the packages that a registry does not already contain. These steps protect the public package set while keeping local sandbox work close to the release path.

Package compilation

Package compilation uses a package-owned build-config.ts to describe the public entry points and platform targets. The build command can select named packages or all buildable packages, while Nx runs package compilation in dependency order and caches its output. A production build creates JavaScript bundles, package export metadata, and declaration files; watch builds focus on fast bundle updates and type mappers. References: scripts/build-package.ts• L28-34, scripts/build-package.ts• L64-83, scripts/build-package.ts• L110-125, scripts/…/build-package.ts• L57-125, scripts/…/entry-utils.ts• L7-25

The build keeps the package contract aligned with the generated files. Each configured entry can expose a package subpath, declare its type surface, and set the dependencies that remain outside the bundle. Production declaration output supports both the standard TypeScript API and the native TypeScript 7 compiler, then bundles declarations with a resolver that preserves the package's external boundary. Shared entries can use common type chunks, while portable entries produce a self-contained type surface. References: scripts/…/entry-utils.ts• L31-65, scripts/…/generate-package-json.ts• L8-40, scripts/…/generate-types-rolldown.ts• L257-369, scripts/…/generate-types-rolldown.ts• L388-499, scripts/…/generate-types-rolldown.ts• L518-585

Declaration generation emits a package-wide type view before bundling. This makes output stable across runs and lets the resolver handle common type-package fallbacks and package-specific declaration transforms without changing the public package contract. References: scripts/…/generate-types-rolldown.ts• L55-63, scripts/…/generate-types-rolldown.ts• L163-201, scripts/…/generate-types-rolldown.ts• L256-301, scripts/…/generate-types-rolldown.ts• L418-465

Browser and Node bundle safety are part of the package contract. The build rejects dynamic require calls that target external modules because those calls fail in browser ESM output. It also aliases the React external-store backfill to a small ES module so packages that use it can keep a browser-safe bundle. Node outputs receive a require bridge only when the bundle needs esbuild's CommonJS helper. This keeps CommonJS dependencies working without adding Node-only module metadata to browser or worker outputs, and it keeps a hashbang at the start of executable files. References: scripts/…/generate-bundle.ts• L49-87, scripts/…/generate-bundle.ts• L303-363, scripts/…/cjs-require-plugin.ts• L6-28, scripts/…/cjs-require-plugin.test.ts• L43-65, scripts/…/use-sync-external-store-shim.ts• L1-3, scripts/…/generate-bundle.test.ts• L45-85

The shared compile task is the entry point that turns this package build into a monorepo operation. It waits for dependency installation, uses different Nx modes for linked and production work, and limits CI parallelism to the executor capacity. CI can skip the Nx cache when the run measures task cost rather than cache reuse. References: scripts/…/compile.ts• L9-19, scripts/…/compile.ts• L20-50

Package checks

Package checks validate the source through the package's TypeScript settings and any strict type-test settings. The shared check task runs packages in parallel with bounded concurrency and uses framework-aware checks where plain TypeScript cannot read a package's source format. CI uses a fixed four-package pool because the native compiler also uses several threads; heavy workspaces start first to reduce the final wait. It reports failures by package so CI can identify the affected workspace. References: nx.json• L36-42, scripts/…/check.ts• L12-40, scripts/…/check.ts• L43-66, scripts/…/check.ts• L68-95, scripts/…/check-package.ts• L32-107

Repository lint rules also protect code that must run with more than one TypeScript backend. The docgen rule blocks direct reads of fields that exist only in TypeScript 7.1 and requires access through the shared docgen contract, so the backend keeps ownership of version-specific AST details. The monorepo import rule rejects static imports from @storybook/core/ and offers an autofix to storybook/internal, so package code uses the supported internal path. Root test commands use Vitest 5.0.5 as a fixed runner version for consistent local and CI behavior. References: scripts/…/docgen-node-fields-through-contract.js• L3-25, scripts/…/docgen-node-fields-through-contract.js• L28-51, scripts/…/storybook-monorepo-imports.js• L5-29, package.json• L20-42

Local registry

The local registry provides a private package boundary for sandbox tests. The publish task builds the packages and places them in a Verdaccio-backed cache, then the registry task starts the package servers and waits for both endpoints before dependent sandbox tasks continue. References: nx.json• L43-63, scripts/…/publish.ts• L19-35, scripts/…/run-registry.ts• L8-43

Sandbox validation

Sandbox automation creates a representative Storybook project from a framework template, installs the built packages, applies the template setup, and prepares it for later checks. It supports linked local packages for development and registry-backed packages for release-like validation.

The sandbox task runs creation, dependency installation, initialization, story and mock setup, test setup, and configuration changes as one preparation flow. It adapts the project for the selected framework and builder, adds the stories and preview settings needed for shared fixtures, and prepares type and Vitest checks when the template supports them. It reinstalls and deduplicates dependencies before later checks. Under Nx, the prepared project moves to a cacheable location without installed dependencies, while Yarn retains the dependency data separately. References: scripts/…/sandbox.ts• L42-79, scripts/…/sandbox.ts• L83-104, scripts/…/sandbox.ts• L135-217, scripts/…/sandbox.ts• L219-250, scripts/…/sandbox-parts.ts• L229-382, scripts/…/sandbox-parts.ts• L572-649, scripts/…/sandbox-parts.ts• L721-1070, scripts/…/sandbox-parts.ts• L1233-1359

The generated Nx projects expose only the checks that each template supports. Template metadata also places projects in normal or daily CI groups, so the same source controls both sandbox behavior and CI selection. References: scripts/create-nx-sandbox-projects.ts• L10-66, scripts/create-nx-sandbox-projects.ts• L67-89

The following diagram shows how a template becomes a validation project.

flowchart TD
  Template[Framework template] --> Create[Create project]
  Create --> Install[Install linked or registry packages]
  Install --> Prepare[Apply stories and framework setup]
  Prepare --> Configure[Configure checks and fixtures]
  Configure --> Validate[Run supported validation targets]

CI support

GitHub Actions and CircleCI share repository task definitions but serve different coordination needs. GitHub Actions runs Nx task groups and reports statuses, while the CI script generates the broader CircleCI workflow configuration used by the repository's job set.

Dependency setup

The shared setup action reads the repository Node version, restores the Yarn cache, installs script dependencies, and optionally installs code dependencies. It separates cache restore from cache save so untrusted pull-request jobs cannot write to the shared cache. References: .github/…/action.yml• L1-12, .github/…/action.yml• L13-52

Shared job definitions

Shared CI jobs turn the task model into repeatable Linux and Windows builds, package checks, unit and story tests, internal Storybook checks, sandbox smoke checks, and performance gates. The build job also passes compiled packages, the local registry state, and required dependency trees to later jobs. It packs nested dependency trees for agent-eval and ecosystem quality checks into the pipeline workspace, because those workspaces do not use the root hoisted tree. Large dependency and sandbox trees move through the pipeline as compressed archives, and downstream jobs unpack those archives instead of depending on an unrelated restored tree. Cache writes remain limited to trusted authors, while pipeline-scoped workspace data keeps fork runs complete. References: scripts/…/common-jobs.ts• L28-95, scripts/…/common-jobs.ts• L121-146, scripts/…/common-jobs.ts• L257-337, scripts/…/common-jobs.ts• L365-408, scripts/…/common-jobs.ts• L413-438, scripts/…/helpers.ts• L22-43, scripts/…/helpers.ts• L61-170

Focused job definitions

Focused CI jobs use the changed-file set to limit type checks, lint, format checks, and related unit tests. A global input or tool configuration change switches the appropriate checks back to the full scope. The jobs use the restored compiled workspace so affected checks can focus on validation rather than rebuild work. References: scripts/…/common-jobs.ts• L440-583, scripts/…/focus.ts• L190-209

Runtime and quality gates

The CI matrix checks both the main Node runtime and selected newer runtime paths. A Node 26 smoke job verifies unit behavior and representative Vite and Webpack sandboxes after installing the package manager explicitly. Separate docgen gates check memory use, performance budgets, and native TypeScript fixtures, while package benchmarks compare release-relevant work against the base branch. References: scripts/…/common-jobs.ts• L365-408, scripts/…/common-jobs.ts• L690-784

CircleCI configuration

CircleCI configuration is generated from selected workflow names rather than maintained as one large hand-written job list. The generator resolves the jobs and their required dependencies, adds one completion status for merge-gating workflows, and keeps nightly runs going long enough to report all failures. It writes the resulting configuration to the generated CircleCI file. References: scripts/…/main.ts• L17-30, scripts/…/main.ts• L52-68, scripts/…/main.ts• L83-122, scripts/…/main.ts• L125-151

CI task reports

The task runner can write JUnit output for task and sandbox runs. Nx also converts failed task output into GitHub commit statuses and links those statuses to Nx Cloud logs when available. Together these reports connect a failed check to both the repository task and its execution log. References: scripts/task.ts• L224-271, scripts/task.ts• L387-405, .github/…/nx.yml• L105-161

Claude automation

Claude Code automation gives trusted repository members an on-demand review and task assistant through GitHub events. Pull-request review runs require a trusted author and an explicit claude-review label; interactive runs require a trusted event author who mentions Claude or assigns the Claude actor. The workflow grants read access to repository and CI data and limits the assistant to approved repository commands, while blocking long-running development servers. References: .github/…/claude-code-review.yml• L1-35, .github/…/claude.yml• L1-68

Release automation

Release automation turns changes on the release branches into versioned packages and GitHub releases. It separates release preparation from publishing so maintainers can review the change list, version choice, and patch handling before a publish job changes external registries.

Release preparation

Patch preparation starts from main, finds patch changes that have not yet been carried across, and prepares a release pull request against latest-release. Non-patch preparation starts from next and supports prerelease, patch, minor, and major version choices for a pull request against next-release. Both paths can stop when releases are frozen or when no release work is needed. References: .github/…/prepare-patch-release.yml• L20-33, .github/…/prepare-patch-release.yml• L44-121, .github/…/prepare-patch-release.yml• L151-196, .github/…/prepare-non-patch-release.yml• L38-51, .github/…/prepare-non-patch-release.yml• L65-120, .github/…/prepare-non-patch-release.yml• L147-176

Version and changelog state

Version tooling can apply a full version change or record a deferred version in code/package.json. Deferred changes let preparation create and review release content before the publish workflow applies the version to all packages and shared version sources. Changelog tooling derives entries from merged changes and writes prerelease or stable entries to the matching changelog file. References: scripts/…/version.ts• L16-36, scripts/…/version.ts• L188-235, scripts/…/version.ts• L290-315, scripts/…/write-changelog.ts• L12-28, scripts/…/write-changelog.ts• L59-104

Patch carryover

Patch tooling finds patch pull requests on next that are not yet marked as picked, cherry-picks them to the release branch, and records conflicts for manual action. The generated release description includes the change list and any manual cherry-pick work so review does not hide an incomplete carryover. References: scripts/…/pick-patches.ts• L12-18, scripts/…/pick-patches.ts• L34-85, scripts/…/generate-pr-description.ts• L90-119, scripts/…/generate-pr-description.ts• L122-187

Package publishing

The publish workflow applies any deferred version, checks whether that version already exists, builds the packages, and publishes them with an explicit latest or next tag. The publishing utility checks the registry before and during the operation, waits for staged packages to become visible, and retries only packages that remain missing. This makes a partial registry response recoverable without republishing packages that are already accepted. References: .github/…/publish.yml• L29-117, .github/…/publish.yml• L225-295, scripts/…/publish.ts• L20-39, scripts/…/publish.ts• L69-81, scripts/…/publish.ts• L92-197, scripts/…/publish.ts• L200-235

Release bookkeeping

After publication, automation creates the GitHub release, merges the release branch into its target, updates the main changelog path when needed, and records release data in connected services. Patch releases also mark included patch pull requests as complete, while failures in post-publish bookkeeping are reported separately so they do not falsely turn a successful package publish into a failed release. References: .github/…/publish.yml• L119-223, .github/…/publish.yml• L225-321

Change checklist

When these files or sections are changed, remember to consider these:

  • When changing an Nx target, update its dependency chain, cache inputs, and declared outputs together. A stale output can make later sandbox or test work use old packages.
  • When changing package build or check rules, check both the root Nx target and the scripts task. CI can call either path.
  • When changing package compilation, keep the CI parallelism setting aligned with the executor capacity and review whether CI should use the Nx cache.
  • When changing declaration generation, keep the standard and native TypeScript paths aligned with the resolver choice, package external boundary, and deterministic output contract.
  • When changing browser bundle externals or aliases, preserve the dynamic-require guard and the external-store shim so browser output remains valid across both bundle engines.
  • When changing Node bundle output, preserve the conditional CommonJS bridge and its hashbang handling. Outputs that do not need require must remain free of Node-only module metadata.
  • When changing sandbox templates, regenerate their Nx project definitions so supported targets, framework links, and CI tags stay current.
  • When changing sandbox preparation stages, keep framework setup, shared stories, preview configuration, and supported test targets aligned with each template.
  • When changing a package build entry, keep its export map, JavaScript output, declaration output, and external dependency boundary aligned.
  • When changing declaration bundling, preserve the resolver choice and the portable-entry external allowlist. These define what downstream consumers can resolve from the published type surface.
  • When changing the docgen TypeScript contract, update the accessor rule and the native TypeScript fixture gate together. Direct native-only field access can break the other backend.
  • When changing the monorepo import rule, keep its storybook/internal replacement target aligned with the package import contract.
  • When changing the root Vitest version, keep the fixed runner version aligned with workspace dependencies and the Yarn lock state.
  • When changing the Node 26 smoke job, preserve its package-manager bootstrap and its exclusions for projects that need the default Node runtime.
  • When adding or changing a workspace with nested dependencies, include its dependency tree in the pipeline workspace and keep its focused-test workflow from using an incompatible root tree.
  • When changing release version state, preserve the contract between deferredNextVersion, workflow outputs, package versions, source version constants, and the lockfile.
  • When changing release branch or label rules, update both the preparation workflow and the generated release description. They must agree on which changes are included and which branch receives them.
  • When changing publish retry behavior, keep the npm distribution tag and registry visibility checks aligned. A package can be accepted by npm before it appears in a later registry query.
  • When changing global-input or fixture classification, check that affected checks widen when needed and that ordinary source changes still use focused validation.
  • When changing focus roles or sandbox metadata, preserve the priority match and Chromatic sibling coverage so a package change reaches a representative template.
  • When changing shared CI artifacts or dependency caches, keep producer paths, consumer paths, and trusted-author cache rules aligned across operating systems.
  • When changing workspace archive or cache helpers, keep pack, wait, unpack, and platform-specific paths aligned. A downstream job must receive the exact dependency tree and sandbox state produced by its upstream job.
  • When changing Claude triggers or permissions, keep trusted-author checks, read scopes, and blocked long-running commands aligned.

Important failure modes

TriggerConsequenceGuard
A package target omits a compile or registry dependencyA sandbox can start with missing or stale workspace packagesKeep the Nx target chain aligned with the task dependencies in nx.json
A generated sandbox project is stale after its template changesCI can skip a supported check or run a check that the template cannot supportRegenerate project definitions from the template metadata
Sandbox preparation does not add the stories or framework settings required by a templateA supported sandbox can fail during startup or miss the product behavior it should validateKeep template-specific preparation aligned with its framework, builder, stories, and check targets
A package check exceeds the compiler time limit or exhausts its output bufferCI reports a compiler failure without a normal type diagnosticThe package checker has a per-package timeout and bounded diagnostic output
A package build publishes an export that has no matching generated fileConsumers fail when they resolve the package subpath or its typesKeep build entries, generated exports, and distribution outputs aligned
Declaration output depends on concurrent module load orderRepeated builds can produce different type files and unstable package diffsEmit package declarations as one package-wide pass before bundling
A declaration resolver misses a type fallback or applies the wrong external boundaryPublished declarations keep an invalid or unavailable importKeep the resolver mode and package matcher aligned with the package dependency contract
A browser bundle leaves a dynamic require call for an external moduleBrowser ESM output fails at runtimeKeep the browser guard active and use an ES module alias when a dependency needs a backfill
A Node bundle needs CommonJS but has no require bridgeThe Node ESM output fails when it loads a bundled CommonJS dependencyApply the bridge only to outputs that contain esbuild's CommonJS helper and test hashbang files
CI executor capacity changes without a matching compile limitCompile work can contend for resources or leave CI capacity unusedKeep the explicit CI parallelism value aligned with the executor size
A docgen module reads a TypeScript 7.1-only node field directlyThe other TypeScript backend can fail or produce incomplete metadataRoute native-only fields through the DocgenTypeScript accessor contract
A package keeps a static @storybook/core/ importThe package lint check fails or the import points at an unsupported source pathUse the storybook/internal path or apply the rule's autofix
Root and workspace tests resolve different Vitest versionsA test can pass locally and fail in CI because the runner behavior differsKeep the root Vitest pin, workspace versions, and lock state aligned
Node 26 runs a sandbox without the pinned Yarn toolchainSandbox setup can use the wrong package manager and hang or install the wrong dependenciesInstall and enable Corepack before the smoke workflow runs
A release version is already present on npmA second publish can fail or corrupt release bookkeepingThe publish flow checks the registry first and treats already visible packages as complete
A patch cherry-pick conflictsThe release PR can omit a change unless a maintainer actsThe patch tool aborts the failed pick and adds a manual cherry-pick task to the PR description
Release bookkeeping loses GitHub or external-service permissionPackages may be published while the GitHub release, patch labels, or deployment record is incompleteThe workflow gives each step the required permission and sends a separate failure alert for post-publish work
A changed global input or fixture is classified as localAffected CI can skip checks that depend on shared setup or fixed dataKeep the global-input and fixture rules aligned with the files that affect many projects
Focus selection misses a package role or shared story pathCI can validate the wrong sandbox set and miss a framework-specific regressionKeep role priority, template metadata, and sibling selection aligned
A sandbox cache contains stale dependency state or loses required workspace filesLater sandbox checks can fail before Storybook startsRebuild the prepared sandbox and keep dependency folders outside the Nx cache contract
A dependency or sandbox archive omits a workspace with nested dependenciesDownstream checks fail when they resolve packages that were installed only in that workspacePack root, hoisted, and nested workspace dependency trees before downstream jobs attach the workspace
An untrusted actor can trigger Claude automationRepository or CI data can be exposed through an assistant runRequire trusted author association and the explicit review or mention trigger

Key files

FileWhy to read it
package.jsonDefines the workspace boundary, including ecosystem quality checks, the package manager, root commands, and pinned test tooling that expose repository automation.
nx.jsonDefines the shared project targets, dependency order, cache model, and sandbox-to-test progression.
scripts/task.tsDefines the common task model, readiness rules, dependency scheduling, service handling, and CI result output.
scripts/package.jsonShows the public command surface for checks, sandboxes, local publishing, and releases.
scripts/…/main.tsShows how selected workflows become a dependency-aware CircleCI configuration with merge and nightly reporting.
scripts/…/common-jobs.tsDefines shared CI builds, focused validation, workspace transfer for nested dependencies, runtime checks, sandbox smoke runs, quality gates, and performance jobs.
scripts/…/helpers.tsDefines shared CI workspace transfer, dependency cache, archive, checkout, and restore steps.
scripts/…/focus.tsDefines changed-file based sandbox and job selection for focused CI runs.
scripts/…/focus.test.tsProtects the mapping from changed packages and paths to focused jobs, sandbox coverage, and full-check fallbacks.
scripts/…/global-inputs.test.tsShows the contract for files that widen affected validation and for test fixtures.
scripts/create-nx-sandbox-projects.tsShows how template metadata becomes Nx sandbox projects and CI groups.
scripts/build-package.tsShows how engineers select buildable packages and run local or production builds.
scripts/…/build-package.tsShows the lifecycle that turns one package's build configuration into bundles, exports, and type output.
scripts/…/entry-utils.tsDefines the package entry contract and the dependency boundaries used by JavaScript and type builds.
scripts/…/generate-bundle.tsEnforces browser-safe external handling and coordinates the JavaScript bundle variants.
scripts/…/cjs-require-plugin.tsAdds the Node-only CommonJS bridge only when a generated bundle needs it.
scripts/…/cjs-require-plugin.test.tsProtects Node CommonJS execution, hashbang placement, and the no-op path for comments and strings.
scripts/…/generate-bundle.test.tsProtects the browser bundle rule for dynamic require calls across both bundle engines.
scripts/…/use-sync-external-store-shim.tsProvides the browser-safe React export used when a dependency needs the external-store backfill.
scripts/…/generate-package-json.tsShows how configured entry points become the package export map.
scripts/…/generate-types-rolldown.tsDefines deterministic declaration generation, TypeScript 7 support, resolver behavior, and portable type outputs.
scripts/…/docgen-node-fields-through-contract.jsEnforces the cross-version docgen contract for TypeScript-native AST fields.
scripts/…/docgen-node-fields-through-contract.test.tsProtects the lint rule that keeps native-only docgen fields behind the shared accessor.
scripts/…/storybook-monorepo-imports.jsEnforces the internal import path contract for static monorepo imports.
scripts/…/tools.tsProvides shared build helpers and tool bindings used by repository scripts.
scripts/…/compile.tsShows how repository compilation is delegated to Nx and tuned for CI resources.
scripts/…/check.tsShows how package validation is grouped, ordered, and bounded for CI.
scripts/…/sandbox.tsShows how repository output becomes a prepared framework sandbox and an Nx cache entry.
scripts/…/sandbox-parts.tsShows how sandbox creation adds framework-specific setup, shared stories, configuration, dependencies, and test preparation.
scripts/…/version.tsDefines full and deferred version changes across the package set.
scripts/…/publish.tsDefines registry-aware package publishing and retry behavior.
.github/…/action.ymlDefines shared Node, Yarn cache, and dependency setup for GitHub Actions.
.github/…/claude-code-review.ymlDefines the trusted, label-gated Claude pull-request review flow.
.github/…/claude.ymlDefines trusted event triggers and command limits for interactive Claude assistance.
.github/…/prepare-patch-release.ymlDefines patch carryover and release pull request preparation.
.github/…/prepare-non-patch-release.ymlDefines prerelease, patch, minor, and major preparation.
.github/…/publish.ymlDefines the publish, GitHub release, branch merge, and post-release bookkeeping flow.
.github/…/nx.ymlDefines Nx CI task selection, distribution, and GitHub status reporting.