diff --git a/.github/workflows/integrate-develop.yml b/.github/workflows/integrate-develop.yml
new file mode 100644
index 0000000..0a506dd
--- /dev/null
+++ b/.github/workflows/integrate-develop.yml
@@ -0,0 +1,157 @@
+name: Integrate Develop to Staging
+
+on:
+  push:
+    branches:
+      - develop
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  create-or-update-pr:
+    name: Create or Update PR to Staging
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.10.0'
+
+      - name: Check for existing PR
+        id: check-pr
+        run: |
+          EXISTING_PR=$(gh pr list --base staging --head develop --json number --jq '.[0].number' || echo "")
+          
+          if [ -n "$EXISTING_PR" ]; then
+            echo "pr_exists=true" >> $GITHUB_OUTPUT
+            echo "pr_number=$EXISTING_PR" >> $GITHUB_OUTPUT
+            echo "Found existing PR #$EXISTING_PR"
+          else
+            echo "pr_exists=false" >> $GITHUB_OUTPUT
+            echo "No existing PR found"
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get commit information
+        id: commit-info
+        run: |
+          # Fetch staging branch
+          git fetch origin staging:staging || echo "Staging branch not found"
+          
+          # Get the latest commits from develop that aren't in staging
+          if git rev-parse --verify origin/staging >/dev/null 2>&1; then
+            COMMITS=$(git log --pretty=format:"- %s (%h)" origin/staging..HEAD | head -20)
+            COMMIT_COUNT=$(git rev-list --count origin/staging..HEAD)
+          else
+            COMMITS=$(git log --pretty=format:"- %s (%h)" HEAD | head -20)
+            COMMIT_COUNT=$(git rev-list --count HEAD)
+          fi
+          
+          # Escape for GitHub Actions output
+          COMMITS="${COMMITS//'%'/'%25'}"
+          COMMITS="${COMMITS//$'\n'/'%0A'}"
+          COMMITS="${COMMITS//$'\r'/'%0D'}"
+          
+          echo "commits<<EOF" >> $GITHUB_OUTPUT
+          echo "$COMMITS" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+          echo "commit_count=$COMMIT_COUNT" >> $GITHUB_OUTPUT
+          
+          # Get timestamp
+          TIMESTAMP=$(date -u +"%Y-%m-%d %H:%M:%S UTC")
+          echo "timestamp=$TIMESTAMP" >> $GITHUB_OUTPUT
+
+      - name: Create PR to staging
+        if: steps.check-pr.outputs.pr_exists == 'false'
+        run: |
+          COMMIT_COUNT="${{ steps.commit-info.outputs.commit_count }}"
+          TIMESTAMP="${{ steps.commit-info.outputs.timestamp }}"
+          
+          # Create PR body file
+          {
+            echo "## 🚀 Integration from develop to staging"
+            echo ""
+            echo "### 📊 Summary"
+            echo "- **Commits**: ${COMMIT_COUNT} new commits"
+            echo "- **Created**: ${TIMESTAMP}"
+            echo "- **Auto-generated**: This PR was automatically created by the integration workflow"
+            echo ""
+            echo "### 📝 Recent Commits"
+            echo "${{ steps.commit-info.outputs.commits }}"
+            echo ""
+            echo "### 🔍 What happens next?"
+            echo "1. Review the changes in this PR"
+            echo "2. Run any necessary QA tests"
+            echo "3. When approved and merged, the staging workflow will:"
+            echo "   - Check for changesets"
+            echo "   - If found, create beta releases"
+            echo "   - Automatically create a PR to main"
+            echo ""
+            echo "### ⚡ Notes"
+            echo "- This PR will be automatically updated with new commits to develop"
+            echo "- Multiple features can accumulate in this single PR"
+            echo "- Approval triggers the beta release process"
+          } > pr-body.md
+          
+          gh pr create \
+            --base staging \
+            --head develop \
+            --title "🔄 Integrate develop → staging" \
+            --body-file pr-body.md \
+            --label "auto-updated"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update existing PR
+        if: steps.check-pr.outputs.pr_exists == 'true'
+        run: |
+          PR_NUMBER="${{ steps.check-pr.outputs.pr_number }}"
+          COMMIT_COUNT="${{ steps.commit-info.outputs.commit_count }}"
+          TIMESTAMP="${{ steps.commit-info.outputs.timestamp }}"
+          COMMITS="${{ steps.commit-info.outputs.commits }}"
+          
+          # Update PR title with commit count
+          gh pr edit $PR_NUMBER \
+            --title "🔄 Integrate develop → staging (${COMMIT_COUNT} commits)"
+          
+          # Get current PR body
+          CURRENT_BODY=$(gh pr view $PR_NUMBER --json body --jq '.body')
+          
+          # Create updated section
+          UPDATED_SECTION="### 🔄 Last Updated: ${TIMESTAMP}\nNew commits: ${COMMIT_COUNT}\n\n### 📝 Recent Commits\n${COMMITS}"
+          
+          # Update or append the updated section
+          if echo "$CURRENT_BODY" | grep -q "### 🔄 Last Updated:"; then
+            # Replace existing update section
+            NEW_BODY=$(echo "$CURRENT_BODY" | sed '/### 🔄 Last Updated:/,/### 📝 Recent Commits/d' | sed '/^$/d')
+            NEW_BODY="$NEW_BODY\n\n$UPDATED_SECTION"
+          else
+            # Append update section
+            NEW_BODY="$CURRENT_BODY\n\n---\n\n$UPDATED_SECTION"
+          fi
+          
+          # Update PR body
+          echo "$NEW_BODY" > pr-body-update.md
+          gh pr edit $PR_NUMBER --body-file pr-body-update.md
+          
+          # Add labels
+          gh pr edit $PR_NUMBER \
+            --add-label "needs-review"
+          
+          # Set as ready for review
+          gh pr ready $PR_NUMBER || true
+          
+          echo "✅ Updated PR #${PR_NUMBER} with ${COMMIT_COUNT} new commits"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/.github/workflows/release-develop.yml b/.github/workflows/legacy/release-develop.yml.bak
similarity index 100%
rename from .github/workflows/release-develop.yml
rename to .github/workflows/legacy/release-develop.yml.bak
diff --git a/.github/workflows/release.yml b/.github/workflows/legacy/release.yml.bak
similarity index 100%
rename from .github/workflows/release.yml
rename to .github/workflows/legacy/release.yml.bak
diff --git a/.github/workflows/pr-check.yml b/.github/workflows/pr-check.yml
index 9c29efe..2bb2c91 100644
--- a/.github/workflows/pr-check.yml
+++ b/.github/workflows/pr-check.yml
@@ -5,6 +5,7 @@ on:
     branches:
       - main
       - develop
+      - staging
 
 jobs:
   lint-and-type-check:
