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-
requireguard 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
requiremust 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/internalreplacement 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
| Trigger | Consequence | Guard |
|---|---|---|
| A package target omits a compile or registry dependency | A sandbox can start with missing or stale workspace packages | Keep the Nx target chain aligned with the task dependencies in nx.json |
| A generated sandbox project is stale after its template changes | CI can skip a supported check or run a check that the template cannot support | Regenerate project definitions from the template metadata |
| Sandbox preparation does not add the stories or framework settings required by a template | A supported sandbox can fail during startup or miss the product behavior it should validate | Keep template-specific preparation aligned with its framework, builder, stories, and check targets |
| A package check exceeds the compiler time limit or exhausts its output buffer | CI reports a compiler failure without a normal type diagnostic | The package checker has a per-package timeout and bounded diagnostic output |
| A package build publishes an export that has no matching generated file | Consumers fail when they resolve the package subpath or its types | Keep build entries, generated exports, and distribution outputs aligned |
| Declaration output depends on concurrent module load order | Repeated builds can produce different type files and unstable package diffs | Emit package declarations as one package-wide pass before bundling |
| A declaration resolver misses a type fallback or applies the wrong external boundary | Published declarations keep an invalid or unavailable import | Keep the resolver mode and package matcher aligned with the package dependency contract |
A browser bundle leaves a dynamic require call for an external module | Browser ESM output fails at runtime | Keep 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 bridge | The Node ESM output fails when it loads a bundled CommonJS dependency | Apply the bridge only to outputs that contain esbuild's CommonJS helper and test hashbang files |
| CI executor capacity changes without a matching compile limit | Compile work can contend for resources or leave CI capacity unused | Keep the explicit CI parallelism value aligned with the executor size |
| A docgen module reads a TypeScript 7.1-only node field directly | The other TypeScript backend can fail or produce incomplete metadata | Route native-only fields through the DocgenTypeScript accessor contract |
A package keeps a static @storybook/core/ import | The package lint check fails or the import points at an unsupported source path | Use the storybook/internal path or apply the rule's autofix |
| Root and workspace tests resolve different Vitest versions | A test can pass locally and fail in CI because the runner behavior differs | Keep the root Vitest pin, workspace versions, and lock state aligned |
| Node 26 runs a sandbox without the pinned Yarn toolchain | Sandbox setup can use the wrong package manager and hang or install the wrong dependencies | Install and enable Corepack before the smoke workflow runs |
| A release version is already present on npm | A second publish can fail or corrupt release bookkeeping | The publish flow checks the registry first and treats already visible packages as complete |
| A patch cherry-pick conflicts | The release PR can omit a change unless a maintainer acts | The patch tool aborts the failed pick and adds a manual cherry-pick task to the PR description |
| Release bookkeeping loses GitHub or external-service permission | Packages may be published while the GitHub release, patch labels, or deployment record is incomplete | The 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 local | Affected CI can skip checks that depend on shared setup or fixed data | Keep the global-input and fixture rules aligned with the files that affect many projects |
| Focus selection misses a package role or shared story path | CI can validate the wrong sandbox set and miss a framework-specific regression | Keep role priority, template metadata, and sibling selection aligned |
| A sandbox cache contains stale dependency state or loses required workspace files | Later sandbox checks can fail before Storybook starts | Rebuild the prepared sandbox and keep dependency folders outside the Nx cache contract |
| A dependency or sandbox archive omits a workspace with nested dependencies | Downstream checks fail when they resolve packages that were installed only in that workspace | Pack root, hoisted, and nested workspace dependency trees before downstream jobs attach the workspace |
| An untrusted actor can trigger Claude automation | Repository or CI data can be exposed through an assistant run | Require trusted author association and the explicit review or mention trigger |
Key files
| File | Why to read it |
|---|---|
| package.json | Defines the workspace boundary, including ecosystem quality checks, the package manager, root commands, and pinned test tooling that expose repository automation. |
| nx.json | Defines the shared project targets, dependency order, cache model, and sandbox-to-test progression. |
| scripts/task.ts | Defines the common task model, readiness rules, dependency scheduling, service handling, and CI result output. |
| scripts/package.json | Shows the public command surface for checks, sandboxes, local publishing, and releases. |
| scripts/…/main.ts | Shows how selected workflows become a dependency-aware CircleCI configuration with merge and nightly reporting. |
| scripts/…/common-jobs.ts | Defines shared CI builds, focused validation, workspace transfer for nested dependencies, runtime checks, sandbox smoke runs, quality gates, and performance jobs. |
| scripts/…/helpers.ts | Defines shared CI workspace transfer, dependency cache, archive, checkout, and restore steps. |
| scripts/…/focus.ts | Defines changed-file based sandbox and job selection for focused CI runs. |
| scripts/…/focus.test.ts | Protects the mapping from changed packages and paths to focused jobs, sandbox coverage, and full-check fallbacks. |
| scripts/…/global-inputs.test.ts | Shows the contract for files that widen affected validation and for test fixtures. |
| scripts/create-nx-sandbox-projects.ts | Shows how template metadata becomes Nx sandbox projects and CI groups. |
| scripts/build-package.ts | Shows how engineers select buildable packages and run local or production builds. |
| scripts/…/build-package.ts | Shows the lifecycle that turns one package's build configuration into bundles, exports, and type output. |
| scripts/…/entry-utils.ts | Defines the package entry contract and the dependency boundaries used by JavaScript and type builds. |
| scripts/…/generate-bundle.ts | Enforces browser-safe external handling and coordinates the JavaScript bundle variants. |
| scripts/…/cjs-require-plugin.ts | Adds the Node-only CommonJS bridge only when a generated bundle needs it. |
| scripts/…/cjs-require-plugin.test.ts | Protects Node CommonJS execution, hashbang placement, and the no-op path for comments and strings. |
| scripts/…/generate-bundle.test.ts | Protects the browser bundle rule for dynamic require calls across both bundle engines. |
| scripts/…/use-sync-external-store-shim.ts | Provides the browser-safe React export used when a dependency needs the external-store backfill. |
| scripts/…/generate-package-json.ts | Shows how configured entry points become the package export map. |
| scripts/…/generate-types-rolldown.ts | Defines deterministic declaration generation, TypeScript 7 support, resolver behavior, and portable type outputs. |
| scripts/…/docgen-node-fields-through-contract.js | Enforces the cross-version docgen contract for TypeScript-native AST fields. |
| scripts/…/docgen-node-fields-through-contract.test.ts | Protects the lint rule that keeps native-only docgen fields behind the shared accessor. |
| scripts/…/storybook-monorepo-imports.js | Enforces the internal import path contract for static monorepo imports. |
| scripts/…/tools.ts | Provides shared build helpers and tool bindings used by repository scripts. |
| scripts/…/compile.ts | Shows how repository compilation is delegated to Nx and tuned for CI resources. |
| scripts/…/check.ts | Shows how package validation is grouped, ordered, and bounded for CI. |
| scripts/…/sandbox.ts | Shows how repository output becomes a prepared framework sandbox and an Nx cache entry. |
| scripts/…/sandbox-parts.ts | Shows how sandbox creation adds framework-specific setup, shared stories, configuration, dependencies, and test preparation. |
| scripts/…/version.ts | Defines full and deferred version changes across the package set. |
| scripts/…/publish.ts | Defines registry-aware package publishing and retry behavior. |
| .github/…/action.yml | Defines shared Node, Yarn cache, and dependency setup for GitHub Actions. |
| .github/…/claude-code-review.yml | Defines the trusted, label-gated Claude pull-request review flow. |
| .github/…/claude.yml | Defines trusted event triggers and command limits for interactive Claude assistance. |
| .github/…/prepare-patch-release.yml | Defines patch carryover and release pull request preparation. |
| .github/…/prepare-non-patch-release.yml | Defines prerelease, patch, minor, and major preparation. |
| .github/…/publish.yml | Defines the publish, GitHub release, branch merge, and post-release bookkeeping flow. |
| .github/…/nx.yml | Defines Nx CI task selection, distribution, and GitHub status reporting. |