@zuplo/cli 7.4.7 → 7.5.0

package/node_modules/slow-redact/.claude/settings.local.json

@@ -1,12 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm test)",
-      "Bash(node -e \"\nconst fs = require(''fs'');\nconst code = fs.readFileSync(''./index.js'', ''utf8'');\n\n// Extract just the parsePath function for testing\nconst parsePathMatch = code.match(/function parsePath \\(path\\) \\{[\\s\\S]*?\\n\\}/);\nif (!parsePathMatch) {\n  console.log(''Could not find parsePath function'');\n  process.exit(1);\n}\n\nconst parsePathCode = parsePathMatch[0];\neval(parsePathCode);\n\n// Test the problematic paths\nconsole.log(''Testing parsePath function...'');\nconsole.log(''parsePath(\"\"[\\\"\"\\\"\"\\\"\"]\\.c\"\"):'', parsePath(''[\\\"\"\\\"\"\\\"\"]\\.c'')); // [\"\"\"\"]\\.c\nconsole.log(''parsePath(\"\"[\\''\\'']\\.c\"\"):'', parsePath(''[\\\\''\\\\'']\\.c'')); // [\\''\\'']\\.c\nconsole.log(''parsePath(\"\"headers.authorization\"\"):'', parsePath(''headers.authorization'')); // should work\n\")",
-      "Bash(node -e \"\nconst fs = require(''fs'');\nconst code = fs.readFileSync(''./index.js'', ''utf8'');\n\n// Extract just the parsePath function for testing\nconst parsePathMatch = code.match(/function parsePath \\(path\\) \\{[\\s\\S]*?\\n\\}/);\nif (!parsePathMatch) {\n  console.log(''Could not find parsePath function'');\n  process.exit(1);\n}\n\nconst parsePathCode = parsePathMatch[0];\neval(parsePathCode);\n\n// Test the problematic paths\nconsole.log(''Testing parsePath function...'');\nconsole.log(''parsePath(\\\"\"[\\\\\\\"\"\\\\\\\"\"].c\\\"\"):'', parsePath(''[\\\"\"\\\"\"].c'')); // [\"\"\"\"]\\.c\nconsole.log(''parsePath(\\\"\"[\\\\'']\\\\].c\\\"\"):'', parsePath(''[\\\\''\\\\'']\\.c'')); // [\\''\\'']\\.c\nconsole.log(''parsePath(\\\"\"headers.authorization\\\"\"):'', parsePath(''headers.authorization'')); // should work\n\")",
-      "Bash(gh issue view:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/node_modules/slow-redact/.github/dependabot.yml

@@ -1,13 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    open-pull-requests-limit: 10
-
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    open-pull-requests-limit: 10

package/node_modules/slow-redact/.github/workflows/ci.yml

@@ -1,48 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - main
-      - 'v*'
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-
-# This allows a subsequently queued workflow run to interrupt previous runs
-concurrency:
-  group: "${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
-  cancel-in-progress: true
-
-jobs:
-  test:
-    name: ${{ matrix.node-version }} ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macOS-latest, windows-latest, ubuntu-latest]
-        node-version: [18, 20, 22, 24]
-
-    steps:
-      - name: Check out repo
-        uses: actions/checkout@v5.0.0
-        with:
-          persist-credentials: false
-
-      - name: Setup Node ${{ matrix.node-version }}
-        uses: actions/setup-node@v5
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Install dependencies
-        run: npm i --ignore-scripts
-
-      - name: Run tests
-        run: npm run test

package/node_modules/slow-redact/.github/workflows/publish-release.yml

@@ -1,43 +0,0 @@
-name: Publish release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'The version number to tag and release'
-        required: true
-        type: string
-      prerelease:
-        description: 'Release as pre-release'
-        required: false
-        type: boolean
-        default: false
-
-jobs:
-  release-npm:
-    runs-on: ubuntu-latest
-    environment: main
-    permissions:
-      contents: write
-      id-token: write
-    steps:
-      - uses: actions/checkout@ff7abcd0c3c05ccf6adc123a8cd1fd4fb30fb493 # v4
-      - uses: actions/setup-node@v5
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm install npm -g
-      - run: npm install
-      - name: Change version number and sync
-        run: |
-          node scripts/sync-version.mjs ${{ inputs.version }}
-      - name: GIT commit and push all changed files
-        run: |
-          git config --global user.name "mcollina"
-          git config --global user.email "hello@matteocollina.com"
-          git commit -n -a -m "Bumped v${{ inputs.version }}"
-          git push origin HEAD:${{ github.ref }}
-      - run: npm publish --access public --tag ${{ inputs.prerelease == true && 'next' || 'latest' }}
-      - name: 'Create release notes'
-        run: |
-          npx @matteo.collina/release-notes -a ${{ secrets.GITHUB_TOKEN }} -t v${{ inputs.version }} -r slow-redact -o pinojs ${{ github.event.inputs.prerelease == 'true' && '-p' || '' }} -c ${{ github.ref }}