diff --git a/.github/workflows/release-staging.yml b/.github/workflows/release-staging.yml
new file mode 100644
index 0000000..f5b2bac
--- /dev/null
+++ b/.github/workflows/release-staging.yml
@@ -0,0 +1,262 @@
+name: Release Staging (Beta)
+
+on:
+  push:
+    branches:
+      - staging
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  check-changesets:
+    name: Check for Changesets
+    runs-on: ubuntu-latest
+    outputs:
+      has_changesets: ${{ steps.check.outputs.has_changesets }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for changesets
+        id: check
+        run: |
+          if [ -d ".changeset" ] && [ "$(ls -A .changeset/*.md 2>/dev/null | grep -v README.md)" ]; then
+            echo "has_changesets=true" >> $GITHUB_OUTPUT
+            echo "✅ Found changesets to process"
+          else
+            echo "has_changesets=false" >> $GITHUB_OUTPUT
+            echo "⏭️ No changesets found, skipping release"
+          fi
+
+  release-beta:
+    name: Release Beta Versions
+    needs: check-changesets
+    if: needs.check-changesets.outputs.has_changesets == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.10.0'
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: latest
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Run quality checks
+        run: |
+          echo "Running type checks..."
+          pnpm typecheck
+          pnpm -r typecheck || true
+          
+          echo "Running linting..."
+          pnpm lint
+          pnpm -r lint || true
+
+      - name: Create beta versions
+        id: changesets
+        run: |
+          # Configure git
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          
+          # Run changesets version with beta
+          pnpm changeset version
+          
+          # Add beta suffix to all updated packages
+          TIMESTAMP=$(date +%s)
+          
+          # Update main package if version changed
+          if git diff --name-only | grep -q "^package.json$"; then
+            CURRENT_VERSION=$(node -p "require('./package.json').version")
+            BETA_VERSION="${CURRENT_VERSION}-beta.${TIMESTAMP}"
+            npm version $BETA_VERSION --no-git-tag-version
+            echo "Main package: $CURRENT_VERSION → $BETA_VERSION"
+          fi
+          
+          # Update sub-packages if versions changed
+          for pkg in packages/*/; do
+            if [ -d "$pkg" ] && git diff --name-only | grep -q "^$pkg"; then
+              cd "$pkg"
+              if git diff --name-only | grep -q "package.json"; then
+                CURRENT_VERSION=$(node -p "require('./package.json').version")
+                BETA_VERSION="${CURRENT_VERSION}-beta.${TIMESTAMP}"
+                npm version $BETA_VERSION --no-git-tag-version
+                PKG_NAME=$(basename "$pkg")
+                echo "$PKG_NAME: $CURRENT_VERSION → $BETA_VERSION"
+              fi
+              cd - > /dev/null
+            fi
+          done
+          
+          # Commit all changes
+          git add -A
+          git commit -m "chore: version packages for beta release" || echo "No changes to commit"
+
+      - name: Build packages
+        run: |
+          echo "Building all packages..."
+          pnpm build:all
+
+      - name: Publish beta packages
+        id: publish
+        run: |
+          # Publish with beta tag
+          RELEASE_TAG=beta node scripts/release-packages.cjs
+          
+          # Collect published versions
+          echo "published_versions<<EOF" >> $GITHUB_OUTPUT
+          echo "### Published Beta Versions" >> $GITHUB_OUTPUT
+          
+          # Check main package
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          echo "- vue-pivottable@$MAIN_VERSION" >> $GITHUB_OUTPUT
+          
+          # Check sub-packages
+          for pkg in packages/*/; do
+            if [ -d "$pkg" ] && [ -f "$pkg/package.json" ]; then
+              PKG_NAME=$(cd "$pkg" && node -p "require('./package.json').name")
+              PKG_VERSION=$(cd "$pkg" && node -p "require('./package.json').version")
+              echo "- $PKG_NAME@$PKG_VERSION" >> $GITHUB_OUTPUT
+            fi
+          done
+          echo "EOF" >> $GITHUB_OUTPUT
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN_SUMIN: ${{ secrets.NPM_TOKEN_SUMIN }}
+
+      - name: Push changes
+        run: |
+          git push origin staging
+
+      - name: Check for existing PR to main
+        id: check-pr
+        run: |
+          EXISTING_PR=$(gh pr list --base main --head staging --json number --jq '.[0].number' || echo "")
+          
+          if [ -n "$EXISTING_PR" ]; then
+            echo "pr_exists=true" >> $GITHUB_OUTPUT
+            echo "pr_number=$EXISTING_PR" >> $GITHUB_OUTPUT
+          else
+            echo "pr_exists=false" >> $GITHUB_OUTPUT
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create PR to main
+        if: steps.check-pr.outputs.pr_exists == 'false'
+        run: |
+          # Get the main package version for PR title
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          
+          gh pr create \
+            --base main \
+            --head staging \
+            --title "🚀 Release: Beta versions ready for production" \
+            --body "## 🎯 Beta Release Ready for Production
+
+${{ steps.publish.outputs.published_versions }}
+
+### 📋 What happens next?
+1. Review and test the beta versions
+2. When approved and merged, this will:
+   - Update package.json versions (remove beta suffix)
+   - Generate/update CHANGELOG.md files
+   - Sync changes back to develop and staging
+   - **Note**: npm publish happens only when you create a version tag
+
+### 🏷️ After merge:
+Create a version tag to trigger production release:
+\`\`\`bash
+git checkout main
+git pull origin main
+git tag v\${VERSION}
+git push origin v\${VERSION}
+\`\`\`
+
+### 📦 Install beta versions:
+\`\`\`bash
+npm install vue-pivottable@beta
+# or specific sub-packages
+npm install @vue-pivottable/plotly-renderer@beta
+npm install @vue-pivottable/lazy-table-renderer@beta
+\`\`\`
+
+---
+*This PR was automatically created by the staging release workflow*" \
+            --label "released" \
+            --label "auto-updated"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update existing PR
+        if: steps.check-pr.outputs.pr_exists == 'true'
+        run: |
+          TIMESTAMP=$(date -u +"%Y-%m-%d %H:%M:%S UTC")
+          PR_NUMBER="${{ steps.check-pr.outputs.pr_number }}"
+          PUBLISHED_VERSIONS="${{ steps.publish.outputs.published_versions }}"
+          
+          cat > pr-body-update.md << EOF
+## 🎯 Beta Release Ready for Production
+
+### ⏰ Last Updated: $TIMESTAMP
+
+$PUBLISHED_VERSIONS
+
+### 📋 What happens next?
+1. Review and test the beta versions
+2. When approved and merged, this will:
+   - Update package.json versions (remove beta suffix)
+   - Generate/update CHANGELOG.md files
+   - Sync changes back to develop and staging
+   - **Note**: npm publish happens only when you create a version tag
+
+### 🏷️ After merge:
+Create a version tag to trigger production release:
+\`\`\`bash
+git checkout main
+git pull origin main
+git tag v\${VERSION}
+git push origin v\${VERSION}
+\`\`\`
+
+### 📦 Install beta versions:
+\`\`\`bash
+npm install vue-pivottable@beta
+# or specific sub-packages
+npm install @vue-pivottable/plotly-renderer@beta
+npm install @vue-pivottable/lazy-table-renderer@beta
+\`\`\`
+
+---
+*This PR was automatically updated by the staging release workflow*
+EOF
+          
+          # Update PR body with new beta versions
+          gh pr edit $PR_NUMBER --body-file pr-body-update.md
+          
+          # Update labels
+          gh pr edit $PR_NUMBER \
+            --add-label "needs-review"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/.github/workflows/release-tag.yml b/.github/workflows/release-tag.yml
new file mode 100644
index 0000000..5cffe31
--- /dev/null
+++ b/.github/workflows/release-tag.yml
@@ -0,0 +1,185 @@
+name: Release Production (Tag)
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  release-production:
+    name: Release to Production
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Validate tag
+        id: tag-info
+        run: |
+          TAG_NAME=${GITHUB_REF#refs/tags/}
+          echo "tag=$TAG_NAME" >> $GITHUB_OUTPUT
+          
+          # Extract version from tag
+          VERSION=${TAG_NAME#v}
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          
+          # Validate version format
+          if ! [[ $VERSION =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$ ]]; then
+            echo "❌ Invalid version format: $VERSION"
+            exit 1
+          fi
+          
+          echo "✅ Valid tag: $TAG_NAME (version: $VERSION)"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.10.0'
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: latest
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Verify versions match
+        run: |
+          TAG_VERSION="${{ steps.tag-info.outputs.version }}"
+          
+          # Check main package version
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          if [ "$MAIN_VERSION" != "$TAG_VERSION" ]; then
+            echo "⚠️ Warning: Main package version ($MAIN_VERSION) doesn't match tag ($TAG_VERSION)"
+            # This is not a fatal error as we might be releasing sub-packages
+          else
+            echo "✅ Main package version matches tag: $MAIN_VERSION"
+          fi
+
+      - name: Run quality checks
+        run: |
+          echo "Running type checks..."
+          pnpm typecheck
+          pnpm -r typecheck || true
+          
+          echo "Running linting..."
+          pnpm lint
+          pnpm -r lint || true
+
+      - name: Build packages
+        run: |
+          echo "Building all packages..."
+          pnpm build:all
+
+      - name: Publish to npm
+        id: publish
+        run: |
+          echo "Publishing packages with @latest tag..."
+          
+          # Publish packages
+          node scripts/release-packages.cjs
+          
+          # Collect published packages
+          echo "published_packages<<EOF" >> $GITHUB_OUTPUT
+          
+          # Check which packages were published
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          echo "- vue-pivottable@$MAIN_VERSION" >> $GITHUB_OUTPUT
+          
+          for pkg in packages/*/; do
+            if [ -d "$pkg" ] && [ -f "$pkg/package.json" ]; then
+              PKG_NAME=$(cd "$pkg" && node -p "require('./package.json').name")
+              PKG_VERSION=$(cd "$pkg" && node -p "require('./package.json').version")
+              echo "- $PKG_NAME@$PKG_VERSION" >> $GITHUB_OUTPUT
+            fi
+          done
+          echo "EOF" >> $GITHUB_OUTPUT
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN_SUMIN: ${{ secrets.NPM_TOKEN_SUMIN }}
+
+      - name: Get release notes
+        id: release-notes
+        run: |
+          # Try to extract release notes from CHANGELOG.md
+          NOTES=""
+          
+          if [ -f "CHANGELOG.md" ]; then
+            # Extract notes for this version
+            VERSION="${{ steps.tag-info.outputs.version }}"
+            NOTES=$(awk "/^## $VERSION/,/^## [0-9]/" CHANGELOG.md | sed '1d;$d' | head -n 20)
+          fi
+          
+          if [ -z "$NOTES" ]; then
+            NOTES="See CHANGELOG.md for details"
+          fi
+          
+          # Escape for GitHub Actions
+          NOTES="${NOTES//'%'/'%25'}"
+          NOTES="${NOTES//$'\n'/'%0A'}"
+          NOTES="${NOTES//$'\r'/'%0D'}"
+          
+          echo "notes<<EOF" >> $GITHUB_OUTPUT
+          echo "$NOTES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        run: |
+          TAG="${{ steps.tag-info.outputs.tag }}"
+          VERSION="${{ steps.tag-info.outputs.version }}"
+          PUBLISHED_PACKAGES="${{ steps.publish.outputs.published_packages }}"
+          RELEASE_NOTES="${{ steps.release-notes.outputs.notes }}"
+          
+          cat > release-notes.md << EOF
+## 🚀 Production Release $VERSION
+
+### 📦 Published Packages
+$PUBLISHED_PACKAGES
+
+### 📝 Release Notes
+$RELEASE_NOTES
+
+### 💻 Installation
+\`\`\`bash
+npm install vue-pivottable@latest
+# or specific packages
+npm install @vue-pivottable/plotly-renderer@latest
+npm install @vue-pivottable/lazy-table-renderer@latest
+\`\`\`
+
+### 🔗 Links
+- [npm: vue-pivottable](https://www.npmjs.com/package/vue-pivottable)
+- [npm: @vue-pivottable/plotly-renderer](https://www.npmjs.com/package/@vue-pivottable/plotly-renderer)
+- [npm: @vue-pivottable/lazy-table-renderer](https://www.npmjs.com/package/@vue-pivottable/lazy-table-renderer)
+
+---
+*Released by GitHub Actions*
+EOF
+          
+          gh release create "$TAG" \
+            --title "Release $TAG" \
+            --notes-file release-notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create release summary
+        run: |
+          echo "## 🎉 Production Release Complete!" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 📦 Released Version: ${{ steps.tag-info.outputs.tag }}" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 📚 Published Packages" >> $GITHUB_STEP_SUMMARY
+          echo "${{ steps.publish.outputs.published_packages }}" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 🔗 View Release" >> $GITHUB_STEP_SUMMARY
+          echo "[GitHub Release](https://github.com/${{ github.repository }}/releases/tag/${{ steps.tag-info.outputs.tag }})" >> $GITHUB_STEP_SUMMARY
\ No newline at end of file
diff --git a/.github/workflows/update-version.yml b/.github/workflows/update-version.yml
new file mode 100644
index 0000000..8baa775
--- /dev/null
+++ b/.github/workflows/update-version.yml
@@ -0,0 +1,247 @@
+name: Update Version in Main
+
+on:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  check-versions:
+    name: Check for Beta Versions
+    runs-on: ubuntu-latest
+    outputs:
+      has_beta: ${{ steps.check.outputs.has_beta }}
+      base_version: ${{ steps.check.outputs.base_version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for beta versions
+        id: check
+        run: |
+          HAS_BETA=false
+          BASE_VERSION=""
+          
+          # Check main package
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          if [[ $MAIN_VERSION == *"-beta"* ]]; then
+            HAS_BETA=true
+            BASE_VERSION=$(echo $MAIN_VERSION | sed 's/-beta.*//')
+            echo "Found beta in main package: $MAIN_VERSION → $BASE_VERSION"
+          fi
+          
+          # Check sub-packages
+          for pkg in packages/*/; do
+            if [ -d "$pkg" ] && [ -f "$pkg/package.json" ]; then
+              PKG_VERSION=$(cd "$pkg" && node -p "require('./package.json').version")
+              if [[ $PKG_VERSION == *"-beta"* ]]; then
+                HAS_BETA=true
+                PKG_BASE=$(echo $PKG_VERSION | sed 's/-beta.*//')
+                PKG_NAME=$(basename "$pkg")
+                echo "Found beta in $PKG_NAME: $PKG_VERSION → $PKG_BASE"
+              fi
+            fi
+          done
+          
+          echo "has_beta=$HAS_BETA" >> $GITHUB_OUTPUT
+          echo "base_version=$BASE_VERSION" >> $GITHUB_OUTPUT
+
+  update-versions:
+    name: Update Versions and Sync
+    needs: check-versions
+    if: needs.check-versions.outputs.has_beta == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.10.0'
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: latest
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Update versions
+        id: version-update
+        run: |
+          echo "📝 Updating package versions..."
+          
+          # Use changeset version to update versions properly
+          pnpm changeset version
+          
+          # Remove any remaining beta suffixes
+          # Update main package
+          MAIN_VERSION=$(node -p "require('./package.json').version")
+          if [[ $MAIN_VERSION == *"-beta"* ]]; then
+            CLEAN_VERSION=$(echo $MAIN_VERSION | sed 's/-beta.*//')
+            npm version $CLEAN_VERSION --no-git-tag-version
+            echo "Updated main package to $CLEAN_VERSION"
+          fi
+          
+          # Update sub-packages
+          for pkg in packages/*/; do
+            if [ -d "$pkg" ] && [ -f "$pkg/package.json" ]; then
+              cd "$pkg"
+              PKG_VERSION=$(node -p "require('./package.json').version")
+              if [[ $PKG_VERSION == *"-beta"* ]]; then
+                CLEAN_VERSION=$(echo $PKG_VERSION | sed 's/-beta.*//')
+                npm version $CLEAN_VERSION --no-git-tag-version
+                PKG_NAME=$(basename "$pkg")
+                echo "Updated $PKG_NAME to $CLEAN_VERSION"
+              fi
+              cd - > /dev/null
+            fi
+          done
+          
+          # Get final version for output
+          FINAL_VERSION=$(node -p "require('./package.json').version")
+          echo "version=$FINAL_VERSION" >> $GITHUB_OUTPUT
+
+      - name: Commit version updates
+        run: |
+          git add -A
+          git commit -m "chore: update versions to stable
+
+          - Remove beta suffixes
+          - Update CHANGELOG.md files
+          - Prepare for production release" || echo "No changes to commit"
+
+      - name: Push to main
+        run: |
+          git push origin main
+
+      - name: Sync to develop
+        run: |
+          echo "🔄 Syncing changes to develop branch..."
+          
+          # Fetch latest develop
+          git fetch origin develop:develop
+          
+          # Create sync branch
+          SYNC_BRANCH="sync/main-to-develop-$(date +%s)"
+          git checkout -b $SYNC_BRANCH
+          
+          # Merge main changes
+          git merge main --no-ff -m "chore: sync version updates from main"
+          
+          # Push sync branch
+          git push origin $SYNC_BRANCH
+          
+          # Create PR
+          VERSION="${{ steps.version-update.outputs.version }}"
+          
+          {
+            echo "## 🔄 Version Sync from Main"
+            echo ""
+            echo "### 📦 Updated Versions"
+            echo "This PR syncs the stable version updates from main to develop."
+            echo ""
+            echo "Version: **v$VERSION**"
+            echo ""
+            echo "### ⚡ Auto-merge"
+            echo "This PR should be merged automatically to keep branches in sync."
+            echo ""
+            echo "---"
+            echo "*This PR was automatically created by the version update workflow*"
+          } > pr-body.md
+          
+          gh pr create \
+            --base develop \
+            --head $SYNC_BRANCH \
+            --title "🔄 Sync: main → develop (v$VERSION)" \
+            --body-file pr-body.md \
+            --label "auto-updated"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Sync to staging
+        run: |
+          echo "🔄 Syncing changes to staging branch..."
+          
+          # Checkout main again
+          git checkout main
+          
+          # Fetch latest staging
+          git fetch origin staging:staging
+          
+          # Create sync branch
+          SYNC_BRANCH="sync/main-to-staging-$(date +%s)"
+          git checkout -b $SYNC_BRANCH
+          
+          # Merge main changes
+          git merge main --no-ff -m "chore: sync version updates from main"
+          
+          # Push sync branch
+          git push origin $SYNC_BRANCH
+          
+          # Create PR
+          VERSION="${{ steps.version-update.outputs.version }}"
+          
+          {
+            echo "## 🔄 Version Sync from Main"
+            echo ""
+            echo "### 📦 Updated Versions"
+            echo "This PR syncs the stable version updates from main to staging."
+            echo ""
+            echo "Version: **v$VERSION**"
+            echo ""
+            echo "### ⚡ Auto-merge"
+            echo "This PR should be merged automatically to keep branches in sync."
+            echo ""
+            echo "---"
+            echo "*This PR was automatically created by the version update workflow*"
+          } > pr-body-staging.md
+          
+          gh pr create \
+            --base staging \
+            --head $SYNC_BRANCH \
+            --title "🔄 Sync: main → staging (v$VERSION)" \
+            --body-file pr-body-staging.md \
+            --label "auto-updated"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create release summary
+        run: |
+          VERSION="${{ steps.version-update.outputs.version }}"
+          
+          echo "## ✅ Version Update Complete" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 📦 Version: v$VERSION" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 🏷️ Next Steps" >> $GITHUB_STEP_SUMMARY
+          echo "To publish this version to npm, create and push a tag:" >> $GITHUB_STEP_SUMMARY
+          echo "\`\`\`bash" >> $GITHUB_STEP_SUMMARY
+          echo "git checkout main" >> $GITHUB_STEP_SUMMARY
+          echo "git pull origin main" >> $GITHUB_STEP_SUMMARY
+          echo "git tag v$VERSION" >> $GITHUB_STEP_SUMMARY
+          echo "git push origin v$VERSION" >> $GITHUB_STEP_SUMMARY
+          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### 🔄 Sync PRs Created" >> $GITHUB_STEP_SUMMARY
+          echo "- PR to develop branch" >> $GITHUB_STEP_SUMMARY
+          echo "- PR to staging branch" >> $GITHUB_STEP_SUMMARY
\ No newline at end of file
diff --git a/RELEASE_STRATEGY.ko.md b/RELEASE_STRATEGY.ko.md
index 80e3f0d..c467d31 100644
--- a/RELEASE_STRATEGY.ko.md
+++ b/RELEASE_STRATEGY.ko.md
@@ -4,43 +4,43 @@
 
 ## 개요
 
-이 문서는 Changesets를 사용하여 버전 관리를 하고 독립적인 패키지 릴리스를 지원하는 vue3-pivottable 모노레포의 릴리스 전략을 설명합니다.
+이 문서는 자동화된 워크플로우, Changesets를 통한 버전 관리, 그리고 프로덕션 배포를 위한 태그 기반 릴리스를 사용하는 vue3-pivottable 모노레포의 릴리스 전략을 설명합니다.
 
 ## 릴리스 플로우
 
 ```mermaid
 sequenceDiagram
-    participant F as feature 브랜치
+    participant F as feature/fix 브랜치
     participant D as develop
+    participant S as staging
     participant M as main
-    participant R as release/vX.X.X
+    participant T as Tags
     participant NPM as npm 레지스트리
     
     Note over F,D: 1. 기능 개발
     F->>D: changesets와 함께 PR
-    D-->>D: 코드 리뷰 & 머지
+    D->>D: 코드 리뷰 & 머지
     
-    Note over D,NPM: 2. 베타 릴리스 (자동)
-    D-->>D: Changesets 소비
-    D-->>D: 버전 bump + beta 접미사
-    D-->>D: 품질 체크 (lint, typecheck)
-    D-->>D: 모든 패키지 빌드
-    D->>NPM: @beta 퍼블리시
-    D-->>D: 변경사항 커밋
+    Note over D,S: 2. Staging으로 자동 PR
+    D->>S: 자동 PR 생성
+    D->>S: 추가 커밋 누적
     
-    Note over D,M: 3. 프로덕션 준비
-    D->>M: PR (베타 버전, changesets 없음)
-    M-->>M: 리뷰 & 머지
+    Note over S,NPM: 3. 베타 릴리스 (PR 승인)
+    S->>S: 베타 버전 생성
+    S->>S: 품질 체크 & 빌드
+    S->>NPM: @beta 퍼블리시
+    S->>M: main으로 자동 PR
     
-    Note over M,NPM: 4. 안정 릴리스 (자동)
-    M->>R: 릴리스 브랜치 생성
-    R-->>R: beta 접미사만 제거
-    R-->>R: 품질 체크 & 빌드
-    R->>NPM: @latest 퍼블리시
+    Note over M,T: 4. 버전 업데이트 (PR 승인)
+    M->>M: Changeset version 업데이트
+    M->>M: package.json & CHANGELOG 업데이트
+    M->>D: develop으로 자동 동기화
+    M->>S: staging으로 자동 동기화
     
-    Note over R,M: 5. 동기화
-    R->>M: main 업데이트를 위한 PR
-    M-->>M: 머지 (main에 안정 버전 반영)
+    Note over T,NPM: 5. 프로덕션 릴리스 (태그)
+    T->>T: 버전 태그 생성 (v1.2.0)
+    T->>NPM: @latest 퍼블리시
+    T->>T: GitHub Release 생성
 ```
 
 ## 브랜치 책임
@@ -48,30 +48,42 @@ sequenceDiagram
 ### develop 브랜치
 - **목적**: 모든 기능의 통합 브랜치
 - **자동 작업**:
-  - changesets 소비 (파일 삭제됨)
-  - changesets 기반 버전 bump
-  - 타임스탬프와 함께 beta 접미사 추가
-  - 품질 체크 실행 (ESLint, TypeScript)
-  - 모든 패키지 빌드
-  - @beta 태그로 npm에 퍼블리시
-  - 버전 변경사항을 develop에 커밋
+  - push 시 staging으로 자동 PR 생성
+  - 기존 staging PR에 변경사항 누적
+  - 지속적 통합 체크
+
+### staging 브랜치
+- **목적**: QA 테스트 및 베타 릴리스
+- **PR 머지 시 자동 작업**:
+  - 누적된 changesets 확인
+  - changesets가 있을 경우:
+    - changesets 소비 (파일 삭제)
+    - 베타 버전 생성 (x.y.z-beta.timestamp)
+    - 품질 체크 실행 (ESLint, TypeScript)
+    - 모든 패키지 빌드
+    - @beta 태그로 npm에 퍼블리시
+    - main으로 자동 PR 생성
+  - changesets가 없으면: 릴리스 프로세스 건너뛰기
 
 ### main 브랜치
-- **목적**: 프로덕션 준비 코드만
-- **보호**: 직접 푸시 불가
-- **자동 작업**:
-  - release/vX.X.X 브랜치 생성
-  - changeset 처리 없음 (develop에서 이미 완료)
-  - 안정 릴리스 프로세스 트리거
-
-### release/vX.X.X 브랜치
-- **목적**: 안정 릴리스를 위한 임시 브랜치
+- **목적**: 프로덕션 준비 코드
+- **보호**: 직접 커밋 불가 (PR만 가능)
+- **PR 머지 시 자동 작업**:
+  - `changeset version` 실행
+  - package.json 버전 업데이트
+  - CHANGELOG.md 생성/업데이트
+  - 버전 변경사항 커밋
+  - develop과 staging으로 변경사항 동기화
+  - **npm 퍼블리시하지 않음**
+
+### Tags (v*.*.*)
+- **목적**: 프로덕션 릴리스 트리거
+- **생성**: main 업데이트 후 수동
 - **자동 작업**:
-  - 버전에서 beta 접미사 제거
-  - 품질 체크 실행
+  - 태그된 커밋에서 체크아웃
   - 모든 패키지 빌드
   - @latest 태그로 npm에 퍼블리시
-  - main으로 다시 PR 생성
+  - GitHub Release 생성
 
 ## 패키지 독립성
 
@@ -114,14 +126,16 @@ graph TD
 # 메인 패키지의 버그 수정을 위한 Changeset
 "vue-pivottable": patch
 
-# develop에서의 결과:
+# staging에서의 결과:
 vue-pivottable: 1.1.1 → 1.1.2-beta.1234567890
 @vue-pivottable/plotly-renderer: 2.0.0 (변경 없음)
 @vue-pivottable/lazy-table-renderer: 1.0.13 (변경 없음)
 
-# main/release에서의 결과:
-vue-pivottable: 1.1.2-beta.1234567890 → 1.1.2
-# 다른 패키지는 퍼블리시되지 않음
+# main 머지 후 결과:
+vue-pivottable: 1.1.2 (버전 업데이트됨, 퍼블리시 안 됨)
+
+# v1.1.2 태그 생성 후:
+vue-pivottable: 1.1.2 → npm @latest
 ```
 
 ### 시나리오 2: 다중 패키지 업데이트
@@ -130,15 +144,16 @@ vue-pivottable: 1.1.2-beta.1234567890 → 1.1.2
 "vue-pivottable": minor
 "@vue-pivottable/plotly-renderer": minor
 
-# develop에서의 결과:
+# staging에서의 결과:
 vue-pivottable: 1.1.1 → 1.2.0-beta.1234567890
 @vue-pivottable/plotly-renderer: 2.0.0 → 2.1.0-beta.1234567890
-@vue-pivottable/lazy-table-renderer: 1.0.13 (변경 없음)
 
-# main/release에서의 결과:
-vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
-@vue-pivottable/plotly-renderer: 2.1.0-beta.1234567890 → 2.1.0
-# lazy-table-renderer는 퍼블리시되지 않음
+# main 머지 후 결과:
+vue-pivottable: 1.2.0 (업데이트됨)
+@vue-pivottable/plotly-renderer: 2.1.0 (업데이트됨)
+
+# v1.2.0 태그 생성 후:
+두 패키지 모두 → npm @latest
 ```
 
 ## 품질 게이트
@@ -158,19 +173,30 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 ## 워크플로우 파일
 
 ### 1. `.github/workflows/pr-check.yml`
-- **트리거**: main 또는 develop으로의 PR
+- **트리거**: 모든 브랜치로의 PR
 - **체크**: Lint, TypeCheck, Build, Changesets
 - **목적**: 머지 전 코드 품질 보장
 
-### 2. `.github/workflows/release-develop.yml`
+### 2. `.github/workflows/integrate-develop.yml`
 - **트리거**: develop으로 푸시
-- **작업**: 버전 관리, 빌드, @beta 퍼블리시
-- **핵심 기능**: changesets 소비
+- **작업**: staging으로 PR 생성/업데이트
+- **핵심 기능**: 다중 변경사항 누적
+
+### 3. `.github/workflows/release-staging.yml`
+- **트리거**: staging으로 푸시
+- **조건**: changesets가 존재할 때 (develop에서 누적됨)
+- **작업**: 베타 버전, 빌드, @beta 퍼블리시
+- **핵심 기능**: changesets 소비, main으로 자동 PR
+
+### 4. `.github/workflows/update-version.yml`
+- **트리거**: main으로 푸시 (베타 버전 포함)
+- **작업**: 버전 업데이트, 브랜치 동기화
+- **핵심 기능**: npm 퍼블리시 안 함
 
-### 3. `.github/workflows/release.yml`
-- **트리거**: main으로 푸시
-- **작업**: beta 접미사 제거, 빌드, @latest 퍼블리시
-- **핵심 기능**: changeset 불필요
+### 5. `.github/workflows/release-tag.yml`
+- **트리거**: 태그 푸시 (v*.*.*)
+- **작업**: 빌드, @latest 퍼블리시
+- **핵심 기능**: 프로덕션 배포
 
 ## 보안
 
@@ -181,15 +207,16 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 
 ### 브랜치 보호
 - main: PR 필수, 직접 푸시 불가
-- develop: CI 커밋을 위해 열려있음
-- release/*: 임시, 자동 생성
+- staging: PR 필수, 직접 푸시 불가
+- develop: PR 필수, 직접 푸시 불가
 
 ## 명령어 참조
 
 | 명령어 | 설명 |
 |---------|-------------|
-| `pnpm changeset add` | 변경사항에 대한 changeset 추가 |
+| `pnpm changeset` | 변경사항에 대한 changeset 추가 |
 | `pnpm changeset status` | 대기 중인 changesets 확인 |
+| `pnpm changeset version` | changesets를 버전에 적용 |
 | `pnpm build:all` | 모든 패키지 빌드 |
 | `pnpm typecheck` | TypeScript 체크 실행 |
 | `pnpm lint` | ESLint 실행 |
@@ -198,60 +225,87 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 ## 모범 사례
 
 1. **항상 changesets 추가** - 릴리스를 트리거해야 하는 변경사항에 대해
-2. **베타에서 먼저 테스트** - main으로 승인하기 전에 npm @beta 확인
-3. **독립 버전** - 변경되지 않은 패키지는 bump하지 않음
-4. **품질 우선** - 퍼블리시 전 모든 체크 통과 필수
+2. **베타에서 먼저 테스트** - staging이 베타 테스트 환경 제공
+3. **자동 PR 검토** - 승인 전 자동화된 PR 확인
+4. **main 업데이트 후 태그** - main에서 버전 업데이트 후에만 태그 생성
 
 ## 릴리스 프로세스 중 업데이트 처리
 
-### 시나리오: main으로의 PR 이후 develop 변경사항
+### 시나리오: 지속적인 개발 플로우
 
-develop에서 main으로의 PR이 이미 열려있고 develop에 새로운 변경사항이 푸시되는 경우:
+워크플로우는 진행 중인 개발을 원활하게 처리합니다:
 
 1. **자동 PR 업데이트**
-   - release-develop 워크플로우가 기존 PR을 자동으로 감지
-   - PR 제목을 새 베타 버전으로 업데이트
-   - PR 설명에 타임스탬프와 새 버전 정보 업데이트
-   - `auto-updated`와 `needs-review` 라벨 추가
-   - PR을 "ready for review" 상태로 설정
-
-2. **리뷰 프로세스**
-   - 리뷰어는 라벨을 통해 업데이트 알림을 받음
-   - 이전 승인은 유지되지만 재검토 권장
-   - PR 설명에 명확한 "Updated" 상태와 타임스탬프 표시
-
-3. **장점**
-   - PR 히스토리와 토론 내용 보존
-   - 수동 개입 불필요
-   - 모든 베타 버전의 명확한 감사 추적
+   - develop → staging PR이 새 커밋 누적
+   - 각 추가사항마다 PR 설명 업데이트
+   - 여러 기능/수정을 위한 단일 PR
+
+2. **베타 버전 관리**
+   - 각 staging 머지마다 새 베타 버전 생성
+   - 이전 베타 버전도 사용 가능
+   - 명확한 버전 진행 추적
+
+3. **동기화**
+   - main 업데이트가 develop/staging으로 되돌아감
+   - 브랜치 간 차이 방지
+   - 선형 히스토리 유지
 
 ### 예시 플로우
 ```
-1. v1.2.0-beta.1234567890 → PR #123 생성
-2. develop에 새로운 수정사항 푸시
-3. v1.2.1-beta.2345678901 → PR #123 자동 업데이트
-4. 리뷰어가 "auto-updated" 라벨 확인 후 재검토
-5. 승인 후 main으로 머지하면 안정 릴리스 트리거
+1. 기능 A를 develop에 머지 → staging으로 자동 PR #123
+2. 기능 B를 develop에 머지 → PR #123 업데이트
+3. PR #123 승인 → v1.2.0-beta.1234567890
+4. main으로 자동 PR #124 생성
+5. PR #124 승인 → main에 버전 1.2.0
+6. v1.2.0 태그 생성 → npm에 퍼블리시
+7. develop/staging이 main과 동기화
 ```
 
+## 릴리스 체크리스트
+
+### 개발자용
+- [ ] develop에서 feature/fix 브랜치 생성
+- [ ] 적절한 버전 bump와 함께 changeset 추가
+- [ ] develop으로 PR 생성
+- [ ] 모든 체크 통과 확인
+
+### QA 팀용
+- [ ] staging PR 내용 검토
+- [ ] npm에서 베타 버전 테스트
+- [ ] 준비되면 staging PR 승인
+
+### 릴리스 관리자용
+- [ ] staging에서 온 main PR 검토
+- [ ] main PR 승인 (버전 업데이트 트리거)
+- [ ] 동기화 완료 대기
+- [ ] 버전 태그 생성 및 푸시:
+  ```bash
+  git checkout main
+  git pull origin main
+  git tag v1.2.0
+  git push origin v1.2.0
+  ```
+- [ ] npm 배포 확인
+- [ ] GitHub Release 생성 확인
+
 ## 문제 해결
 
-### 베타 버전이 퍼블리시되지 않나요?
-- changesets가 존재하는지 확인
-- 빌드가 성공하는지 검증
-- npm 토큰 권한 확인
+### 자동 PR이 생성되지 않나요?
+- GitHub Actions 실행 확인
+- 브랜치 보호가 봇 PR을 허용하는지 확인
+- 기존 열린 PR이 있는지 확인
 
-### 패키지가 업데이트되지 않나요?
-- changeset에 패키지 이름이 포함되어 있는지 확인
-- 패키지에 빌드 스크립트가 있는지 확인
-- package.json의 이름이 일치하는지 검증
+### 베타 버전이 퍼블리시되지 않나요?
+- changesets가 추가되었는지 확인
+- staging에서 빌드 성공 확인
+- npm 토큰 유효성 확인
 
-### CI에서는 타입 오류가 있는데 로컬에서는 없나요?
-- 로컬에서 `pnpm typecheck` 실행
-- 모든 워크스페이스 패키지 확인: `pnpm -r typecheck`
-- 의존성이 최신인지 확인
+### 동기화 실패?
+- 머지 충돌 확인
+- 워크플로우 로그 검토
+- 수동 동기화 필요할 수 있음
 
-### PR이 자동으로 업데이트되지 않나요?
-- GitHub Actions 권한 확인
-- GITHUB_TOKEN이 PR 쓰기 권한을 가지고 있는지 검증
-- PR이 열린 상태인지 확인
\ No newline at end of file
+### 태그 릴리스 실패?
+- 태그가 버전 패턴과 일치하는지 확인 (v*.*.*)
+- npm 토큰 권한 확인
+- 패키지 빌드 성공 확인
\ No newline at end of file
diff --git a/RELEASE_STRATEGY.md b/RELEASE_STRATEGY.md
index f4c06b3..0d7a699 100644
--- a/RELEASE_STRATEGY.md
+++ b/RELEASE_STRATEGY.md
@@ -4,43 +4,43 @@
 
 ## Overview
 
-This document outlines the release strategy for the vue3-pivottable monorepo, which uses Changesets for version management and supports independent package releases.
+This document outlines the release strategy for the vue3-pivottable monorepo, which uses automated workflows, Changesets for version management, and tag-based releases for production deployment.
 
 ## Release Flow
 
 ```mermaid
 sequenceDiagram
-    participant F as feature branch
+    participant F as feature/fix branch
     participant D as develop
+    participant S as staging
     participant M as main
-    participant R as release/vX.X.X
+    participant T as Tags
     participant NPM as npm Registry
     
     Note over F,D: 1. Feature Development
     F->>D: PR with changesets
     D->>D: Code Review & Merge
     
-    Note over D,NPM: 2. Beta Release (Automatic)
-    D->>D: Changesets consumed
-    D->>D: Version bump + beta suffix
-    D->>D: Quality checks (lint, typecheck)
-    D->>D: Build all packages
-    D->>NPM: Publish @beta
-    D->>D: Commit changes
+    Note over D,S: 2. Auto PR to Staging
+    D->>S: Automatic PR creation
+    D->>S: Additional commits accumulate
     
-    Note over D,M: 3. Production Preparation
-    D->>M: PR (beta versions, no changesets)
-    M->>M: Review & Merge
+    Note over S,NPM: 3. Beta Release (PR Approval)
+    S->>S: Beta version generation
+    S->>S: Quality checks & Build
+    S->>NPM: Publish @beta
+    S->>M: Auto PR to main
     
-    Note over M,NPM: 4. Stable Release (Automatic)
-    M->>R: Create release branch
-    R->>R: Remove beta suffix only
-    R->>R: Quality checks & Build
-    R->>NPM: Publish @latest
+    Note over M,T: 4. Version Update (PR Approval)
+    M->>M: Changeset version update
+    M->>M: Update package.json & CHANGELOG
+    M->>D: Auto sync to develop
+    M->>S: Auto sync to staging
     
-    Note over R,M: 5. Sync Back
-    R->>M: PR to update main
-    M->>M: Merge (main now has stable versions)
+    Note over T,NPM: 5. Production Release (Tag)
+    T->>T: Create version tag (v1.2.0)
+    T->>NPM: Publish @latest
+    T->>T: Create GitHub Release
 ```
 
 ## Branch Responsibilities
@@ -48,30 +48,42 @@ sequenceDiagram
 ### develop Branch
 - **Purpose**: Integration branch for all features
 - **Automatic Actions**:
-  - Consume changesets (files are deleted)
-  - Bump versions based on changesets
-  - Add beta suffix with timestamp
-  - Run quality checks (ESLint, TypeScript)
-  - Build all packages
-  - Publish to npm with @beta tag
-  - Commit version changes back to develop
+  - Trigger auto PR to staging on push
+  - Accumulate changes in existing staging PR
+  - Continuous integration checks
+
+### staging Branch
+- **Purpose**: QA testing and beta releases
+- **Automatic Actions on PR merge**:
+  - Check for accumulated changesets
+  - If changesets exist:
+    - Consume changesets (delete files)
+    - Generate beta version (x.y.z-beta.timestamp)
+    - Run quality checks (ESLint, TypeScript)
+    - Build all packages
+    - Publish to npm with @beta tag
+    - Create auto PR to main
+  - If no changesets: skip release process
 
 ### main Branch
-- **Purpose**: Production-ready code only
-- **Protection**: Cannot push directly
-- **Automatic Actions**:
-  - Create release/vX.X.X branch
-  - No changeset processing (already done in develop)
-  - Trigger stable release process
-
-### release/vX.X.X Branch
-- **Purpose**: Temporary branch for stable releases
+- **Purpose**: Production-ready code
+- **Protection**: No direct commits (only PRs)
+- **Automatic Actions on PR merge**:
+  - Execute `changeset version`
+  - Update package.json versions
+  - Generate/update CHANGELOG.md
+  - Commit version changes
+  - Sync changes to develop and staging
+  - **No npm publish**
+
+### Tags (v*.*.*)
+- **Purpose**: Trigger production releases
+- **Created**: Manually after main update
 - **Automatic Actions**:
-  - Remove beta suffix from versions
-  - Run quality checks
+  - Checkout tagged commit
   - Build all packages
   - Publish to npm with @latest tag
-  - Create PR back to main
+  - Create GitHub Release
 
 ## Package Independence
 
@@ -114,14 +126,16 @@ This ensures each package:
 # Changeset for bug fix in main package
 "vue-pivottable": patch
 
-# Result in develop:
+# Result in staging:
 vue-pivottable: 1.1.1 → 1.1.2-beta.1234567890
 @vue-pivottable/plotly-renderer: 2.0.0 (unchanged)
 @vue-pivottable/lazy-table-renderer: 1.0.13 (unchanged)
 
-# Result in main/release:
-vue-pivottable: 1.1.2-beta.1234567890 → 1.1.2
-# Other packages not published
+# Result after main merge:
+vue-pivottable: 1.1.2 (version updated, not published)
+
+# Result after tag v1.1.2:
+vue-pivottable: 1.1.2 → npm @latest
 ```
 
 ### Scenario 2: Multiple Package Updates
@@ -130,15 +144,16 @@ vue-pivottable: 1.1.2-beta.1234567890 → 1.1.2
 "vue-pivottable": minor
 "@vue-pivottable/plotly-renderer": minor
 
-# Result in develop:
+# Result in staging:
 vue-pivottable: 1.1.1 → 1.2.0-beta.1234567890
 @vue-pivottable/plotly-renderer: 2.0.0 → 2.1.0-beta.1234567890
-@vue-pivottable/lazy-table-renderer: 1.0.13 (unchanged)
 
-# Result in main/release:
-vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
-@vue-pivottable/plotly-renderer: 2.1.0-beta.1234567890 → 2.1.0
-# lazy-table-renderer not published
+# Result after main merge:
+vue-pivottable: 1.2.0 (updated)
+@vue-pivottable/plotly-renderer: 2.1.0 (updated)
+
+# Result after tag v1.2.0:
+Both packages → npm @latest
 ```
 
 ## Quality Gates
@@ -158,19 +173,30 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 ## Workflow Files
 
 ### 1. `.github/workflows/pr-check.yml`
-- **Triggers**: PR to main or develop
+- **Triggers**: PR to any branch
 - **Checks**: Lint, TypeCheck, Build, Changesets
 - **Purpose**: Ensure code quality before merge
 
-### 2. `.github/workflows/release-develop.yml`
+### 2. `.github/workflows/integrate-develop.yml`
 - **Triggers**: Push to develop
-- **Actions**: Version, Build, Publish @beta
-- **Key Feature**: Consumes changesets
+- **Actions**: Create/update PR to staging
+- **Key Feature**: Accumulates multiple changes
+
+### 3. `.github/workflows/release-staging.yml`
+- **Triggers**: Push to staging
+- **Condition**: When changesets exist (accumulated from develop)
+- **Actions**: Beta version, Build, Publish @beta
+- **Key Feature**: Consumes changesets, Auto PR to main
 
-### 3. `.github/workflows/release.yml`
-- **Triggers**: Push to main
-- **Actions**: Remove beta suffix, Build, Publish @latest
-- **Key Feature**: No changeset needed
+### 4. `.github/workflows/update-version.yml`
+- **Triggers**: Push to main (with beta versions)
+- **Actions**: Update versions, sync branches
+- **Key Feature**: No npm publish
+
+### 5. `.github/workflows/release-tag.yml`
+- **Triggers**: Tag push (v*.*.*)
+- **Actions**: Build, Publish @latest
+- **Key Feature**: Production deployment
 
 ## Security
 
@@ -181,15 +207,16 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 
 ### Branch Protection
 - main: Requires PR, no direct push
-- develop: Open for CI commits
-- release/*: Temporary, auto-created
+- staging: Requires PR, no direct push
+- develop: Requires PR, no direct push
 
 ## Commands Reference
 
 | Command | Description |
 |---------|-------------|
-| `pnpm changeset add` | Add a changeset for your changes |
+| `pnpm changeset` | Add a changeset for your changes |
 | `pnpm changeset status` | Check pending changesets |
+| `pnpm changeset version` | Apply changesets to versions |
 | `pnpm build:all` | Build all packages |
 | `pnpm typecheck` | Run TypeScript checks |
 | `pnpm lint` | Run ESLint |
@@ -198,60 +225,87 @@ vue-pivottable: 1.2.0-beta.1234567890 → 1.2.0
 ## Best Practices
 
 1. **Always add changesets** for changes that should trigger releases
-2. **Test in beta first** - Check npm @beta before approving to main
-3. **Independent versions** - Don't bump unchanged packages
-4. **Quality first** - All checks must pass before publish
+2. **Test in beta first** - staging provides beta testing environment
+3. **Review auto PRs** - Check automated PRs before approving
+4. **Tag after main update** - Create tags only after version update in main
 
 ## Handling Updates During Release Process
 
-### Scenario: Changes to develop after PR to main
+### Scenario: Continuous Development Flow
 
-When a PR from develop to main is already open and new changes are pushed to develop:
+The workflow handles ongoing development seamlessly:
 
-1. **Automatic PR Update**
-   - The release-develop workflow automatically detects existing PR
-   - Updates PR title with new beta version
-   - Updates PR description with timestamp and new version info
-   - Adds `auto-updated` and `needs-review` labels
-   - Sets PR back to "ready for review" state
+1. **Automatic PR Updates**
+   - develop → staging PR accumulates new commits
+   - PR description updates with each addition
+   - Single PR for multiple features/fixes
 
-2. **Review Process**
-   - Reviewers are notified of the update via labels
-   - Previous approvals remain but re-review is recommended
-   - PR description shows clear "Updated" status with timestamp
+2. **Beta Version Management**
+   - Each staging merge creates new beta version
+   - Previous beta versions remain available
+   - Clear version progression tracking
 
-3. **Benefits**
-   - PR history and discussions are preserved
-   - No manual intervention required
-   - Clear audit trail of all beta versions
+3. **Synchronization**
+   - main updates flow back to develop/staging
+   - Prevents divergence between branches
+   - Maintains linear history
 
 ### Example Flow
 ```
-1. v1.2.0-beta.1234567890 → PR #123 created
-2. New fix pushed to develop
-3. v1.2.1-beta.2345678901 → PR #123 automatically updated
-4. Reviewers see "auto-updated" label and re-review
-5. Once approved, merge to main triggers stable release
+1. Feature A merged to develop → Auto PR #123 to staging
+2. Feature B merged to develop → PR #123 updated
+3. PR #123 approved → v1.2.0-beta.1234567890
+4. Auto PR #124 to main created
+5. PR #124 approved → Version 1.2.0 in main
+6. Tag v1.2.0 created → Published to npm
+7. develop/staging synced with main
 ```
 
+## Release Checklist
+
+### For Developers
+- [ ] Create feature/fix branch from develop
+- [ ] Add changeset with appropriate version bump
+- [ ] Create PR to develop
+- [ ] Ensure all checks pass
+
+### For QA Team
+- [ ] Review staging PR contents
+- [ ] Test beta version from npm
+- [ ] Approve staging PR when ready
+
+### For Release Manager
+- [ ] Review main PR from staging
+- [ ] Approve main PR (triggers version update)
+- [ ] Wait for sync completion
+- [ ] Create and push version tag:
+  ```bash
+  git checkout main
+  git pull origin main
+  git tag v1.2.0
+  git push origin v1.2.0
+  ```
+- [ ] Verify npm deployment
+- [ ] Check GitHub Release creation
+
 ## Troubleshooting
 
-### Beta version not publishing?
-- Check if changesets exist
-- Verify build succeeds
-- Check npm token permissions
+### Auto PR not created?
+- Check GitHub Actions runs
+- Verify branch protections allow bot PRs
+- Check for existing open PRs
 
-### Package not updating?
-- Ensure changeset includes the package name
-- Check if package has build script
-- Verify package.json name matches
+### Beta version not publishing?
+- Verify changesets were added
+- Check build success in staging
+- Verify npm token validity
 
-### Type errors in CI but not locally?
-- Run `pnpm typecheck` locally
-- Check all workspace packages: `pnpm -r typecheck`
-- Ensure dependencies are up to date
+### Sync failed?
+- Check for merge conflicts
+- Review workflow logs
+- Manual sync may be needed
 
-### PR not updating automatically?
-- Check GitHub Actions permissions
-- Verify GITHUB_TOKEN has write access to PRs
-- Check if PR is in open state
\ No newline at end of file
+### Tag release failed?
+- Ensure tag matches version pattern (v*.*.*)
+- Check npm token permissions
+- Verify package builds succeed
\ No newline at end of file
diff --git a/docs/GIT_FLOW_STRATEGY.md b/docs/GIT_FLOW_STRATEGY.md
new file mode 100644
index 0000000..b8d36e5
--- /dev/null
+++ b/docs/GIT_FLOW_STRATEGY.md
@@ -0,0 +1,339 @@
+# Git Flow 전략 문서
+
+## 목차
+1. [개요](#개요)
+2. [브랜치 전략](#브랜치-전략)
+3. [자동화된 워크플로우](#자동화된-워크플로우)
+4. [버전 관리 전략](#버전-관리-전략)
+5. [CI/CD 파이프라인](#cicd-파이프라인)
+6. [팀 가이드라인](#팀-가이드라인)
+7. [실전 가이드](#실전-가이드)
+
+## 개요
+
+이 문서는 vue3-pivottable 프로젝트의 Git Flow 전략을 정의합니다. 브랜치 보호 규칙과 자동화를 효과적으로 조합하여, 안정적이면서도 효율적인 개발 프로세스를 구축합니다.
+
+### 핵심 원칙
+- **자동화된 PR 생성**: 브랜치 간 자동 PR로 수동 작업 최소화
+- **명확한 환경 분리**: develop(개발) → staging(QA) → main(프로덕션)
+- **태그 기반 릴리즈**: 브랜치 보호와 자동화를 양립
+- **지속적 동기화**: 모든 브랜치를 최신 상태로 유지
+
+## 브랜치 전략
+
+### 브랜치 구조
+
+```
+main (production) - 태그 기반 정식 릴리즈
+  ├── hotfix/* - 긴급 수정
+  └── staging (QA) - 베타 배포
+       └── develop (integration) - 개발 통합
+            ├── feature/* - 새 기능
+            └── fix/* - 버그 수정
+```
+
+### 브랜치별 역할
+
+#### develop (개발 통합)
+- **목적**: 모든 개발 작업의 통합점
+- **자동화**: PR 승인 시 staging으로 자동 PR 생성
+- **특징**: 지속적 통합(CI) 실행
+
+#### staging (QA/베타)
+- **목적**: QA 테스트 및 베타 배포
+- **배포**: npm beta 태그
+- **버전**: x.y.z-beta.timestamp
+- **자동화**: 
+  - develop에서 자동 PR 수신 (changesets 누적)
+  - PR 승인 시 changesets 확인
+  - changesets 있을 때만 베타 배포
+  - 배포 후 main으로 자동 PR 생성
+
+#### main (프로덕션)
+- **목적**: 프로덕션 코드 관리
+- **배포**: 태그 생성 시 npm latest
+- **자동화**:
+  - staging에서 자동 PR 수신
+  - 승인 시 버전 업데이트 (배포는 안 함)
+  - develop/staging 자동 동기화
+
+#### feature/* & fix/*
+- **생성**: develop에서 분기
+- **머지**: develop으로 PR
+- **네이밍**: 
+  - feature/기능명
+  - fix/이슈번호-설명
+
+#### hotfix/*
+- **생성**: main에서 분기
+- **머지**: main으로 직접 PR
+- **용도**: 프로덕션 긴급 수정
+
+## 자동화된 워크플로우
+
+### 전체 플로우 다이어그램
+
+```mermaid
+graph TD
+    A[feature/fix 브랜치] -->|PR 승인| B[develop]
+    B -->|자동 PR 생성| C[staging PR 대기]
+    C -->|추가 커밋 누적| C
+    C -->|PR 승인| D[staging]
+    D -->|베타 배포| E[npm beta]
+    D -->|자동 PR 생성| F[main PR 대기]
+    F -->|PR 승인| G[main]
+    G -->|버전 업데이트| H[develop/staging 동기화]
+    G -->|태그 생성| I[npm latest 배포]
+```
+
+### 상세 프로세스
+
+#### 1. 개발 → 스테이징 (자동)
+
+**트리거**: develop PR 승인
+**동작**:
+1. develop → staging 자동 PR 생성
+2. 기존 PR이 있으면 커밋 추가
+3. PR 설명에 포함된 기능 목록 자동 업데이트
+
+**특징**:
+- 여러 개발 사항이 하나의 PR에 누적
+- QA 팀이 일괄 테스트 가능
+
+#### 2. 스테이징 승인 → 베타 배포
+
+**트리거**: staging PR 승인
+**동작**:
+1. 누적된 changesets 확인
+2. changesets가 있을 경우:
+   - changesets 소비 (파일 삭제)
+   - 베타 버전 자동 생성 (x.y.z-beta.timestamp)
+   - npm beta 태그로 배포
+   - GitHub pre-release 생성
+   - main으로 자동 PR 생성
+3. changesets가 없으면 릴리즈 건너뛰기
+
+#### 3. 메인 승인 → 버전 업데이트
+
+**트리거**: main PR 승인
+**동작**:
+1. Changeset version 실행
+2. package.json 버전 업데이트
+3. CHANGELOG.md 생성
+4. 변경사항 main에 커밋
+5. develop과 staging 자동 동기화
+6. **npm 배포는 하지 않음**
+
+#### 4. 태그 생성 → 정식 배포
+
+**트리거**: v*.*.* 태그 푸시
+**동작**:
+1. 태그된 커밋에서 체크아웃
+2. npm latest 태그로 배포
+3. GitHub Release 생성
+4. 릴리즈 노트 자동 생성
+
+### 동기화 전략
+
+main이 업데이트되면 다음 순서로 동기화:
+1. main → develop (자동 머지)
+2. main → staging (자동 머지)
+
+**동기화 시 주의사항**:
+- 충돌 가능성은 낮음 (순차적 머지이므로)
+- 베타 버전이 있는 staging은 재배포하지 않음
+- 동기화 실패 시 알림 발송
+
+## 버전 관리 전략
+
+### 버전 형식
+- **개발**: 수동 버전 관리 없음
+- **스테이징**: `1.2.0-beta.1234567890`
+- **메인**: `1.2.0` (태그 생성 전까지 배포 안 함)
+- **태그**: `v1.2.0` (정식 릴리즈)
+
+### Changesets 활용
+- 모든 PR에 changeset 필수
+- staging → main PR 승인 시 자동 적용
+- 버전 업데이트와 CHANGELOG 자동 생성
+
+### npm 태그 전략
+- `beta`: staging 브랜치 자동 배포
+- `latest`: 태그 생성 시에만 배포
+
+## CI/CD 파이프라인
+
+### 1. PR 체크 (pr-check.yml)
+**트리거**: 모든 PR
+**검증 항목**:
+- Lint & TypeScript 체크
+- 빌드 테스트
+- Changeset 존재 여부
+- 테스트 실행
+
+### 2. 개발 통합 (integrate-develop.yml)
+**트리거**: develop push
+**작업**:
+- staging으로 자동 PR 생성/업데이트
+- PR 라벨 자동 추가
+
+### 3. 베타 릴리즈 (release-staging.yml)
+**트리거**: staging push
+**조건**: changesets 존재 시 (develop에서 누적됨)
+**작업**:
+1. changesets 소비 (파일 삭제)
+2. 베타 버전 생성
+3. npm beta 배포
+4. main으로 자동 PR 생성
+
+### 4. 버전 업데이트 (update-version.yml)
+**트리거**: main push
+**조건**: 베타 버전 존재 시
+**작업**:
+1. Changeset version 실행
+2. 버전 커밋
+3. develop/staging 동기화
+
+### 5. 정식 릴리즈 (release-tag.yml)
+**트리거**: 태그 푸시 (v*.*.*)
+**작업**:
+1. npm latest 배포
+2. GitHub Release 생성
+
+## 팀 가이드라인
+
+### 브랜치 작업 규칙
+
+#### 일반 개발
+1. develop에서 feature/fix 브랜치 생성
+2. 작업 완료 후 develop으로 PR
+3. Changeset 추가 필수
+4. 코드 리뷰 후 승인
+
+#### 긴급 수정
+1. main에서 hotfix 브랜치 생성
+2. 수정 후 main으로 직접 PR
+3. 승인 후 자동 동기화 확인
+
+### 릴리즈 담당자 가이드
+
+#### 정식 릴리즈 절차
+1. main PR 승인 (버전 업데이트됨)
+2. 동기화 완료 확인
+3. 태그 생성 및 푸시:
+   ```bash
+   git checkout main
+   git pull origin main
+   git tag v1.2.0
+   git push origin v1.2.0
+   ```
+4. 배포 모니터링
+
+### Changeset 작성 가이드
+
+**언제 필요한가?**
+- 모든 기능 추가/수정/버그 픽스
+- 사용자에게 영향을 주는 모든 변경
+
+**버전 선택 기준**:
+- **Major**: Breaking changes
+- **Minor**: 새 기능 (하위 호환)
+- **Patch**: 버그 수정
+
+## 실전 가이드
+
+### 시나리오 1: 새 기능 개발
+
+1. **브랜치 생성**
+   - develop → feature/new-feature
+
+2. **개발 및 PR**
+   - Changeset 추가
+   - develop으로 PR 생성
+
+3. **자동 프로세스**
+   - PR 승인 → staging 자동 PR
+   - staging 승인 → 베타 배포
+   - main 자동 PR 대기
+
+### 시나리오 2: 베타 테스트 중 버그 발견
+
+1. **수정 작업**
+   - develop → fix/bug-in-beta
+   - 버그 수정 후 PR
+
+2. **자동 업데이트**
+   - 기존 staging PR에 커밋 추가
+   - QA 재테스트
+
+### 시나리오 3: 프로덕션 긴급 패치
+
+1. **Hotfix 생성**
+   - main → hotfix/critical-bug
+
+2. **빠른 배포**
+   - main PR 승인
+   - 즉시 태그 생성하여 배포
+
+### 자주 사용하는 명령어
+
+**개발**:
+```bash
+# feature 브랜치 생성
+git checkout develop
+git pull origin develop
+git checkout -b feature/my-feature
+
+# changeset 추가
+pnpm changeset
+```
+
+**릴리즈**:
+```bash
+# 태그 생성 (릴리즈 담당자)
+git checkout main
+git pull origin main
+git tag v1.2.0
+git push origin v1.2.0
+```
+
+### 트러블슈팅
+
+**문제: 자동 PR에 충돌 발생**
+- develop을 최신으로 업데이트 후 재시도
+- 수동으로 충돌 해결 후 푸시
+
+**문제: 동기화 실패**
+- 워크플로우 로그 확인
+- 수동 동기화 필요시 관리자 문의
+
+**문제: 베타 버전이 main에 반영 안 됨**
+- staging에 베타 태그 확인
+- main PR이 자동 생성되었는지 확인
+
+## 프로젝트 자동화 도구
+
+### Changesets
+- 버전 관리 자동화
+- CHANGELOG 자동 생성
+- 모노레포 지원
+
+### pnpm Workspace
+```
+vue3-pivottable/
+├── packages/
+│   ├── plotly-renderer/
+│   └── lazy-table-renderer/
+└── pnpm-workspace.yaml
+```
+
+### 릴리즈 스크립트
+- `scripts/release-packages.cjs`
+- 환경변수:
+  - NPM_TOKEN
+  - NPM_TOKEN_SUMIN
+  - RELEASE_TAG
+
+---
+
+*이 문서는 지속적으로 업데이트됩니다. 변경사항은 PR을 통해 제안해주세요.*
\ No newline at end of file
diff --git a/packages/lazy-table-renderer/README.md b/packages/lazy-table-renderer/README.md
index 8f9f083..eb85407 100644
--- a/packages/lazy-table-renderer/README.md
+++ b/packages/lazy-table-renderer/README.md
@@ -21,7 +21,7 @@ This component inherits all standard props from the `vue-pivottable` package, wi
 
 | Prop         | Type   | Default | Description                                                 |
 | ------------ | ------ | ------- | ----------------------------------------------------------- |
-| `chunkSize`  | Number | `20`    | Number of rows rendered per chunk                           |
+| `chunkSize`  | Number | `50`    | Number of rows rendered per chunk                           |
 | `bufferSize` | Number | `1`     | Number of chunks rendered before and after the visible area |
 
 All other props behave the same as in the original [`vue-pivottable`](https://github.com/vue-pivottable/vue3-pivottable) package.