package/node_modules/slow-redact/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 pinojs contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/slow-redact/README.md

@@ -1,350 +0,0 @@
-# slow-redact
-
-> Smart object redaction for JavaScript applications - safe AND fast!
-
-Redact JS objects with the same API as [fast-redact](https://github.com/davidmarkclements/fast-redact), but uses innovative **selective cloning** instead of mutating the original. This provides immutability guarantees with **performance competitive** to fast-redact for real-world usage patterns.
-
-## Install
-
-```bash
-npm install slow-redact
-```
-
-## Usage
-
-```js
-const slowRedact = require('slow-redact')
-
-const redact = slowRedact({
-  paths: ['headers.cookie', 'headers.authorization', 'user.password']
-})
-
-const obj = {
-  headers: {
-    cookie: 'secret-session-token',
-    authorization: 'Bearer abc123',
-    'x-forwarded-for': '192.168.1.1'
-  },
-  user: {
-    name: 'john',
-    password: 'secret123'
-  }
-}
-
-console.log(redact(obj))
-// Output: {"headers":{"cookie":"[REDACTED]","authorization":"[REDACTED]","x-forwarded-for":"192.168.1.1"},"user":{"name":"john","password":"[REDACTED]"}}
-
-// Original object is completely unchanged:
-console.log(obj.headers.cookie) // 'secret-session-token'
-```
-
-## API
-
-### slowRedact(options) → Function
-
-Creates a redaction function with the specified options.
-
-#### Options
-
-- **paths** `string[]` (required): An array of strings describing the nested location of a key in an object
-- **censor** `any` (optional, default: `'[REDACTED]'`): The value to replace sensitive data with. Can be a static value or function.
-- **serialize** `Function|boolean` (optional, default: `JSON.stringify`): Serialization function. Set to `false` to return the redacted object.
-- **remove** `boolean` (optional, default: `false`): Remove redacted keys from serialized output
-- **strict** `boolean` (optional, default: `true`): Throw on non-object values or pass through primitives
-
-#### Path Syntax
-
-Supports the same path syntax as fast-redact:
-
-- **Dot notation**: `'user.name'`, `'headers.cookie'`
-- **Bracket notation**: `'user["password"]'`, `'headers["X-Forwarded-For"]'`
-- **Array indices**: `'users[0].password'`, `'items[1].secret'`
-- **Wildcards**:
-  - Terminal: `'users.*.password'` (redacts password for all users)
-  - Intermediate: `'*.password'` (redacts password at any level)
-  - Array wildcard: `'items.*'` (redacts all array elements)
-
-#### Examples
-
-**Custom censor value:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  censor: '***HIDDEN***'
-})
-```
-
-**Dynamic censor function:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  censor: (value, path) => `REDACTED:${path}`
-})
-```
-
-**Return object instead of JSON string:**
-```js
-const redact = slowRedact({
-  paths: ['secret'],
-  serialize: false
-})
-
-const result = redact({ secret: 'hidden', public: 'data' })
-console.log(result.secret) // '[REDACTED]'
-console.log(result.public) // 'data'
-
-// Restore original values
-const restored = result.restore()
-console.log(restored.secret) // 'hidden'
-```
-
-**Custom serialization:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  serialize: obj => JSON.stringify(obj, null, 2)
-})
-```
-
-**Remove keys instead of redacting:**
-```js
-const redact = slowRedact({
-  paths: ['password', 'user.secret'],
-  remove: true
-})
-
-const obj = { username: 'john', password: 'secret123', user: { name: 'Jane', secret: 'hidden' } }
-console.log(redact(obj))
-// Output: {"username":"john","user":{"name":"Jane"}}
-// Note: 'password' and 'user.secret' are completely absent, not redacted
-```
-
-**Wildcard patterns:**
-```js
-// Redact all properties in secrets object
-const redact1 = slowRedact({ paths: ['secrets.*'] })
-
-// Redact password for any user
-const redact2 = slowRedact({ paths: ['users.*.password'] })
-
-// Redact all items in an array
-const redact3 = slowRedact({ paths: ['items.*'] })
-
-// Remove all secrets instead of redacting them
-const redact4 = slowRedact({ paths: ['secrets.*'], remove: true })
-```
-
-## Key Differences from fast-redact
-
-### Safety First
-- **No mutation**: Original objects are never modified
-- **Selective cloning**: Only clones paths that need redaction, shares references for everything else
-- **Restore capability**: Can restore original values when `serialize: false`
-
-### Feature Compatibility
-- **Remove option**: Full compatibility with fast-redact's `remove: true` option to completely omit keys from output
-- **All path patterns**: Supports same syntax including wildcards, bracket notation, and array indices
-- **Censor functions**: Dynamic censoring with path information passed as arrays
-- **Serialization**: Custom serializers and `serialize: false` mode
-
-### Smart Performance Approach
-- **Selective cloning**: Analyzes redaction paths and only clones necessary object branches
-- **Reference sharing**: Non-redacted properties maintain original object references
-- **Memory efficiency**: Dramatically reduced memory usage for large objects with minimal redaction
-- **Setup-time optimization**: Path analysis happens once during setup, not per redaction
-
-### When to Use slow-redact
-- When immutability is critical
-- When you need to preserve original objects
-- When objects are shared across multiple contexts
-- In functional programming environments
-- When debugging and you need to compare before/after
-- **Large objects with selective redaction** (now performance-competitive!)
-- When memory efficiency with reference sharing is important
-
-### When to Use fast-redact
-- When absolute maximum performance is critical
-- In extremely high-throughput scenarios (>100,000 ops/sec)
-- When you control the object lifecycle and mutation is acceptable
-- Very small objects where setup overhead matters
-
-## Performance Benchmarks
-
-slow-redact uses **selective cloning** that provides good performance while maintaining immutability guarantees:
-
-### Performance Results
-
-| Operation Type | slow-redact | fast-redact | Performance Ratio |
-|---------------|-------------|-------------|-------------------|
-| **Small objects** | ~690ns | ~200ns | ~3.5x slower |
-| **Large objects (minimal redaction)** | **~18μs** | ~17μs | **~same performance** |
-| **Large objects (wildcards)** | **~48μs** | ~37μs | **~1.3x slower** |
-| **No redaction (large objects)** | **~18μs** | ~17μs | **~same performance** |
-
-### Performance Improvements
-
-slow-redact is performance-competitive with fast-redact for large objects.
-
-1. **Selective cloning approach**: Only clones object paths that need redaction
-2. **Reference sharing**: Non-redacted properties share original object references
-3. **Setup-time optimization**: Path analysis happens once, not per redaction
-4. **Memory efficiency**: Dramatically reduced memory usage for typical use cases
-
-### Benchmark Details
-
-**Small Objects (~180 bytes)**:
-- slow-redact: **690ns** per operation
-- fast-redact: **200ns** per operation
-- **Slight setup overhead for small objects**
-
-**Large Objects (~18KB, minimal redaction)**:
-- slow-redact: **18μs** per operation
-- fast-redact: **17μs** per operation
-- Near-identical performance
-
-**Large Objects (~18KB, wildcard patterns)**:
-- slow-redact: **48μs** per operation
-- fast-redact: **37μs** per operation
-- Competitive performance for complex patterns
-
-**Memory Considerations**:
-- slow-redact: **Selective reference sharing** (much lower memory usage than before)
-- fast-redact: Mutates in-place (lowest memory usage)
-- Large objects with few redacted paths now share most references
-
-### When Performance Matters
-
-Choose **fast-redact** when:
-- Absolute maximum performance is critical (>100,000 ops/sec)
-- Working with very small objects frequently
-- Mutation is acceptable and controlled
-- Every microsecond counts
-
-Choose **slow-redact** when:
-- Immutability is required (with competitive performance)
-- Objects are shared across contexts
-- Large objects with selective redaction
-- Memory efficiency through reference sharing is important
-- Safety and functionality are priorities
-- Most production applications (performance gap is minimal)
-
-Run benchmarks yourself:
-```bash
-npm run bench
-```
-
-## How Selective Cloning Works
-
-slow-redact uses an innovative **selective cloning** approach that provides immutability guarantees while dramatically improving performance:
-
-### Traditional Approach (before optimization)
-```js
-// Old approach: Deep clone entire object, then redact
-const fullClone = deepClone(originalObject)  // Clone everything
-redact(fullClone, paths)                     // Then redact specific paths
-```
-
-### Selective Cloning Approach (current)
-```js
-// New approach: Analyze paths, clone only what's needed
-const pathStructure = buildPathStructure(paths)  // One-time setup
-const selectiveClone = cloneOnlyNeededPaths(obj, pathStructure)  // Smart cloning
-redact(selectiveClone, paths)  // Redact pre-identified paths
-```
-
-### Key Innovations
-
-1. **Path Analysis**: Pre-processes redaction paths into an efficient tree structure
-2. **Selective Cloning**: Only creates new objects for branches that contain redaction targets
-3. **Reference Sharing**: Non-redacted properties maintain exact same object references
-4. **Setup Optimization**: Path parsing happens once during redactor creation, not per redaction
-
-### Example: Reference Sharing in Action
-
-```js
-const largeConfig = {
-  database: { /* large config object */ },
-  api: { /* another large config */ },
-  secrets: { password: 'hidden', apiKey: 'secret' }
-}
-
-const redact = slowRedact({ paths: ['secrets.password'] })
-const result = redact(largeConfig)
-
-// Only secrets object is cloned, database and api share original references
-console.log(result.database === largeConfig.database)  // true - shared reference!
-console.log(result.api === largeConfig.api)            // true - shared reference!
-console.log(result.secrets === largeConfig.secrets)    // false - cloned for redaction
-```
-
-This approach provides **immutability where it matters** while **sharing references where it's safe**.
-
-## Remove Option
-
-The `remove: true` option provides full compatibility with fast-redact's key removal functionality:
-
-```js
-const redact = slowRedact({
-  paths: ['password', 'secrets.*', 'users.*.credentials'],
-  remove: true
-})
-
-const data = {
-  username: 'john',
-  password: 'secret123',
-  secrets: { apiKey: 'abc', token: 'xyz' },
-  users: [
-    { name: 'Alice', credentials: { password: 'pass1' } },
-    { name: 'Bob', credentials: { password: 'pass2' } }
-  ]
-}
-
-console.log(redact(data))
-// Output: {"username":"john","secrets":{},"users":[{"name":"Alice"},{"name":"Bob"}]}
-```
-
-### Remove vs Redact Behavior
-
-| Option | Behavior | Output Example |
-|--------|----------|----------------|
-| Default (redact) | Replaces values with censor | `{"password":"[REDACTED]"}` |
-| `remove: true` | Completely omits keys | `{}` |
-
-### Compatibility Notes
-
-- **Same output as fast-redact**: Identical JSON output when using `remove: true`
-- **Wildcard support**: Works with all wildcard patterns (`*`, `users.*`, `items.*.secret`)
-- **Array handling**: Array items are set to `undefined` (omitted in JSON output)
-- **Nested paths**: Supports deep removal (`users.*.credentials.password`)
-- **Serialize compatibility**: Only works with `JSON.stringify` serializer (like fast-redact)
-
-## Testing
-
-```bash
-# Run unit tests
-npm test
-
-# Run integration tests comparing with fast-redact
-npm run test:integration
-
-# Run all tests (unit + integration)
-npm run test:all
-
-# Run benchmarks
-npm run bench
-```
-
-### Test Coverage
-
-- **16 unit tests**: Core functionality and edge cases
-- **16 integration tests**: Output compatibility with fast-redact
-- **All major features**: Paths, wildcards, serialization, custom censors
-- **Performance benchmarks**: Direct comparison with fast-redact
-
-## License
-
-MIT
-
-## Contributing
-
-Pull requests welcome! Please ensure all tests pass and add tests for new features.

package/node_modules/slow-redact/benchmarks/basic.js

@@ -1,184 +0,0 @@
-const { bench, group, run } = require('mitata')
-const slowRedact = require('../index.js')
-const fastRedact = require('fast-redact')
-
-// Test objects
-const smallObj = {
-  user: { name: 'john', password: 'secret123' },
-  headers: { cookie: 'session-token', authorization: 'Bearer abc123' }
-}
-
-const largeObj = {
-  users: [],
-  metadata: {
-    version: '1.0.0',
-    secret: 'app-secret-key',
-    database: {
-      host: 'localhost',
-      password: 'db-password'
-    }
-  }
-}
-
-// Populate users array with for loop instead of Array.from
-for (let i = 0; i < 100; i++) {
-  largeObj.users.push({
-    id: i,
-    name: `user${i}`,
-    email: `user${i}@example.com`,
-    password: `secret${i}`,
-    profile: {
-      age: 20 + (i % 50),
-      preferences: {
-        theme: 'dark',
-        notifications: true,
-        apiKey: `key-${i}-secret`
-      }
-    }
-  })
-}
-
-// Redaction configurations
-const basicSlowRedact = slowRedact({
-  paths: ['user.password', 'headers.cookie']
-})
-
-const basicFastRedact = fastRedact({
-  paths: ['user.password', 'headers.cookie']
-})
-
-const wildcardSlowRedact = slowRedact({
-  paths: ['users.*.password', 'users.*.profile.preferences.apiKey']
-})
-
-const wildcardFastRedact = fastRedact({
-  paths: ['users.*.password', 'users.*.profile.preferences.apiKey']
-})
-
-const deepSlowRedact = slowRedact({
-  paths: ['metadata.secret', 'metadata.database.password']
-})
-
-const deepFastRedact = fastRedact({
-  paths: ['metadata.secret', 'metadata.database.password']
-})
-
-group('Small Object Redaction - slow-redact', () => {
-  bench('basic paths', () => {
-    basicSlowRedact(smallObj)
-  })
-
-  bench('serialize: false', () => {
-    const redact = slowRedact({
-      paths: ['user.password'],
-      serialize: false
-    })
-    redact(smallObj)
-  })
-
-  bench('custom censor function', () => {
-    const redact = slowRedact({
-      paths: ['user.password'],
-      censor: (value, path) => `HIDDEN:${path}`
-    })
-    redact(smallObj)
-  })
-})
-
-group('Small Object Redaction - fast-redact', () => {
-  bench('basic paths', () => {
-    basicFastRedact(smallObj)
-  })
-
-  bench('serialize: false', () => {
-    const redact = fastRedact({
-      paths: ['user.password'],
-      serialize: false
-    })
-    redact(smallObj)
-  })
-
-  bench('custom censor function', () => {
-    const redact = fastRedact({
-      paths: ['user.password'],
-      censor: (value, path) => `HIDDEN:${path}`
-    })
-    redact(smallObj)
-  })
-})
-
-group('Large Object Redaction - slow-redact', () => {
-  bench('wildcard patterns', () => {
-    wildcardSlowRedact(largeObj)
-  })
-
-  bench('deep nested paths', () => {
-    deepSlowRedact(largeObj)
-  })
-
-  bench('multiple wildcards', () => {
-    const redact = slowRedact({
-      paths: ['users.*.password', 'users.*.profile.preferences.*']
-    })
-    redact(largeObj)
-  })
-})
-
-group('Large Object Redaction - fast-redact', () => {
-  bench('wildcard patterns', () => {
-    wildcardFastRedact(largeObj)
-  })
-
-  bench('deep nested paths', () => {
-    deepFastRedact(largeObj)
-  })
-
-  bench('multiple wildcards', () => {
-    const redact = fastRedact({
-      paths: ['users.*.password', 'users.*.profile.preferences.*']
-    })
-    redact(largeObj)
-  })
-})
-
-group('Direct Performance Comparison', () => {
-  bench('slow-redact - basic paths', () => {
-    basicSlowRedact(smallObj)
-  })
-
-  bench('fast-redact - basic paths', () => {
-    basicFastRedact(smallObj)
-  })
-
-  bench('slow-redact - wildcards', () => {
-    wildcardSlowRedact(largeObj)
-  })
-
-  bench('fast-redact - wildcards', () => {
-    wildcardFastRedact(largeObj)
-  })
-})
-
-group('Object Cloning Overhead', () => {
-  bench('slow-redact - no redaction (clone only)', () => {
-    const redact = slowRedact({ paths: [] })
-    redact(smallObj)
-  })
-
-  bench('fast-redact - no redaction', () => {
-    const redact = fastRedact({ paths: [] })
-    redact(smallObj)
-  })
-
-  bench('slow-redact - large object clone', () => {
-    const redact = slowRedact({ paths: [] })
-    redact(largeObj)
-  })
-
-  bench('fast-redact - large object', () => {
-    const redact = fastRedact({ paths: [] })
-    redact(largeObj)
-  })
-})
-
-run()

package/node_modules/slow-redact/eslint.config.js

@@ -1 +0,0 @@
-module.exports = require('neostandard')()