.github/workflows/codeql.yml

@@ -20,8 +20,6 @@ on:
   schedule:
     - cron: '24 3 * * 1'
 
-permissions: {}
-
 jobs:
   analyze:
     name: Analyze
@@ -40,11 +38,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@v6
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -55,7 +53,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+      uses: github/codeql-action/autobuild@v4
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -69,4 +67,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+      uses: github/codeql-action/analyze@v4

.github/workflows/docker-githubaction.yml

@@ -1,107 +0,0 @@
-name: Release Docker GitHub Action
-
-on:
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  publishGithubActionDocker:
-    environment: dockerhub
-    env:
-      IMAGE_NAME: mikefarah/yq
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@06116385d9baf250c9f4dcb4858b16962ea869c3 # v4.1.0
-        with:
-          platforms: all
-
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
-        with:
-          version: latest
-
-      - name: Verify Dockerfile base image digest matches yq:4
-        run: |
-          PINNED_DIGEST=$(grep -oE 'sha256:[a-f0-9]{64}' github-action/Dockerfile | head -1)
-          if [ -z "${PINNED_DIGEST}" ]; then
-            echo "::error::Could not find a sha256 digest in github-action/Dockerfile"
-            exit 1
-          fi
-
-          LATEST_DIGEST=$(docker buildx imagetools inspect "${IMAGE_NAME}:4" --format '{{printf "%s" .Manifest.Digest}}')
-
-          echo "Dockerfile pins: ${PINNED_DIGEST}"
-          echo "mikefarah/yq:4 is:  ${LATEST_DIGEST}"
-
-          if [ "${PINNED_DIGEST}" != "${LATEST_DIGEST}" ]; then
-            echo "::error::github-action/Dockerfile digest does not match the current mikefarah/yq:4 image"
-            echo "Update the FROM line in github-action/Dockerfile to:"
-            echo "  FROM mikefarah/yq:4@${LATEST_DIGEST}"
-            exit 1
-          fi
-
-      - name: Resolve version from yq:4
-        run: |
-          IMAGE_VERSION=$(docker run --rm "${IMAGE_NAME}:4" --version | awk '{print $NF}' | sed 's/^v//')
-          if [ -z "${IMAGE_VERSION}" ]; then
-            echo "::error::Could not determine yq version from ${IMAGE_NAME}:4"
-            exit 1
-          fi
-          echo "Resolved yq version: ${IMAGE_VERSION}"
-          echo "IMAGE_VERSION=${IMAGE_VERSION}" >> "${GITHUB_ENV}"
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push github-action image
-        working-directory: github-action
-        run: |
-          PLATFORMS="linux/amd64,linux/ppc64le,linux/arm64,linux/arm/v7,linux/s390x"
-
-          echo "Building and pushing github-action image for version ${IMAGE_VERSION}"
-          docker buildx build \
-            --label "org.opencontainers.image.authors=https://github.com/mikefarah/yq/graphs/contributors" \
-            --label "org.opencontainers.image.created=$(date --rfc-3339=seconds)" \
-            --label "org.opencontainers.image.description=yq is a portable command-line data file processor" \
-            --label "org.opencontainers.image.documentation=https://mikefarah.gitbook.io/yq/" \
-            --label "org.opencontainers.image.licenses=MIT" \
-            --label "org.opencontainers.image.revision=$(git rev-parse HEAD)" \
-            --label "org.opencontainers.image.source=https://github.com/mikefarah/yq" \
-            --label "org.opencontainers.image.title=yq" \
-            --label "org.opencontainers.image.url=https://mikefarah.gitbook.io/yq/" \
-            --label "org.opencontainers.image.version=${IMAGE_VERSION}" \
-            --platform "${PLATFORMS}" \
-            --pull \
-            --push \
-            -t "${IMAGE_NAME}:${IMAGE_VERSION}-githubaction" \
-            -t "${IMAGE_NAME}:4-githubaction" \
-            -t "${IMAGE_NAME}:latest-githubaction" \
-            -t "ghcr.io/${IMAGE_NAME}:${IMAGE_VERSION}-githubaction" \
-            -t "ghcr.io/${IMAGE_NAME}:4-githubaction" \
-            -t "ghcr.io/${IMAGE_NAME}:latest-githubaction" \
-            .
-
-      - name: Report action.yml digest to pin
-        run: |
-          GITHUBACTION_DIGEST=$(docker buildx imagetools inspect "${IMAGE_NAME}:4-githubaction" --format '{{printf "%s" .Manifest.Digest}}')
-          echo "Published ${IMAGE_NAME}:4-githubaction at ${GITHUBACTION_DIGEST}"
-          echo "Update action.yml image to:"
-          echo "  docker://${IMAGE_NAME}:4-githubaction@${GITHUBACTION_DIGEST}"

.github/workflows/docker-release.yml

@@ -7,28 +7,23 @@ on:
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
-permissions: {}
-
 jobs:
   publishDocker:
     environment: dockerhub
     env:
       IMAGE_NAME: mikefarah/yq
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@v6
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@06116385d9baf250c9f4dcb4858b16962ea869c3 # v4.1.0
+        uses: docker/setup-qemu-action@v3
         with:
           platforms: all
 
       - name: Set up Docker Buildx
         id: buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+        uses: docker/setup-buildx-action@v3
         with:
           version: latest
 
@@ -36,13 +31,13 @@ jobs:
         run: echo ${{ steps.buildx.outputs.platforms }} && docker version
 
       - name: Login to Docker Hub
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -80,3 +75,26 @@ jobs:
             -t "ghcr.io/${IMAGE_NAME}:4" \
             -t "ghcr.io/${IMAGE_NAME}:latest" \
             .
+
+          cd github-action
+          docker buildx build \
+            --label "org.opencontainers.image.authors=https://github.com/mikefarah/yq/graphs/contributors" \
+            --label "org.opencontainers.image.created=$(date --rfc-3339=seconds)" \
+            --label "org.opencontainers.image.description=yq is a portable command-line data file processor" \
+            --label "org.opencontainers.image.documentation=https://mikefarah.gitbook.io/yq/" \
+            --label "org.opencontainers.image.licenses=MIT" \
+            --label "org.opencontainers.image.revision=$(git rev-parse HEAD)" \
+            --label "org.opencontainers.image.source=https://github.com/mikefarah/yq" \
+            --label "org.opencontainers.image.title=yq" \
+            --label "org.opencontainers.image.url=https://mikefarah.gitbook.io/yq/" \
+            --label "org.opencontainers.image.version=${IMAGE_VERSION}" \
+            --platform "${PLATFORMS}" \
+            --pull \
+            --push \
+            -t "${IMAGE_NAME}:${IMAGE_VERSION}-githubaction" \
+            -t "${IMAGE_NAME}:4-githubaction" \
+            -t "${IMAGE_NAME}:latest-githubaction" \
+            -t "ghcr.io/${IMAGE_NAME}:${IMAGE_VERSION}-githubaction" \
+            -t "ghcr.io/${IMAGE_NAME}:4-githubaction" \
+            -t "ghcr.io/${IMAGE_NAME}:latest-githubaction" \
+            .

.github/workflows/go.yml

@@ -5,51 +5,25 @@ permissions:
 
 jobs:
 
-  verify-action-digest:
-    name: Verify action.yml image digest
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
-
-      - name: Verify action.yml digest matches published image
-        run: |
-          PINNED_DIGEST=$(grep -oE 'sha256:[a-f0-9]{64}' action.yml | head -1)
-          if [ -z "${PINNED_DIGEST}" ]; then
-            echo "::error::action.yml does not pin the runtime image by digest"
-            exit 1
-          fi
-
-          LATEST_DIGEST=$(docker buildx imagetools inspect docker.io/mikefarah/yq:4-githubaction --format '{{printf "%s" .Manifest.Digest}}')
-
-          echo "action.yml pins:              ${PINNED_DIGEST}"
-          echo "mikefarah/yq:4-githubaction: ${LATEST_DIGEST}"
-
-          if [ "${PINNED_DIGEST}" != "${LATEST_DIGEST}" ]; then
-            echo "::error::action.yml digest does not match the current mikefarah/yq:4-githubaction image"
-            echo "Update the image line in action.yml to:"
-            echo "  docker://mikefarah/yq:4-githubaction@${LATEST_DIGEST}"
-            exit 1
-          fi
-
   build:
     name: Build
     runs-on: ubuntu-latest
     steps:
 
     - name: Set up Go
-      uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
+      uses: actions/setup-go@v6
       with:
         go-version: '^1.20'
       id: go
 
     - name: Check out code into the Go module directory
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@v6
 
     - name: Get dependencies
       run: |
         go get -v -t -d ./...
         if [ -f Gopkg.toml ]; then
-            curl -sSfL https://raw.githubusercontent.com/golang/dep/1f7c19e5f52f49ffb9f956f64c010be14683468b/install.sh | env DEP_RELEASE_TAG=v0.5.4 sh
+            curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
             dep ensure
         fi
 

.github/workflows/release.yml

@@ -5,17 +5,12 @@ on:
       - 'v4.*'
       - 'draft-*'
 
-permissions: {}
-
 jobs:
   publishGitRelease:
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      id-token: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@v6
-      - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
+      - uses: actions/setup-go@v6
         with:
           go-version: '^1.20'
           check-latest: true
@@ -29,7 +24,7 @@ jobs:
         run: echo "VERSION=${GITHUB_REF##*/}" >> "${GITHUB_OUTPUT}"
 
       - name: Generate man page
-        uses: docker://pandoc/core:2.14.2@sha256:04e127c6642a2b9d447c26fe0ac6a5932efa8f508eda9f07da51b6e621dd7c19
+        uses: docker://pandoc/core:2.14.2
         id: gen-man-page
         with:
           args: >-
@@ -42,22 +37,14 @@ jobs:
             --output=yq.1
             man.md
 
-      - name: Install cosign
-        uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6 # v4.1.2
-
       - name: Cross compile
         run: |
           sudo apt-get install rhash -y
-          go install github.com/goreleaser/goreleaser/v2@v2.16.0
+          go install github.com/goreleaser/goreleaser/v2@latest
           ./scripts/xcompile.sh
 
-      - name: Sign checksums
-        run: |
-          cosign sign-blob --yes --bundle build/checksums.bundle build/checksums
-          cosign sign-blob --yes --bundle build/checksums-bsd.bundle build/checksums-bsd
-
       - name: Release
-        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
+        uses: softprops/action-gh-release@v1
         with:
           files: build/*
           draft: true

.github/workflows/scorecard.yml

@@ -1,78 +0,0 @@
-# This workflow uses actions that are not certified by GitHub. They are provided
-# by a third-party and are governed by separate terms of service, privacy
-# policy, and support documentation.
-
-name: Scorecard supply-chain security
-on:
-  # For Branch-Protection check. Only the default branch is supported. See
-  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
-  branch_protection_rule:
-  # To guarantee Maintained check is occasionally updated. See
-  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
-  schedule:
-    - cron: '39 7 * * 2'
-  push:
-    branches: [ "master" ]
-
-# Declare default permissions as read only.
-permissions: read-all
-
-jobs:
-  analysis:
-    name: Scorecard analysis
-    runs-on: ubuntu-latest
-    # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.
-    if: github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request'
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Needed to publish results and get a badge (see publish_results below).
-      id-token: write
-      # Uncomment the permissions below if installing in a private repository.
-      # contents: read
-      # actions: read
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
-          # - you want to enable the Branch-Protection check on a *public* repository, or
-          # - you are installing Scorecard on a *private* repository
-          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
-          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
-
-          # Public repositories:
-          #   - Publish results to OpenSSF REST API for easy access by consumers
-          #   - Allows the repository to include the Scorecard badge.
-          #   - See https://github.com/ossf/scorecard-action#publishing-results.
-          # For private repositories:
-          #   - `publish_results` will always be set to `false`, regardless
-          #     of the value entered here.
-          publish_results: true
-
-          # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore
-          # file_mode: git
-
-      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
-      # format to the repository Actions tab.
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      # Upload the results to GitHub's code scanning dashboard (optional).
-      # Commenting out will disable upload of results to your repo's Code Scanning dashboard
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
-        with:
-          sarif_file: results.sarif

.github/workflows/snap-release.yml

@@ -7,23 +7,19 @@ on:
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
-permissions: {}
-
 jobs:
     buildSnap:
       environment: snap
       runs-on: ubuntu-latest
-      permissions:
-        contents: read
       steps:
-        - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        - uses: actions/checkout@v6
-        - uses: snapcore/action-build@3bdaa03e1ba6bf59a65f84a751d943d549a54e79 # v1.3.0
+        - uses: snapcore/action-build@v1
           id: build
           env:
             SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.STORE_LOGIN }}
           with:
             snapcraft-args: "remote-build --launchpad-accept-public-upload"
-        - uses: snapcore/action-publish@214b86e5ca036ead1668c79afb81e550e6c54d40 # v1.2.0
+        - uses: snapcore/action-publish@v1
           env:
             SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.STORE_LOGIN }}
           with:

.github/workflows/test-yq.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@v6
       - name: Get test
         id: get_value
         uses: mikefarah/yq@master

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.26.4@sha256:792443b89f65105abba56b9bd5e97f680a80074ac62fc844a584212f8c8102c3 AS builder
+FROM golang:1.26.0 AS builder
 
 WORKDIR /go/src/mikefarah/yq
 
@@ -10,7 +10,7 @@ RUN ./scripts/acceptance.sh
 
 # Choose alpine as a base image to make this useful for CI, as many
 # CI tools expect an interactive shell inside the container
-FROM alpine:3@sha256:28bd5fe8b56d1bd048e5babf5b10710ebe0bae67db86916198a6eec434943f8b AS production
+FROM alpine:3 AS production
 LABEL maintainer="Mike Farah <mikefarah@users.noreply.github.com>"
 
 COPY --from=builder /go/src/mikefarah/yq/yq /usr/bin/yq

Dockerfile.dev

@@ -1,4 +1,8 @@
-FROM golang:1.26.4@sha256:792443b89f65105abba56b9bd5e97f680a80074ac62fc844a584212f8c8102c3
+FROM golang:1.26.0
+
+RUN apt-get update && \
+    apt-get install -y npm && \
+    npm install -g npx cspell@latest
 
 COPY scripts/devtools.sh /opt/devtools.sh
 

Makefile

@@ -42,7 +42,7 @@ quiet: # this is silly but shuts up 'Nothing to be done for `local`'
 	@:
 
 prepare: tmp/dev_image_id
-tmp/dev_image_id: Dockerfile.dev scripts/devtools.sh _typos.toml
+tmp/dev_image_id: Dockerfile.dev scripts/devtools.sh
 	@mkdir -p tmp
 	@${ENGINE} rmi -f ${DEV_IMAGE} > /dev/null 2>&1 || true
 	@${ENGINE} build -t ${DEV_IMAGE} -f Dockerfile.dev .

SECURITY.md

@@ -1,26 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please **do not** report security vulnerabilities through public GitHub issues.
-
-Instead, use GitHub's private vulnerability reporting feature:
-👉 https://github.com/mikefarah/yq/security
-
-This allows vulnerabilities to be triaged and addressed confidentially before any public disclosure.
-
-## Scope
-
-### HTTP / TLS / Network vulnerabilities
-
-yq is a command-line YAML/JSON/TOML processor that reads from files or standard input and writes to standard output. **yq does not include any HTTP or network libraries** and makes no network connections at runtime. CVEs related to HTTP, TLS, or networking are therefore **not applicable** to yq.
-
-### Dependency version bumps
-
-yq uses [Dependabot](https://docs.github.com/en/code-security/dependabot) to automatically raise pull requests for:
-
-- Go module dependencies
-- Go toolchain version
-- Docker base images
-
-Please **do not** raise pull requests or issues solely to bump dependency or Go versions — Dependabot handles this automatically and the maintainers merge those PRs regularly.

_typos.toml

@@ -1,20 +0,0 @@
-[files]
-extend-exclude = ["vendor", "bin"]
-
-[default]
-locale = "en"
-extend-ignore-identifiers-re = [
-  "NdJson",
-]
-
-[default.extend-identifiers]
-AttributeIDSupressMenu = "AttributeIDSupressMenu"
-
-[default.extend-words]
-Teh = "Teh"
-teh = "teh"
-Supress = "Supress"
-HashiCorp = "HashiCorp"
-Hashi = "Hashi"
-fot = "fot"
-nd = "nd"

action.yml

@@ -12,6 +12,6 @@ outputs:
     description: "The complete result from the yq command being run"
 runs:
   using: 'docker'
-  image: 'docker://mikefarah/yq:4-githubaction@sha256:e1b8c865f299ea6b02910a7ddf147d5d431244d4cc116f89c2148c9f53822906'
+  image: 'docker://mikefarah/yq:4-githubaction'
   args:
     - ${{ inputs.cmd }}

agents.md

@@ -1,79 +1,3 @@
-# yq — agent instructions
-
-## ⚠️ MANDATORY: GitHub agent disclosure
-
-**Always required. No exceptions.**
-
-Whenever you perform **any** GitHub action on behalf of the user, you **must** disclose that an AI agent (Cursor) wrote the content and is acting on the user's behalf — **not the user personally**. Do this **before** submitting; never post first and add the disclosure later.
-
-Applies to **all** GitHub interactions, including:
-
-- Pull requests (titles, descriptions, and reviews)
-- PR comments and inline review comments
-- Issues (new issues, comments, and updates)
-- Any other post or reply on GitHub
-
-**How to disclose:** Put it prominently at the **top** of every PR description, review body, comment, or issue. Use wording like:
-
-
-Inline review comments must include a short disclosure too (e.g. `> Generated by Cursor acting on the user's behalf, not the user personally.`).
-
-**Never** submit a GitHub action without this disclosure.
-
----
-
-Always run the spellcheck before raising a PR:
-
-```bash
-bash scripts/spelling.sh
-```
-
-This is also included in the full CI pipeline via `make local test`.
-
-## Cursor Cloud specific instructions
-
-### Overview
-
-**yq** is a Go CLI for querying and transforming YAML, JSON, XML, INI, and other structured formats. There are no long-running services — development is build-and-test against a local `./yq` binary.
-
-### Prerequisites
-
-- **Go ≥ 1.25** (see `go.mod`)
-- **Bash** (acceptance tests)
-- **Docker/Podman** is optional; use `make local <target>` to run natively when containers are unavailable
-
-### PATH
-
-After `scripts/devtools.sh`, add Go tool binaries to PATH:
-
-```bash
-export PATH="$HOME/go/bin:$PATH"
-```
-
-`golangci-lint` and `typos` install to `$HOME/go/bin`; `gosec` installs to `./bin/gosec` in the repo root.
-
-### Common commands (local, no Docker)
-
-| Task | Command |
-|------|---------|
-| Install dev tools | `bash scripts/devtools.sh` |
-| Vendor dependencies | `make local vendor` |
-| Build binary | `go build -o yq .` or `make local build` |
-| Format | `make local format` |
-| Lint | `make local check` |
-| Unit tests | `make local test` or `bash scripts/test.sh` |
-| Acceptance (E2E) | `bash scripts/acceptance.sh` (requires `./yq` built first) |
-
-`make local build` runs the full CI chain (format → spelling → gosec → lint → unit tests → build → acceptance). For a faster loop, build with `go build -o yq .` and run `bash scripts/acceptance.sh`.
-
-### Caveats
-
-- **`make` without `local`** tries Docker/Podman (`Dockerfile.dev`). In Cloud Agent VMs without Docker, always prefix with `make local`.
-- **Spelling step** uses `typos` (installed by `scripts/devtools.sh`).
-- **`make local test` / `scripts/check.sh`** require `golangci-lint` on PATH (`devtools.sh`).
-
----
-
 # General rules
 ✅ **DO:**
 - You can use ./yq with the `--debug-node-info` flag to get a deeper understanding of the ast.
@@ -81,12 +5,10 @@ export PATH="$HOME/go/bin:$PATH"
 - Add comprehensive tests to cover the changes
 - Run test suite to ensure there is no regression
 - Use UK english spelling
-- **Follow the mandatory GitHub agent disclosure rule above** on every GitHub action — no exceptions
 
 ❌ **DON'T:**
 - Git add or commit
 - Add comments to functions that are self-explanatory
-- **Post to GitHub without the mandatory agent disclosure** (PRs, reviews, comments, issues, or any other GitHub interaction)
 
 
 

cmd/evaluate_all_command.go

@@ -101,15 +101,12 @@ func evaluateAll(cmd *cobra.Command, args []string) (cmdError error) {
 	}
 
 	if frontMatter != "" {
-		originalFilename := args[0]
 		frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
 		err = frontMatterHandler.Split()
 		if err != nil {
 			return err
 		}
 		args[0] = frontMatterHandler.GetYamlFrontMatterFilename()
-		yqlib.SetFilenameAlias(args[0], originalFilename)
-		defer yqlib.ClearFilenameAliases()
 
 		if frontMatter == "process" {
 			reader := frontMatterHandler.GetContentReader()

cmd/evaluate_all_command_test.go

@@ -13,7 +13,6 @@ func TestCreateEvaluateAllCommand(t *testing.T) {
 
 	if cmd == nil {
 		t.Fatal("createEvaluateAllCommand returned nil")
-		return
 	}
 
 	// Test basic command properties

cmd/evaluate_sequence_command.go

@@ -122,15 +122,12 @@ func evaluateSequence(cmd *cobra.Command, args []string) (cmdError error) {
 
 	if frontMatter != "" {
 		yqlib.GetLogger().Debug("using front matter handler")
-		originalFilename := args[0]
 		frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
 		err = frontMatterHandler.Split()
 		if err != nil {
 			return err
 		}
 		args[0] = frontMatterHandler.GetYamlFrontMatterFilename()
-		yqlib.SetFilenameAlias(args[0], originalFilename)
-		defer yqlib.ClearFilenameAliases()
 
 		if frontMatter == "process" {
 			reader := frontMatterHandler.GetContentReader()

cmd/evaluate_sequence_command_test.go

@@ -13,7 +13,6 @@ func TestCreateEvaluateSequenceCommand(t *testing.T) {
 
 	if cmd == nil {
 		t.Fatal("createEvaluateSequenceCommand returned nil")
-		return
 	}
 
 	// Test basic command properties

cmd/root.go

@@ -2,12 +2,12 @@ package cmd
 
 import (
 	"fmt"
-	"log/slog"
 	"os"
 	"strings"
 
 	"github.com/mikefarah/yq/v4/pkg/yqlib"
 	"github.com/spf13/cobra"
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 type runeValue rune
@@ -68,21 +68,30 @@ yq -P -oy sample.json
 		},
 		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
 			cmd.SetOut(cmd.OutOrStdout())
+			level := logging.WARNING
+			stringFormat := `[%{level}] %{color}%{time:15:04:05}%{color:reset} %{message}`
 
 			// when NO_COLOR environment variable presents and not an empty string the coloured output should be disabled;
 			// refer to no-color.org
 			forceNoColor = forceNoColor || os.Getenv("NO_COLOR") != ""
 
-			level := slog.LevelWarn
+			if verbose && forceNoColor {
-			if verbose {
+				level = logging.DEBUG
-				level = slog.LevelDebug
+				stringFormat = `[%{level:5.5s}] %{time:15:04:05} %{shortfile:-33s} %{shortfunc:-25s} %{message}`
+			} else if verbose {
+				level = logging.DEBUG
+				stringFormat = `[%{level:5.5s}] %{color}%{time:15:04:05}%{color:bold} %{shortfile:-33s} %{shortfunc:-25s}%{color:reset} %{message}`
+			} else if forceNoColor {
+				stringFormat = `[%{level}] %{time:15:04:05} %{message}`
 			}
 
-			yqlib.GetLogger().SetLevel(level)
+			var format = logging.MustStringFormatter(stringFormat)
-			opts := &slog.HandlerOptions{Level: level, AddSource: verbose}
+			var backend = logging.AddModuleLevel(
-			handler := slog.NewTextHandler(os.Stderr, opts)
+				logging.NewBackendFormatter(logging.NewLogBackend(os.Stderr, "", 0), format))
-			yqlib.GetLogger().SetSlogger(slog.New(handler))
 
+			backend.SetLevel(level, "")
+
+			logging.SetBackend(backend)
 			yqlib.InitExpressionParser()
 
 			return nil
@@ -156,8 +165,6 @@ yq -P -oy sample.json
 	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredLuaPreferences.UnquotedKeys, "lua-unquoted", yqlib.ConfiguredLuaPreferences.UnquotedKeys, "output unquoted string keys (e.g. {foo=\"bar\"})")
 	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredLuaPreferences.Globals, "lua-globals", yqlib.ConfiguredLuaPreferences.Globals, "output keys as top-level global variables")
 
-	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredINIPreferences.PreserveSurroundedQuote, "ini-preserve-quotes", yqlib.ConfiguredINIPreferences.PreserveSurroundedQuote, "preserve surrounding quotes on INI values during round-trip")
-
 	rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredPropertiesPreferences.KeyValueSeparator, "properties-separator", yqlib.ConfiguredPropertiesPreferences.KeyValueSeparator, "separator to use between keys and values")
 	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredPropertiesPreferences.UseArrayBrackets, "properties-array-brackets", yqlib.ConfiguredPropertiesPreferences.UseArrayBrackets, "use [x] in array paths (e.g. for SpringBoot)")
 
@@ -214,7 +221,6 @@ yq -P -oy sample.json
 
 	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredSecurityPreferences.DisableEnvOps, "security-disable-env-ops", "", false, "Disable env related operations.")
 	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredSecurityPreferences.DisableFileOps, "security-disable-file-ops", "", false, "Disable file related operations (e.g. load)")
-	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredSecurityPreferences.EnableSystemOps, "security-enable-system-operator", "", false, "Enable system operator to allow execution of external commands.")
 
 	rootCmd.AddCommand(
 		createEvaluateSequenceCommand(),

cmd/root_test.go

@@ -195,7 +195,6 @@ func TestNew(t *testing.T) {
 
 	if rootCmd == nil {
 		t.Fatal("New() returned nil")
-		return
 	}
 
 	// Test basic command properties

cmd/utils.go

@@ -3,12 +3,12 @@ package cmd
 import (
 	"fmt"
 	"io"
-	"log/slog"
 	"os"
 	"strings"
 
 	"github.com/mikefarah/yq/v4/pkg/yqlib"
 	"github.com/spf13/cobra"
+	"gopkg.in/op/go-logging.v1"
 )
 
 func isAutomaticOutputFormat() bool {
@@ -104,8 +104,8 @@ func configureFormats(args []string) error {
 		return err
 	}
 
-	yqlib.GetLogger().Debugf("Using input format %v", inputFormat)
+	yqlib.GetLogger().Debug("Using input format %v", inputFormat)
-	yqlib.GetLogger().Debugf("Using output format %v", outputFormat)
+	yqlib.GetLogger().Debug("Using output format %v", outputFormat)
 
 	return nil
 }
@@ -117,7 +117,7 @@ func configureInputFormat(inputFilename string) error {
 		_, err := yqlib.FormatFromString(inputFormat)
 		if err != nil {
 			// unknown file type, default to yaml
-			yqlib.GetLogger().Debugf("Unknown file format extension '%v', defaulting to yaml", inputFormat)
+			yqlib.GetLogger().Debug("Unknown file format extension '%v', defaulting to yaml", inputFormat)
 			inputFormat = "yaml"
 			if isAutomaticOutputFormat() {
 				outputFormat = "yaml"
@@ -132,7 +132,7 @@ func configureInputFormat(inputFilename string) error {
 		//
 		outputFormat = yqlib.FormatStringFromFilename(inputFilename)
 		if inputFilename != "-" {
-			yqlib.GetLogger().Warningf("yq default output is now 'auto' (based on the filename extension). Normally yq would output '%v', but for backwards compatibility 'yaml' has been set. Please use -oy to specify yaml, or drop the -p flag.", outputFormat)
+			yqlib.GetLogger().Warning("yq default output is now 'auto' (based on the filename extension). Normally yq would output '%v', but for backwards compatibility 'yaml' has been set. Please use -oy to specify yaml, or drop the -p flag.", outputFormat)
 		}
 		outputFormat = "yaml"
 	}
@@ -235,7 +235,7 @@ func maybeFile(str string) bool {
 	yqlib.GetLogger().Debugf("checking '%v' is a file", str)
 	stat, err := os.Stat(str) // #nosec
 	result := err == nil && !stat.IsDir()
-	if yqlib.GetLogger().IsEnabledFor(slog.LevelDebug) {
+	if yqlib.GetLogger().IsEnabledFor(logging.DEBUG) {
 		if err != nil {
 			yqlib.GetLogger().Debugf("error: %v", err)
 		} else {
@@ -280,7 +280,7 @@ func processArgs(originalArgs []string) (string, []string, error) {
 
 	if expressionFile == "" && maybeFirstArgIsAFile && strings.HasSuffix(args[0], ".yq") {
 		// lets check if an expression file was given
-		yqlib.GetLogger().Debugf("Assuming arg %v is an expression file", args[0])
+		yqlib.GetLogger().Debug("Assuming arg %v is an expression file", args[0])
 		expressionFile = args[0]
 		args = args[1:]
 	}
@@ -296,7 +296,7 @@ func processArgs(originalArgs []string) (string, []string, error) {
 
 	yqlib.GetLogger().Debugf("processed args: %v", args)
 	if expression == "" && len(args) > 0 && args[0] != "-" && !maybeFile(args[0]) {
-		yqlib.GetLogger().Debugf("assuming expression is '%v'", args[0])
+		yqlib.GetLogger().Debug("assuming expression is '%v'", args[0])
 		expression = args[0]
 		args = args[1:]
 	}

cmd/utils_test.go

@@ -911,7 +911,7 @@ func stringsEqual(a, b []string) bool {
 		return false
 	}
 	for i := range a {
-		if a[i] != b[i] { //nolint:gosec // G602 false positive: b length equality is checked above
+		if a[i] != b[i] {
 			return false
 		}
 	}

cmd/version.go

@@ -11,7 +11,7 @@ var (
 	GitDescribe string
 
 	// Version is main version number that is being run at the moment.
-	Version = "v4.53.3"
+	Version = "v4.52.4"
 
 	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
 	// then it means that it is a final release. Otherwise, this is a pre-release

cspell.config.yaml

@@ -0,0 +1,14 @@
+---
+$schema: https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
+version: '0.2'
+language: en-GB
+dictionaryDefinitions:
+  - name: project-words
+    path: './project-words.txt'
+    addWords: true
+dictionaries:
+  - project-words
+ignorePaths:
+  - 'vendor'
+  - 'bin'
+  - '/project-words.txt'

github-action/Dockerfile

@@ -1,4 +1,4 @@
-FROM mikefarah/yq:4@sha256:11a1f0b604b13dbbdc662260d8db6f644b22d8553122a25c1b5b2e8713ca6977
+FROM mikefarah/yq:4
 
 COPY entrypoint.sh /entrypoint.sh
 

go.mod

@@ -6,23 +6,24 @@ require (
 	github.com/alecthomas/repr v0.5.2
 	github.com/dimchansky/utfbom v1.1.1
 	github.com/elliotchance/orderedmap v1.8.0
-	github.com/fatih/color v1.19.0
+	github.com/fatih/color v1.18.0
 	github.com/go-ini/ini v1.67.0
-	github.com/goccy/go-json v0.10.6
+	github.com/goccy/go-json v0.10.5
 	github.com/goccy/go-yaml v1.19.2
 	github.com/hashicorp/hcl/v2 v2.24.0
 	github.com/jinzhu/copier v0.4.0
 	github.com/magiconair/properties v1.8.10
-	github.com/pelletier/go-toml/v2 v2.4.2
+	github.com/pelletier/go-toml/v2 v2.2.4
 	github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/pflag v1.0.10
-	github.com/yuin/gopher-lua v1.1.2
+	github.com/yuin/gopher-lua v1.1.1
-	github.com/zclconf/go-cty v1.18.1
+	github.com/zclconf/go-cty v1.17.0
-	go.yaml.in/yaml/v4 v4.0.0-rc.6
+	go.yaml.in/yaml/v4 v4.0.0-rc.3
-	golang.org/x/mod v0.37.0
+	golang.org/x/mod v0.33.0
-	golang.org/x/net v0.56.0
+	golang.org/x/net v0.50.0
-	golang.org/x/text v0.38.0
+	golang.org/x/text v0.34.0
+	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
 )
 
 require (
@@ -33,9 +34,11 @@ require (
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
-	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
-	golang.org/x/tools v0.45.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
 )
 
-go 1.25.0
+go 1.24.0
+
+toolchain go1.24.1

go.sum

@@ -18,14 +18,14 @@ github.com/dimchansky/utfbom v1.1.1 h1:vV6w1AhK4VMnhBno/TPVCoK9U/LP0PkLCS9tbxHdi
 github.com/dimchansky/utfbom v1.1.1/go.mod h1:SxdoEBH5qIqFocHMyGOXVAybYJdr71b1Q/j0mACtrfE=
 github.com/elliotchance/orderedmap v1.8.0 h1:TrOREecvh3JbS+NCgwposXG5ZTFHtEsQiCGOhPElnMw=
 github.com/elliotchance/orderedmap v1.8.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
-github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
 github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
 github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
 github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
-github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU=
+github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
 github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
@@ -46,8 +46,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
-github.com/pelletier/go-toml/v2 v2.4.2 h1:M2fKKbmyvI+hGId/D0W64qDBMVhJnNR10O5gIbMc//Q=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.4.2/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -61,28 +61,30 @@ github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3A
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/yuin/gopher-lua v1.1.2 h1:yF/FjE3hD65tBbt0VXLE13HWS9h34fdzJmrWRXwobGA=
+github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
-github.com/yuin/gopher-lua v1.1.2/go.mod h1:7aRmXIWl37SqRf0koeyylBEzJ+aPt8A+mmkQ4f1ntR8=
+github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-github.com/zclconf/go-cty v1.18.1 h1:yEGE8M4iIZlyKQURZNb2SnEyZlZHUcBCnx6KF81KuwM=
+github.com/zclconf/go-cty v1.17.0 h1:seZvECve6XX4tmnvRzWtJNHdscMtYEx5R7bnnVyd/d0=
-github.com/zclconf/go-cty v1.18.1/go.mod h1:qpnV6EDNgC1sns/AleL1fvatHw72j+S+nS+MJ+T2CSg=
+github.com/zclconf/go-cty v1.17.0/go.mod h1:wqFzcImaLTI6A5HfsRwB0nj5n0MRZFwmey8YoFPPs3U=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-go.yaml.in/yaml/v4 v4.0.0-rc.6 h1:1h7H1ohdUh93/FyE4YaDa1Zh64K6VVbjF4K6WUxMtH4=
+go.yaml.in/yaml/v4 v4.0.0-rc.3 h1:3h1fjsh1CTAPjW7q/EMe+C8shx5d8ctzZTrLcs/j8Go=
-go.yaml.in/yaml/v4 v4.0.0-rc.6/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
+go.yaml.in/yaml/v4 v4.0.0-rc.3/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
-golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
+golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
+golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
-golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
-golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
+golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
-golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
+golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
-golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
-golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473 h1:6D+BvnJ/j6e222UW8s2qTSe3wGBtvo0MbVQG/c5k8RE=
+gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473/go.mod h1:N1eN2tsCx0Ydtgjl4cqmbRCsY4/+z4cYDeqwZTk6zog=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

go_install_test.go

@@ -1,5 +1,3 @@
-//go:build goinstall
-
 package main
 
 import (
@@ -13,10 +11,6 @@ import (
 // TestGoInstallCompatibility ensures the module can be zipped for go install.
 // This is an integration test that uses the same zip.CreateFromDir function
 // that go install uses internally. If this test fails, go install will fail.
-//
-// Built with the goinstall tag and run after the main test suite (see scripts/test.sh)
-// so it does not race with pkg/yqlib tests that rewrite doc/*.md during execution.
-//
 // See: https://github.com/mikefarah/yq/issues/2587
 func TestGoInstallCompatibility(t *testing.T) {
 	mod := module.Version{

pkg/yqlib/all_at_once_evaluator_test.go

@@ -54,25 +54,3 @@ func TestAllAtOnceEvaluateNodes(t *testing.T) {
 		test.AssertResultComplex(t, tt.expected, resultsToString(t, list))
 	}
 }
-
-func TestTomlDecoderCanBeReinitializedAcrossDocuments(t *testing.T) {
-	decoder := NewTomlDecoder()
-
-	firstDocuments, err := ReadDocuments(strings.NewReader("id = \"Foobar\"\n"), decoder)
-	if err != nil {
-		t.Fatalf("failed to read first TOML document: %v", err)
-	}
-	if firstDocuments.Len() != 1 {
-		t.Fatalf("expected first document count to be 1, got %d", firstDocuments.Len())
-	}
-	test.AssertResult(t, "Foobar", firstDocuments.Front().Value.(*CandidateNode).Content[1].Value)
-
-	secondDocuments, err := ReadDocuments(strings.NewReader("id = \"Banana\"\n"), decoder)
-	if err != nil {
-		t.Fatalf("failed to read second TOML document: %v", err)
-	}
-	if secondDocuments.Len() != 1 {
-		t.Fatalf("expected second document count to be 1, got %d", secondDocuments.Len())
-	}
-	test.AssertResult(t, "Banana", secondDocuments.Front().Value.(*CandidateNode).Content[1].Value)
-}

pkg/yqlib/candidate_node.go

@@ -27,30 +27,10 @@ const (
 	FlowStyle
 )
 
-// EncodeHint controls how a mapping node is serialised by format-specific encoders
-// that distinguish between inline and block/section representations (e.g. TOML, HCL).
-type EncodeHint int
-
-const (
-	// EncodeHintDefault lets the encoder choose the representation (e.g. TOML block
-	// mappings default to [section] headers).
-	EncodeHintDefault EncodeHint = iota
-	// EncodeHintSeparateBlock forces the node to be emitted as a separate block or
-	// table-section header (used by TOML [section] and HCL block decoders).
-	EncodeHintSeparateBlock
-	// EncodeHintInline forces the node to be emitted as an inline / flow table
-	// (used by TOML inline-table decoder and TOML encoder).
-	EncodeHintInline
-)
-
 func createStringScalarNode(stringValue string) *CandidateNode {
 	var node = &CandidateNode{Kind: ScalarNode}
 	node.Value = stringValue
-	if stringValue == "<<" {
+	node.Tag = "!!str"
-		node.Tag = "!!merge"
-	} else {
-		node.Tag = "!!str"
-	}
 	return node
 }
 
@@ -117,9 +97,9 @@ type CandidateNode struct {
 	// (e.g. top level cross document merge). This property does not propagate to child nodes.
 	EvaluateTogether bool
 	IsMapKey         bool
-	// EncodeHint controls how a mapping node is serialised by format-specific encoders
+	// For formats like HCL and TOML: indicates that child entries should be emitted as separate blocks/tables
-	// (e.g. TOML, HCL) that support both inline and block/section representations.
+	// rather than consolidated into nested mappings (default behaviour)
-	EncodeHint EncodeHint
+	EncodeSeparate bool
 }
 
 func (n *CandidateNode) CreateChild() *CandidateNode {
@@ -300,7 +280,7 @@ func (n *CandidateNode) AddChild(rawChild *CandidateNode) {
 
 func (n *CandidateNode) AddChildren(children []*CandidateNode) {
 	if n.Kind == MappingNode {
-		for i := 0; i < len(children)-1; i += 2 {
+		for i := 0; i < len(children); i += 2 {
 			key := children[i]
 			value := children[i+1]
 			n.AddKeyValueChild(key, value)
@@ -343,11 +323,11 @@ func (n *CandidateNode) guessTagFromCustomType() string {
 	dataBucket, errorReading := parseSnippet(n.Value)
 
 	if errorReading != nil {
-		log.Debugf("guessTagFromCustomType: could not guess underlying tag type %v", errorReading)
+		log.Debug("guessTagFromCustomType: could not guess underlying tag type %v", errorReading)
 		return n.Tag
 	}
 	guessedTag := dataBucket.Tag
-	log.Infof("im guessing the tag %v is a %v", n.Tag, guessedTag)
+	log.Info("im guessing the tag %v is a %v", n.Tag, guessedTag)
 	return guessedTag
 }
 
@@ -431,7 +411,7 @@ func (n *CandidateNode) doCopy(cloneContent bool) *CandidateNode {
 		EvaluateTogether: n.EvaluateTogether,
 		IsMapKey:         n.IsMapKey,
 
-		EncodeHint: n.EncodeHint,
+		EncodeSeparate: n.EncodeSeparate,
 	}
 
 	if cloneContent {
@@ -465,7 +445,7 @@ func (n *CandidateNode) UpdateFrom(other *CandidateNode, prefs assignPreferences
 }
 
 func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode, prefs assignPreferences) {
-	log.Debugf("UpdateAttributesFrom: n: %v other: %v", NodeToString(n), NodeToString(other))
+	log.Debug("UpdateAttributesFrom: n: %v other: %v", NodeToString(n), NodeToString(other))
 	if n.Kind != other.Kind {
 		// clear out the contents when switching to a different type
 		// e.g. map to array
@@ -485,8 +465,8 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode, prefs assignP
 		n.Anchor = other.Anchor
 	}
 
-	// Preserve EncodeHint for format-specific encoding hints
+	// Preserve EncodeSeparate flag for format-specific encoding hints
-	n.EncodeHint = other.EncodeHint
+	n.EncodeSeparate = other.EncodeSeparate
 
 	// merge will pickup the style of the new thing
 	// when autocreating nodes

pkg/yqlib/candidate_node_goccy_yaml.go

@@ -36,13 +36,13 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 					switch commentMapComment.Position {
 					case yaml.CommentHeadPosition:
 						o.HeadComment = comment.String()
-						log.Debugf("its a head comment %v", comment.String())
+						log.Debug("its a head comment %v", comment.String())
 					case yaml.CommentLinePosition:
 						o.LineComment = comment.String()
-						log.Debugf("its a line comment %v", comment.String())
+						log.Debug("its a line comment %v", comment.String())
 					case yaml.CommentFootPosition:
 						o.FootComment = comment.String()
-						log.Debugf("its a foot comment %v", comment.String())
+						log.Debug("its a foot comment %v", comment.String())
 					}
 				}
 			}
@@ -93,8 +93,8 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 			log.Debugf("folded Type %v", astLiteral.Start.Type)
 			o.Style = FoldedStyle
 		}
-		log.Debugf("start value: %v ", node.(*ast.LiteralNode).Start.Value)
+		log.Debug("start value: %v ", node.(*ast.LiteralNode).Start.Value)
-		log.Debugf("start value: %v ", node.(*ast.LiteralNode).Start.Type)
+		log.Debug("start value: %v ", node.(*ast.LiteralNode).Start.Type)
 		// TODO: here I could put the original value with line breaks
 		// to solve the multiline > problem
 		o.Value = astLiteral.Value.Value
@@ -187,7 +187,7 @@ func (o *CandidateNode) UnmarshalGoccyYAML(node ast.Node, cm yaml.CommentMap, an
 }
 
 func (o *CandidateNode) goccyProcessMappingValueNode(mappingEntry *ast.MappingValueNode, cm yaml.CommentMap, anchorMap map[string]*CandidateNode) error {
-	log.Debugf("UnmarshalYAML MAP KEY entry %v", mappingEntry.Key)
+	log.Debug("UnmarshalYAML MAP KEY entry %v", mappingEntry.Key)
 
 	// AddKeyValueFirst because it clones the nodes, and we want to have the real refs when Unmarshalling
 	// particularly for the anchorMap
@@ -197,7 +197,7 @@ func (o *CandidateNode) goccyProcessMappingValueNode(mappingEntry *ast.MappingVa
 		return err
 	}
 
-	log.Debugf("UnmarshalYAML MAP VALUE entry %v", mappingEntry.Value)
+	log.Debug("UnmarshalYAML MAP VALUE entry %v", mappingEntry.Value)
 	if err := valueNode.UnmarshalGoccyYAML(mappingEntry.Value, cm, anchorMap); err != nil {
 		return err
 	}

pkg/yqlib/candidate_node_test.go

@@ -106,31 +106,6 @@ func TestCreateScalarNodeScenarios(t *testing.T) {
 	}
 }
 
-type createStringScalarNodeScenario struct {
-	stringValue string
-	expectedTag string
-}
-
-var createStringScalarNodeScenarios = []createStringScalarNodeScenario{
-	{
-		stringValue: "yourKey",
-		expectedTag: "!!str",
-	},
-	{
-		stringValue: "<<",
-		expectedTag: "!!merge",
-	},
-}
-
-func TestCreateStringScalarNodeScenarios(t *testing.T) {
-	for _, tt := range createStringScalarNodeScenarios {
-		actual := createStringScalarNode(tt.stringValue)
-		test.AssertResultWithContext(t, tt.stringValue, actual.Value, fmt.Sprintf("Value for: %v", tt.stringValue))
-		test.AssertResultWithContext(t, tt.expectedTag, actual.Tag, fmt.Sprintf("Tag for: %v", tt.stringValue))
-		test.AssertResultWithContext(t, ScalarNode, actual.Kind, fmt.Sprintf("Kind for: %v", tt.stringValue))
-	}
-}
-
 func TestGetKeyForMapValue(t *testing.T) {
 	key := createStringScalarNode("yourKey")
 	n := CandidateNode{Key: key, Value: "meow", document: 3}

pkg/yqlib/candidate_node_yaml.go

@@ -55,13 +55,13 @@ func (o *CandidateNode) copyFromYamlNode(node *yaml.Node, anchorMap map[string]*
 
 	if o.Anchor != "" {
 		anchorMap[o.Anchor] = o
-		log.Debugf("set anchor %v to %v", o.Anchor, NodeToString(o))
+		log.Debug("set anchor %v to %v", o.Anchor, NodeToString(o))
 	}
 
 	// its a single alias
 	if node.Alias != nil && node.Alias.Anchor != "" {
 		o.Alias = anchorMap[node.Alias.Anchor]
-		log.Debugf("set alias to %v", NodeToString(anchorMap[node.Alias.Anchor]))
+		log.Debug("set alias to %v", NodeToString(anchorMap[node.Alias.Anchor]))
 	}
 	o.HeadComment = node.HeadComment
 	o.LineComment = node.LineComment
@@ -106,7 +106,7 @@ func (o *CandidateNode) UnmarshalYAML(node *yaml.Node, anchorMap map[string]*Can
 	log.Debugf("UnmarshalYAML %v", node.Tag)
 	switch node.Kind {
 	case yaml.AliasNode:
-		log.Debugf("UnmarshalYAML - alias from yaml: %v", o.Tag)
+		log.Debug("UnmarshalYAML - alias from yaml: %v", o.Tag)
 		o.Kind = AliasNode
 		o.copyFromYamlNode(node, anchorMap)
 		return nil
@@ -176,15 +176,15 @@ func (o *CandidateNode) UnmarshalYAML(node *yaml.Node, anchorMap map[string]*Can
 }
 
 func (o *CandidateNode) MarshalYAML() (*yaml.Node, error) {
-	log.Debugf("MarshalYAML to yaml: %v", o.Tag)
+	log.Debug("MarshalYAML to yaml: %v", o.Tag)
 	switch o.Kind {
 	case AliasNode:
-		log.Debugf("MarshalYAML - alias to yaml: %v", o.Tag)
+		log.Debug("MarshalYAML - alias to yaml: %v", o.Tag)
 		target := &yaml.Node{Kind: yaml.AliasNode}
 		o.copyToYamlNode(target)
 		return target, nil
 	case ScalarNode:
-		log.Debugf("MarshalYAML - scalar: %v", o.Value)
+		log.Debug("MarshalYAML - scalar: %v", o.Value)
 		target := &yaml.Node{Kind: yaml.ScalarNode}
 		o.copyToYamlNode(target)
 		return target, nil

pkg/yqlib/candidiate_node_json.go

@@ -7,9 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
-	"strconv"
-	"strings"
 
 	"github.com/goccy/go-json"
 )
@@ -123,7 +120,7 @@ func (o *CandidateNode) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return err
 	}
-	log.Debugf("UnmarshalJSON -  scalar is %v", scalar)
+	log.Debug("UnmarshalJSON -  scalar is %v", scalar)
 
 	return o.setScalarFromJson(scalar)
 
@@ -143,12 +140,6 @@ func (o *CandidateNode) MarshalJSON() ([]byte, error) {
 		return buf.Bytes(), err
 	case ScalarNode:
 		log.Debugf("MarshalJSON ScalarNode")
-		if o.guessTagFromCustomType() == "!!float" {
-			if raw, ok := jsonFloatLiteral(o.Value); ok {
-				buf.WriteString(raw)
-				return buf.Bytes(), nil
-			}
-		}
 		value, err := o.GetValueRep()
 		if err != nil {
 			return buf.Bytes(), err
@@ -186,85 +177,3 @@ func (o *CandidateNode) MarshalJSON() ([]byte, error) {
 		return buf.Bytes(), err
 	}
 }
-
-// jsonFloatLiteral returns a JSON-shaped representation of a YAML !!float scalar
-// value, preserving the original textual form (e.g. "50.0" stays "50.0") whenever
-// possible. The second return value is false when the value cannot be safely
-// rendered as a JSON number (e.g. ".inf", ".nan", or anything that parses to a
-// non-finite float); callers should fall back to the normal encoding path in
-// that case, which preserves the existing behaviour for those inputs.
-func jsonFloatLiteral(raw string) (string, bool) {
-	if raw == "" {
-		return "", false
-	}
-	f, err := strconv.ParseFloat(raw, 64)
-	if err != nil {
-		return "", false
-	}
-	if math.IsInf(f, 0) || math.IsNaN(f) {
-		return "", false
-	}
-	if isJSONNumberLiteral(raw) {
-		return raw, true
-	}
-	formatted := strconv.FormatFloat(f, 'f', -1, 64)
-	if !strings.ContainsAny(formatted, ".eE") {
-		formatted += ".0"
-	}
-	return formatted, true
-}
-
-// isJSONNumberLiteral reports whether s is already a valid JSON number literal
-// representing a fractional value (i.e. contains a "." or an exponent), so it
-// can be emitted verbatim without round-tripping through a float64.
-func isJSONNumberLiteral(s string) bool {
-	if s == "" {
-		return false
-	}
-	i := 0
-	if s[i] == '-' {
-		i++
-		if i == len(s) {
-			return false
-		}
-	}
-	// integer part: 0 or [1-9][0-9]*
-	if s[i] == '0' {
-		i++
-	} else if s[i] >= '1' && s[i] <= '9' {
-		for i < len(s) && s[i] >= '0' && s[i] <= '9' {
-			i++
-		}
-	} else {
-		return false
-	}
-	hasFraction := false
-	if i < len(s) && s[i] == '.' {
-		hasFraction = true
-		i++
-		if i == len(s) || s[i] < '0' || s[i] > '9' {
-			return false
-		}
-		for i < len(s) && s[i] >= '0' && s[i] <= '9' {
-			i++
-		}
-	}
-	hasExponent := false
-	if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
-		hasExponent = true
-		i++
-		if i < len(s) && (s[i] == '+' || s[i] == '-') {
-			i++
-		}
-		if i == len(s) || s[i] < '0' || s[i] > '9' {
-			return false
-		}
-		for i < len(s) && s[i] >= '0' && s[i] <= '9' {
-			i++
-		}
-	}
-	if i != len(s) {
-		return false
-	}
-	return hasFraction || hasExponent
-}

pkg/yqlib/chown_linux.go

@@ -18,7 +18,7 @@ func changeOwner(info fs.FileInfo, file *os.File) error {
 			// this happens with snap confinement
 			// not really a big issue as users can chown
 			// the file themselves if required.
-			log.Infof("Skipping chown: %v", err)
+			log.Info("Skipping chown: %v", err)
 		}
 	}
 	return nil

pkg/yqlib/context.go

@@ -3,8 +3,9 @@ package yqlib
 import (
 	"container/list"
 	"fmt"
-	"log/slog"
 	"time"
+
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 type Context struct {
@@ -74,7 +75,7 @@ func (n *Context) ChildContext(results *list.List) Context {
 }
 
 func (n *Context) ToString() string {
-	if !log.IsEnabledFor(slog.LevelDebug) {
+	if !log.IsEnabledFor(logging.DEBUG) {
 		return ""
 	}
 	result := fmt.Sprintf("Context\nDontAutoCreate: %v\n", n.DontAutoCreate)

pkg/yqlib/context_test.go

@@ -2,11 +2,11 @@ package yqlib
 
 import (
 	"container/list"
-	"log/slog"
 	"strings"
 	"testing"
 
 	"github.com/mikefarah/yq/v4/test"
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 func TestChildContext(t *testing.T) {
@@ -155,8 +155,8 @@ func TestToString(t *testing.T) {
 	test.AssertResultComplex(t, "", result)
 
 	// Test with debug logging enabled
-	GetLogger().SetLevel(slog.LevelDebug)
+	logging.SetLevel(logging.DEBUG, "")
-	defer GetLogger().SetLevel(slog.LevelWarn) // Reset to default
+	defer logging.SetLevel(logging.INFO, "") // Reset to default
 
 	result2 := context.ToString()
 	test.AssertResultComplex(t, true, len(result2) > 0)

pkg/yqlib/data_tree_navigator.go

@@ -2,7 +2,8 @@ package yqlib
 
 import (
 	"fmt"
-	"log/slog"
+
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 type DataTreeNavigator interface {
@@ -54,7 +55,7 @@ func (d *dataTreeNavigator) GetMatchingNodes(context Context, expressionNode *Ex
 		return context, nil
 	}
 	log.Debugf("Processing Op: %v", expressionNode.Operation.toString())
-	if log.IsEnabledFor(slog.LevelDebug) {
+	if log.IsEnabledFor(logging.DEBUG) {
 		for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 			log.Debug(NodeToString(el.Value.(*CandidateNode)))
 		}

pkg/yqlib/decoder_hcl.go

@@ -226,7 +226,7 @@ func addBlockToMapping(parent *CandidateNode, block *hclsyntax.Block, src []byte
 		// Mark the type node if there are multiple blocks of this type at this level
 		// This tells the encoder to emit them as separate blocks rather than consolidating them
 		if isMultipleBlocksOfType {
-			typeNode.EncodeHint = EncodeHintSeparateBlock
+			typeNode.EncodeSeparate = true
 		}
 	}
 	current = typeNode

pkg/yqlib/decoder_ini.go

@@ -12,20 +12,17 @@ import (
 type iniDecoder struct {
 	reader   io.Reader
 	finished bool // Flag to signal completion of processing
-	prefs    INIPreferences
 }
 
-func NewINIDecoder(prefs INIPreferences) Decoder {
+func NewINIDecoder() Decoder {
 	return &iniDecoder{
 		finished: false, // Initialise the flag as false
-		prefs:    prefs,
 	}
 }
 
 func (dec *iniDecoder) Init(reader io.Reader) error {
 	// Store the reader for use in Decode
 	dec.reader = reader
-	dec.finished = false
 	return nil
 }
 
@@ -42,10 +39,7 @@ func (dec *iniDecoder) Decode() (*CandidateNode, error) {
 	}
 
 	// Parse the INI content
-	loadOpts := ini.LoadOptions{
+	cfg, err := ini.Load(content)
-		PreserveSurroundedQuote: dec.prefs.PreserveSurroundedQuote,
-	}
-	cfg, err := ini.LoadSources(loadOpts, content)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse INI content: %w", err)
 	}

pkg/yqlib/decoder_properties.go

@@ -16,11 +16,10 @@ type propertiesDecoder struct {
 	reader   io.Reader
 	finished bool
 	d        DataTreeNavigator
-	prefs    PropertiesPreferences
 }
 
 func NewPropertiesDecoder() Decoder {
-	return &propertiesDecoder{d: NewDataTreeNavigator(), finished: false, prefs: ConfiguredPropertiesPreferences.Copy()}
+	return &propertiesDecoder{d: NewDataTreeNavigator(), finished: false}
 }
 
 func (dec *propertiesDecoder) Init(reader io.Reader) error {
@@ -29,56 +28,20 @@ func (dec *propertiesDecoder) Init(reader io.Reader) error {
 	return nil
 }
 
-func parsePropKey(key string, prefs PropertiesPreferences) []interface{} {
+func parsePropKey(key string) []interface{} {
 	pathStrArray := strings.Split(key, ".")
-	path := make([]interface{}, 0, len(pathStrArray))
+	path := make([]interface{}, len(pathStrArray))
-	for _, pathStr := range pathStrArray {
+	for i, pathStr := range pathStrArray {
-		path = appendPropKeySegment(path, pathStr, prefs.UseArrayBrackets)
+		num, err := strconv.ParseInt(pathStr, 10, 32)
+		if err == nil {
+			path[i] = num
+		} else {
+			path[i] = pathStr
+		}
 	}
 	return path
 }
 
-func appendPropKeySegment(path []interface{}, segment string, useArrayBrackets bool) []interface{} {
-	if useArrayBrackets && strings.Contains(segment, "[") {
-		bracketPath, ok := parsePropKeyArrayBracketSegment(segment)
-		if ok {
-			return append(path, bracketPath...)
-		}
-	}
-
-	num, err := strconv.ParseInt(segment, 10, 32)
-	if err == nil {
-		return append(path, num)
-	}
-	return append(path, segment)
-}
-
-func parsePropKeyArrayBracketSegment(segment string) ([]interface{}, bool) {
-	path := []interface{}{}
-	bracketIndex := strings.Index(segment, "[")
-	if bracketIndex > 0 {
-		path = append(path, segment[:bracketIndex])
-	}
-
-	remaining := segment[bracketIndex:]
-	for remaining != "" {
-		if !strings.HasPrefix(remaining, "[") {
-			return nil, false
-		}
-		closingBracket := strings.Index(remaining, "]")
-		if closingBracket < 0 {
-			return nil, false
-		}
-		arrayIndex, err := strconv.ParseInt(remaining[1:closingBracket], 10, 32)
-		if err != nil {
-			return nil, false
-		}
-		path = append(path, arrayIndex)
-		remaining = remaining[closingBracket+1:]
-	}
-	return path, true
-}
-
 func (dec *propertiesDecoder) processComment(c string) string {
 	if c == "" {
 		return ""
@@ -112,7 +75,7 @@ func (dec *propertiesDecoder) applyPropertyComments(context Context, path []inte
 
 func (dec *propertiesDecoder) applyProperty(context Context, properties *properties.Properties, key string) error {
 	value, _ := properties.Get(key)
-	path := parsePropKey(key, dec.prefs)
+	path := parsePropKey(key)
 
 	propertyComments := properties.GetComments(key)
 	if len(propertyComments) > 0 {

pkg/yqlib/decoder_test.go

@@ -68,7 +68,7 @@ func mustProcessFormatScenario(s formatScenario, decoder Decoder, encoder Encode
 
 	result, err := processFormatScenario(s, decoder, encoder)
 	if err != nil {
-		log.Errorf("Bad scenario %v: %v", s.description, err)
+		log.Error("Bad scenario %v: %w", s.description, err)
 		return fmt.Sprintf("Bad scenario %v: %v", s.description, err.Error())
 	}
 	return result

pkg/yqlib/decoder_toml.go

@@ -44,7 +44,6 @@ func (dec *tomlDecoder) Init(reader io.Reader) error {
 	}
 	dec.pendingComments = make([]string, 0)
 	dec.firstContentSeen = false
-	dec.finished = false
 	return nil
 }
 
@@ -106,7 +105,7 @@ func (dec *tomlDecoder) decodeKeyValuesIntoMap(rootMap *CandidateNode, tomlNode
 
 	for dec.parser.NextExpression() {
 		nextItem := dec.parser.Expression()
-		log.Debugf("decodeKeyValuesIntoMap -- next exp, its a %v", nextItem.Kind)
+		log.Debug("decodeKeyValuesIntoMap -- next exp, its a %v", nextItem.Kind)
 
 		switch nextItem.Kind {
 		case toml.KeyValue:
@@ -118,7 +117,7 @@ func (dec *tomlDecoder) decodeKeyValuesIntoMap(rootMap *CandidateNode, tomlNode
 			dec.pendingComments = append(dec.pendingComments, string(nextItem.Data))
 		default:
 			// run out of key values
-			log.Debugf("done in decodeKeyValuesIntoMap, gota a %v", nextItem.Kind)
+			log.Debug("done in decodeKeyValuesIntoMap, gota a %v", nextItem.Kind)
 			return true, nil
 		}
 	}
@@ -150,10 +149,9 @@ func (dec *tomlDecoder) createInlineTableMap(tomlNode *toml.Node) (*CandidateNod
 	}
 
 	return &CandidateNode{
-		Kind:       MappingNode,
+		Kind:    MappingNode,
-		Tag:        "!!map",
+		Tag:     "!!map",
-		EncodeHint: EncodeHintInline,
+		Content: content,
-		Content:    content,
 	}, nil
 }
 
@@ -272,7 +270,7 @@ func (dec *tomlDecoder) Decode() (*CandidateNode, error) {
 
 		currentNode := dec.parser.Expression()
 
-		log.Debugf("currentNode: %v ", currentNode.Kind)
+		log.Debug("currentNode: %v ", currentNode.Kind)
 		runAgainstCurrentExp, err = dec.processTopLevelNode(currentNode)
 		if err != nil {
 			return dec.rootMap, err
@@ -299,7 +297,7 @@ func (dec *tomlDecoder) Decode() (*CandidateNode, error) {
 func (dec *tomlDecoder) processTopLevelNode(currentNode *toml.Node) (bool, error) {
 	var runAgainstCurrentExp bool
 	var err error
-	log.Debugf("processTopLevelNode: Going to process %v state is current %v", currentNode.Kind, NodeToString(dec.rootMap))
+	log.Debug("processTopLevelNode: Going to process %v state is current %v", currentNode.Kind, NodeToString(dec.rootMap))
 	switch currentNode.Kind {
 	case toml.Comment:
 		// Collect comment to attach to next element
@@ -327,7 +325,7 @@ func (dec *tomlDecoder) processTopLevelNode(currentNode *toml.Node) (bool, error
 		runAgainstCurrentExp, err = dec.decodeKeyValuesIntoMap(dec.rootMap, currentNode)
 	}
 
-	log.Debugf("processTopLevelNode: DONE Processing state is now %v", NodeToString(dec.rootMap))
+	log.Debug("processTopLevelNode: DONE Processing state is now %v", NodeToString(dec.rootMap))
 	return runAgainstCurrentExp, err
 }
 
@@ -335,7 +333,7 @@ func (dec *tomlDecoder) processTable(currentNode *toml.Node) (bool, error) {
 	log.Debug("Enter processTable")
 	child := currentNode.Child()
 	fullPath := dec.getFullPath(child)
-	log.Debugf("fullpath: %v", fullPath)
+	log.Debug("fullpath: %v", fullPath)
 
 	c := Context{}
 	c = c.SingleChildContext(dec.rootMap)
@@ -346,10 +344,10 @@ func (dec *tomlDecoder) processTable(currentNode *toml.Node) (bool, error) {
 	}
 
 	tableNodeValue := &CandidateNode{
-		Kind:       MappingNode,
+		Kind:           MappingNode,
-		Tag:        "!!map",
+		Tag:            "!!map",
-		Content:    make([]*CandidateNode, 0),
+		Content:        make([]*CandidateNode, 0),
-		EncodeHint: EncodeHintSeparateBlock,
+		EncodeSeparate: true,
 	}
 
 	// Attach pending head comments to the table
@@ -403,7 +401,7 @@ func (dec *tomlDecoder) processTable(currentNode *toml.Node) (bool, error) {
 }
 
 func (dec *tomlDecoder) arrayAppend(context Context, path []interface{}, rhsNode *CandidateNode) error {
-	log.Debugf("arrayAppend to path: %v,%v", path, NodeToString(rhsNode))
+	log.Debug("arrayAppend to path: %v,%v", path, NodeToString(rhsNode))
 	rhsCandidateNode := &CandidateNode{
 		Kind:    SequenceNode,
 		Tag:     "!!seq",
@@ -428,7 +426,7 @@ func (dec *tomlDecoder) processArrayTable(currentNode *toml.Node) (bool, error)
 	log.Debug("Enter processArrayTable")
 	child := currentNode.Child()
 	fullPath := dec.getFullPath(child)
-	log.Debugf("Fullpath: %v", fullPath)
+	log.Debug("Fullpath: %v", fullPath)
 
 	c := Context{}
 	c = c.SingleChildContext(dec.rootMap)
@@ -443,9 +441,9 @@ func (dec *tomlDecoder) processArrayTable(currentNode *toml.Node) (bool, error)
 	hasValue := dec.parser.NextExpression()
 
 	tableNodeValue := &CandidateNode{
-		Kind:       MappingNode,
+		Kind:           MappingNode,
-		Tag:        "!!map",
+		Tag:            "!!map",
-		EncodeHint: EncodeHintSeparateBlock,
+		EncodeSeparate: true,
 	}
 
 	// Attach pending head comments to the array table

pkg/yqlib/decoder_xml.go

@@ -64,7 +64,7 @@ func (dec *xmlDecoder) processComment(c string) string {
 }
 
 func (dec *xmlDecoder) createMap(n *xmlNode) (*CandidateNode, error) {
-	log.Debugf("createMap: headC: %v, lineC: %v, footC: %v", n.HeadComment, n.LineComment, n.FootComment)
+	log.Debug("createMap: headC: %v, lineC: %v, footC: %v", n.HeadComment, n.LineComment, n.FootComment)
 	yamlNode := &CandidateNode{Kind: MappingNode, Tag: "!!map"}
 
 	if len(n.Data) > 0 {
@@ -92,7 +92,7 @@ func (dec *xmlDecoder) createMap(n *xmlNode) (*CandidateNode, error) {
 		log.Debugf("label=%v, i=%v, keyValuePair.FootComment: %v", label, i, keyValuePair.FootComment)
 		labelNode.FootComment = dec.processComment(keyValuePair.FootComment)
 
-		log.Debugf("len of children in %v is %v", label, len(children))
+		log.Debug("len of children in %v is %v", label, len(children))
 		if len(children) > 1 {
 			valueNode, err = dec.createSequence(children)
 			if err != nil {
@@ -105,7 +105,7 @@ func (dec *xmlDecoder) createMap(n *xmlNode) (*CandidateNode, error) {
 			if len(children[0].Children) == 0 && children[0].HeadComment != "" {
 				if len(children[0].Data) > 0 {
 
-					log.Debugf("scalar comment hack, currentlabel [%v]", labelNode.HeadComment)
+					log.Debug("scalar comment hack, currentlabel [%v]", labelNode.HeadComment)
 					labelNode.HeadComment = joinComments([]string{labelNode.HeadComment, strings.TrimSpace(children[0].HeadComment)}, "\n")
 					children[0].HeadComment = ""
 				} else {
@@ -151,7 +151,7 @@ func (dec *xmlDecoder) convertToYamlNode(n *xmlNode) (*CandidateNode, error) {
 
 	scalar := dec.createValueNodeFromData(n.Data)
 
-	log.Debugf("scalar (%v), headC: %v, lineC: %v, footC: %v", scalar.Tag, n.HeadComment, n.LineComment, n.FootComment)
+	log.Debug("scalar (%v), headC: %v, lineC: %v, footC: %v", scalar.Tag, n.HeadComment, n.LineComment, n.FootComment)
 	scalar.HeadComment = dec.processComment(n.HeadComment)
 	scalar.LineComment = dec.processComment(n.LineComment)
 	if scalar.Tag == "!!seq" {
@@ -211,17 +211,17 @@ func (n *xmlNode) AddChild(s string, c *xmlNode) {
 	if n.Children == nil {
 		n.Children = make([]*xmlChildrenKv, 0)
 	}
-	log.Debugf("looking for %s", s)
+	log.Debug("looking for %s", s)
 	// see if we can find an existing entry to add to
 	for _, childEntry := range n.Children {
 		if childEntry.K == s {
-			log.Debugf("found it, appending an entry%s", s)
+			log.Debug("found it, appending an entry%s", s)
 			childEntry.V = append(childEntry.V, c)
-			log.Debugf("yay len of children in %v is %v", s, len(childEntry.V))
+			log.Debug("yay len of children in %v is %v", s, len(childEntry.V))
 			return
 		}
 	}
-	log.Debugf("not there, making a new one %s", s)
+	log.Debug("not there, making a new one %s", s)
 	n.Children = append(n.Children, &xmlChildrenKv{K: s, V: []*xmlNode{c}})
 }
 
@@ -267,7 +267,7 @@ func (dec *xmlDecoder) decodeXML(root *xmlNode) error {
 
 		switch se := t.(type) {
 		case xml.StartElement:
-			log.Debugf("start element %v", se.Name.Local)
+			log.Debug("start element %v", se.Name.Local)
 			elem.state = "started"
 			// Build new a new current element and link it to its parent
 			var label = se.Name.Local
@@ -302,14 +302,14 @@ func (dec *xmlDecoder) decodeXML(root *xmlNode) error {
 			if len(newBit) > 0 {
 				elem.n.Data = append(elem.n.Data, newBit)
 				elem.state = "chardata"
-				log.Debugf("chardata [%v] for %v", elem.n.Data, elem.label)
+				log.Debug("chardata [%v] for %v", elem.n.Data, elem.label)
 			}
 		case xml.EndElement:
 			if elem == nil {
 				log.Debug("no element, probably bad xml")
 				continue
 			}
-			log.Debugf("end element %v", elem.label)
+			log.Debug("end element %v", elem.label)
 			elem.state = "finished"
 			// And add it to its parent list
 			if elem.parent != nil {
@@ -326,10 +326,10 @@ func (dec *xmlDecoder) decodeXML(root *xmlNode) error {
 				applyFootComment(elem, commentStr)
 
 			case "chardata":
-				log.Debugf("got a line comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
+				log.Debug("got a line comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
 				elem.n.LineComment = joinComments([]string{elem.n.LineComment, commentStr}, " ")
 			default:
-				log.Debugf("got a head comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
+				log.Debug("got a head comment for (%v) %v: [%v]", elem.state, elem.label, commentStr)
 				elem.n.HeadComment = joinComments([]string{elem.n.HeadComment, commentStr}, " ")
 			}
 
@@ -354,7 +354,7 @@ func applyFootComment(elem *element, commentStr string) {
 	if len(elem.n.Children) > 0 {
 		lastChildIndex := len(elem.n.Children) - 1
 		childKv := elem.n.Children[lastChildIndex]
-		log.Debugf("got a foot comment, putting on last child for %v: [%v]", childKv.K, commentStr)
+		log.Debug("got a foot comment, putting on last child for %v: [%v]", childKv.K, commentStr)
 		// if it's an array of scalars, put the foot comment on the scalar itself
 		if len(childKv.V) > 0 && len(childKv.V[0].Children) == 0 {
 			nodeToUpdate := childKv.V[len(childKv.V)-1]
@@ -363,7 +363,7 @@ func applyFootComment(elem *element, commentStr string) {
 			childKv.FootComment = joinComments([]string{elem.n.FootComment, commentStr}, " ")
 		}
 	} else {
-		log.Debugf("got a foot comment for %v: [%v]", elem.label, commentStr)
+		log.Debug("got a foot comment for %v: [%v]", elem.label, commentStr)
 		elem.n.FootComment = joinComments([]string{elem.n.FootComment, commentStr}, " ")
 	}
 }

pkg/yqlib/doc/operators/anchor-and-alias-operators.md

@@ -2,7 +2,7 @@
 
 Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
 
-`yq` supports merge keys (like `<<: *blah`) from YAML 1.1. These are no longer part of the YAML 1.2 standard, but remain common in practice. Plain `<<:` keys are recognised as merge keys and round-trip as `<<:` without an explicit `!!merge` tag. When the source uses an explicit `!!merge` tag, that is preserved on output. Internally, when `yq` synthesises a `<<` map key (for example during merge operations), it tags the key as `!!merge` rather than `!!str`.
+`yq` supports merge aliases (like `<<: *blah`) however this is no longer in the standard yaml spec (1.2) and so `yq` will automatically add the `!!merge` tag to these nodes as it is effectively a custom tag.
 
 
 ## NOTE --yaml-fix-merge-anchor-to-spec flag
@@ -32,7 +32,7 @@ Given a sample.yml file of:
   r: 10
 - &SMALL
   r: 1
-- <<: *CENTRE
+- !!merge <<: *CENTRE
   r: 10
 ```
 then
@@ -213,10 +213,10 @@ item_value: &item_value
   value: true
 thingOne:
   name: item_1
-  <<: *item_value
+  !!merge <<: *item_value
 thingTwo:
   name: item_2
-  <<: *item_value
+  !!merge <<: *item_value
 ```
 then
 ```bash
@@ -231,7 +231,7 @@ thingOne:
   value: false
 thingTwo:
   name: item_2
-  <<: *item_value
+  !!merge <<: *item_value
 ```
 
 ## LEGACY: Explode with merge anchors
@@ -249,13 +249,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -298,7 +298,7 @@ Given a sample.yml file of:
   r: 10
 - &SMALL
   r: 1
-- <<:
+- !!merge <<:
     - *CENTRE
     - *BIG
 ```
@@ -328,7 +328,7 @@ Given a sample.yml file of:
   r: 10
 - &SMALL
   r: 1
-- <<:
+- !!merge <<:
     - *BIG
     - *LEFT
     - *SMALL
@@ -361,13 +361,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -411,7 +411,7 @@ Given a sample.yml file of:
   r: 10
 - &SMALL
   r: 1
-- <<:
+- !!merge <<:
     - *CENTRE
     - *BIG
 ```
@@ -442,7 +442,7 @@ Given a sample.yml file of:
   r: 10
 - &SMALL
   r: 1
-- <<:
+- !!merge <<:
     - *BIG
     - *LEFT
     - *SMALL
@@ -467,7 +467,7 @@ Given a sample.yml file of:
 ```yaml
 a:
   b: &b 42
-<<:
+!!merge <<:
   c: *b
 ```
 then

pkg/yqlib/doc/operators/divide.md

@@ -55,7 +55,7 @@ yq '.a = .a / 0 | .b = .b / 0' sample.yml
 ```
 will output
 ```yaml
-a: +Inf
+a: !!float +Inf
-b: -Inf
+b: !!float -Inf
 ```
 

pkg/yqlib/doc/operators/headers/anchor-and-alias-operators.md

@@ -2,7 +2,7 @@
 
 Use the `alias` and `anchor` operators to read and write yaml aliases and anchors. The `explode` operator normalises a yaml file (dereference (or expands) aliases and remove anchor names).
 
-`yq` supports merge keys (like `<<: *blah`) from YAML 1.1. These are no longer part of the YAML 1.2 standard, but remain common in practice. Plain `<<:` keys are recognised as merge keys and round-trip as `<<:` without an explicit `!!merge` tag. When the source uses an explicit `!!merge` tag, that is preserved on output. Internally, when `yq` synthesises a `<<` map key (for example during merge operations), it tags the key as `!!merge` rather than `!!str`.
+`yq` supports merge aliases (like `<<: *blah`) however this is no longer in the standard yaml spec (1.2) and so `yq` will automatically add the `!!merge` tag to these nodes as it is effectively a custom tag.
 
 
 ## NOTE --yaml-fix-merge-anchor-to-spec flag

pkg/yqlib/doc/operators/headers/slice-array.md

@@ -1,5 +1,5 @@
-# Slice Array or String
+# Slice/Splice Array
 
-The slice operator works on both arrays and strings. Like the `jq` equivalent, `.[10:15]` will return a subarray (or substring) of length 5, starting from index 10 inclusive, up to index 15 exclusive. Negative numbers count backwards from the end of the array or string.
+The slice array operator takes an array as input and returns a subarray. Like the `jq` equivalent, `.[10:15]` will return an array of length 5, starting from index 10 inclusive, up to index 15 exclusive. Negative numbers count backwards from the end of the array.
 
-You may leave out the first or second number, which will refer to the start or end of the array or string respectively.
+You may leave out the first or second number, which will refer to the start or end of the array respectively.

pkg/yqlib/doc/operators/headers/system-operators.md

@@ -1,27 +0,0 @@
-# System Operators
-
-The `system` operator allows you to run an external command and use its output as a value in your expression.
-
-**Security warning**: The system operator is disabled by default. You must explicitly pass `--security-enable-system-operator` to use it.
-
-**Note:** When enabled, the system operator can replicate the functionality of `env` and `load`
-operators via external commands. Enabling it effectively overrides `--security-disable-env-ops`
-and `--security-disable-file-ops`.
-
-## Usage
-
-```bash
-yq --security-enable-system-operator --null-input '.field = system("command"; "arg1")'
-```
-
-The operator takes:
-- A command string (required)
-- An argument (or an array of arguments), separated from the command by `;` (optional)
-
-The current matched node's value is serialised and piped to the command via stdin. The command's stdout (with trailing newline stripped) is returned as a string.
-
-## Disabling the system operator
-
-The system operator is disabled by default. When disabled, an error is returned instead of running the command, consistent with `--security-disable-env-ops` and `--security-disable-file-ops`.
-
-Use `--security-enable-system-operator` flag to enable it.

pkg/yqlib/doc/operators/modulo.md

@@ -34,7 +34,7 @@ yq '.a = .a % .b' sample.yml
 ```
 will output
 ```yaml
-a: 2
+a: !!float 2
 b: 2.5
 ```
 
@@ -69,7 +69,7 @@ yq '.a = .a % .b' sample.yml
 ```
 will output
 ```yaml
-a: NaN
+a: !!float NaN
 b: 0
 ```
 

pkg/yqlib/doc/operators/multiply-merge.md

@@ -471,13 +471,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -487,7 +487,7 @@ yq '.foobar * .foobarList' sample.yml
 will output
 ```yaml
 c: foobarList_c
-<<:
+!!merge <<:
   - *foo
   - *bar
 thing: foobar_thing

pkg/yqlib/doc/operators/recursive-descent-glob.md

@@ -131,13 +131,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -147,7 +147,7 @@ yq '.foobar | [..]' sample.yml
 will output
 ```yaml
 - c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 - foobar_c
 - *foo

pkg/yqlib/doc/operators/slice-array.md

@@ -1,8 +1,8 @@
-# Slice Array or String
+# Slice/Splice Array
 
-The slice operator works on both arrays and strings. Like the `jq` equivalent, `.[10:15]` will return a subarray (or substring) of length 5, starting from index 10 inclusive, up to index 15 exclusive. Negative numbers count backwards from the end of the array or string.
+The slice array operator takes an array as input and returns a subarray. Like the `jq` equivalent, `.[10:15]` will return an array of length 5, starting from index 10 inclusive, up to index 15 exclusive. Negative numbers count backwards from the end of the array.
 
-You may leave out the first or second number, which will refer to the start or end of the array or string respectively.
+You may leave out the first or second number, which will refer to the start or end of the array respectively.
 
 ## Slicing arrays
 Given a sample.yml file of:
@@ -103,81 +103,3 @@ will output
 - cow
 ```
 
-## Slicing strings
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq '.country[0:5]' sample.yml
-```
-will output
-```yaml
-Austr
-```
-
-## Slicing strings - without the second number
-Finishes at the end of the string
-
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq '.country[5:]' sample.yml
-```
-will output
-```yaml
-alia
-```
-
-## Slicing strings - without the first number
-Starts from the start of the string
-
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq '.country[:5]' sample.yml
-```
-will output
-```yaml
-Austr
-```
-
-## Slicing strings - use negative numbers to count backwards from the end
-Negative indices count from the end of the string
-
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq '.country[-5:]' sample.yml
-```
-will output
-```yaml
-ralia
-```
-
-## Slicing strings - Unicode
-Indices are rune-based, so multi-byte characters are handled correctly
-
-Given a sample.yml file of:
-```yaml
-greeting: héllo
-```
-then
-```bash
-yq '.greeting[1:3]' sample.yml
-```
-will output
-```yaml
-él
-```
-

pkg/yqlib/doc/operators/system-operators.md

@@ -1,76 +0,0 @@
-# System Operators
-
-The `system` operator allows you to run an external command and use its output as a value in your expression.
-
-**Security warning**: The system operator is disabled by default. You must explicitly pass `--security-enable-system-operator` to use it.
-
-**Note:** When enabled, the system operator can replicate the functionality of `env` and `load`
-operators via external commands. Enabling it effectively overrides `--security-disable-env-ops`
-and `--security-disable-file-ops`.
-
-## Usage
-
-```bash
-yq --security-enable-system-operator --null-input '.field = system("command"; "arg1")'
-```
-
-The operator takes:
-- A command string (required)
-- An argument (or an array of arguments), separated from the command by `;` (optional)
-
-The current matched node's value is serialised and piped to the command via stdin. The command's stdout (with trailing newline stripped) is returned as a string.
-
-## Disabling the system operator
-
-The system operator is disabled by default. When disabled, an error is returned instead of running the command, consistent with `--security-disable-env-ops` and `--security-disable-file-ops`.
-
-Use `--security-enable-system-operator` flag to enable it.
-
-## system operator returns error when disabled
-Use `--security-enable-system-operator` to enable the system operator.
-
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq '.country = system("/usr/bin/echo"; "test")' sample.yml
-```
-will output
-```bash
-Error: system operations are disabled, use --security-enable-system-operator to enable
-```
-
-## Run a command with an argument
-Use `--security-enable-system-operator` to enable the system operator.
-
-Given a sample.yml file of:
-```yaml
-country: Australia
-```
-then
-```bash
-yq --security-enable-system-operator '.country = system("/bin/echo"; "test")' sample.yml
-```
-will output
-```yaml
-country: test
-```
-
-## Run a command without arguments
-Omit the semicolon and args to run the command with no extra arguments.
-
-Given a sample.yml file of:
-```yaml
-a: hello
-```
-then
-```bash
-yq --security-enable-system-operator '.a = system("/bin/echo")' sample.yml
-```
-will output
-```yaml
-a: ""
-```
-

pkg/yqlib/doc/operators/traverse-read.md

@@ -294,13 +294,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -325,13 +325,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -376,13 +376,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -409,13 +409,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -442,13 +442,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -477,13 +477,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -513,13 +513,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -546,13 +546,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -579,13 +579,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then
@@ -614,13 +614,13 @@ bar: &bar
   c: bar_c
 foobarList:
   b: foobarList_b
-  <<:
+  !!merge <<:
     - *foo
     - *bar
   c: foobarList_c
 foobar:
   c: foobar_c
-  <<: *foo
+  !!merge <<: *foo
   thing: foobar_thing
 ```
 then

pkg/yqlib/doc/usage/convert.md

@@ -125,22 +125,6 @@ will output
 {"whatever":"cat"}
 ```
 
-## Encode json: preserve floats with trailing zero
-Whole-number floats keep their decimal point so downstream consumers see a JSON number with a fractional part (matches Go's encoding/json, Python's json, and jq).
-
-Given a sample.yml file of:
-```yaml
-percentiles: [50.0, 95.0, 99.0, 99.9]
-```
-then
-```bash
-yq -o=json -I=0 '.' sample.yml
-```
-will output
-```json
-{"percentiles":[50.0,95.0,99.0,99.9]}
-```
-
 ## Roundtrip JSON Lines / NDJSON
 Given a sample.json file of:
 ```json

pkg/yqlib/doc/usage/headers/toml.md

@@ -1,4 +1,4 @@
 # TOML
 
-Encode and decode to and from TOML.
+Decode from TOML. Note that `yq` does not yet support outputting in TOML format (and therefore it cannot roundtrip)
 

pkg/yqlib/doc/usage/toml.md

@@ -1,6 +1,6 @@
 # TOML
 
-Encode and decode to and from TOML.
+Decode from TOML. Note that `yq` does not yet support outputting in TOML format (and therefore it cannot roundtrip)
 
 
 ## Parse: Simple
@@ -384,20 +384,3 @@ ip = "10.0.0.2"
 role = "backend"
 ```
 
-## Encode: Simple mapping produces table section
-Given a sample.yml file of:
-```yaml
-arg:
-  hello: foo
-
-```
-then
-```bash
-yq -o toml '.' sample.yml
-```
-will output
-```toml
-[arg]
-hello = "foo"
-```
-

pkg/yqlib/encoder_hcl.go

@@ -449,8 +449,8 @@ func (he *hclEncoder) encodeBlockIfMapping(body *hclwrite.Body, key string, valu
 		return false
 	}
 
-	// If EncodeHintSeparateBlock is set, emit children as separate blocks regardless of label extraction
+	// If EncodeSeparate is set, emit children as separate blocks regardless of label extraction
-	if valueNode.EncodeHint == EncodeHintSeparateBlock {
+	if valueNode.EncodeSeparate {
 		if handled, _ := he.encodeMappingChildrenAsBlocks(body, key, valueNode); handled {
 			return true
 		}
@@ -537,9 +537,9 @@ func (he *hclEncoder) encodeMappingChildrenAsBlocks(body *hclwrite.Body, blockTy
 		return false, nil
 	}
 
-	// Only emit as separate blocks if EncodeHintSeparateBlock is set
+	// Only emit as separate blocks if EncodeSeparate is true
 	// This allows the encoder to respect the original block structure preserved by the decoder
-	if valueNode.EncodeHint != EncodeHintSeparateBlock {
+	if !valueNode.EncodeSeparate {
 		return false, nil
 	}
 

pkg/yqlib/encoder_kyaml.go

@@ -32,7 +32,7 @@ func (ke *kyamlEncoder) PrintLeadingContent(writer io.Writer, content string) er
 }
 
 func (ke *kyamlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
-	log.Debugf("encoderKYaml - going to print %v", NodeToString(node))
+	log.Debug("encoderKYaml - going to print %v", NodeToString(node))
 	if node.Kind == ScalarNode && ke.prefs.UnwrapScalar {
 		return writeString(writer, node.Value+"\n")
 	}

pkg/yqlib/encoder_toml.go

@@ -69,27 +69,6 @@ func (te *tomlEncoder) CanHandleAliases() bool {
 
 // ---- helpers ----
 
-// tomlKey returns the key quoted if it contains characters that are not valid
-// in a TOML bare key. TOML bare keys may only contain ASCII letters, ASCII
-// digits, underscores, and dashes.
-func tomlKey(key string) string {
-	for _, r := range key {
-		if (r < 'A' || r > 'Z') && (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '_' && r != '-' {
-			return fmt.Sprintf("%q", key)
-		}
-	}
-	return key
-}
-
-// tomlDottedKey joins path components, quoting any that require it.
-func tomlDottedKey(path []string) string {
-	parts := make([]string, len(path))
-	for i, p := range path {
-		parts[i] = tomlKey(p)
-	}
-	return strings.Join(parts, ".")
-}
-
 func (te *tomlEncoder) writeComment(w io.Writer, comment string) error {
 	if comment == "" {
 		return nil
@@ -132,23 +111,12 @@ func (te *tomlEncoder) encodeRootMapping(w io.Writer, node *CandidateNode) error
 		}
 	}
 
+	// Preserve existing order by iterating Content
 	for i := 0; i < len(node.Content); i += 2 {
 		keyNode := node.Content[i]
 		valNode := node.Content[i+1]
-		if isTomlAttribute(valNode) {
+		if err := te.encodeTopLevelEntry(w, []string{keyNode.Value}, valNode); err != nil {
-			if err := te.encodeTopLevelEntry(w, []string{keyNode.Value}, valNode); err != nil {
+			return err
-				return err
-			}
-		}
-	}
-
-	for i := 0; i < len(node.Content); i += 2 {
-		keyNode := node.Content[i]
-		valNode := node.Content[i+1]
-		if !isTomlAttribute(valNode) {
-			if err := te.encodeTopLevelEntry(w, []string{keyNode.Value}, valNode); err != nil {
-				return err
-			}
 		}
 	}
 	return nil
@@ -180,15 +148,9 @@ func (te *tomlEncoder) encodeTopLevelEntry(w io.Writer, path []string, node *Can
 		}
 		if allMaps {
 			key := path[len(path)-1]
-			quotedKey := tomlKey(key)
-			if te.wroteRootAttr {
-				if _, err := w.Write([]byte("\n")); err != nil {
-					return err
-				}
-				te.wroteRootAttr = false
-			}
 			for _, it := range node.Content {
-				if _, err := w.Write([]byte("[[" + quotedKey + "]]\n")); err != nil {
+				// [[key]] then body
+				if _, err := w.Write([]byte("[[" + key + "]]\n")); err != nil {
 					return err
 				}
 				if err := te.encodeMappingBodyWithPath(w, []string{key}, it); err != nil {
@@ -200,12 +162,12 @@ func (te *tomlEncoder) encodeTopLevelEntry(w io.Writer, path []string, node *Can
 		// Regular array attribute
 		return te.writeArrayAttribute(w, path[len(path)-1], node)
 	case MappingNode:
-		// Use inline table syntax only for nodes explicitly marked as TOML inline tables.
+		// Inline table if not EncodeSeparate, else emit separate tables/arrays of tables for children under this path
-		// YAML flow-style mappings are not treated as inline tables; the FlowStyle attribute
+		if !node.EncodeSeparate {
-		// is a YAML-specific rendering hint and should not affect TOML output. This ensures
+			// If children contain mappings or arrays of mappings, prefer separate sections
-		// that auto-detected JSON input (parsed as YAML flow style) produces readable table
+			if te.hasEncodeSeparateChild(node) || te.hasStructuralChildren(node) {
-		// sections, consistent with explicitly parsed JSON input.
+				return te.encodeSeparateMapping(w, path, node)
-		if node.EncodeHint == EncodeHintInline {
+			}
 			return te.writeInlineTableAttribute(w, path[len(path)-1], node)
 		}
 		return te.encodeSeparateMapping(w, path, node)
@@ -214,30 +176,7 @@ func (te *tomlEncoder) encodeTopLevelEntry(w io.Writer, path []string, node *Can
 	}
 }
 
-func isTomlArrayOfTables(seq *CandidateNode) bool {
-	if len(seq.Content) == 0 {
-		return false
-	}
-	for _, it := range seq.Content {
-		if it.Kind != MappingNode || it.EncodeHint == EncodeHintInline {
-			return false
-		}
-	}
-	return true
-}
-
-func isTomlAttribute(node *CandidateNode) bool {
-	if node.Kind == ScalarNode {
-		return true
-	}
-	return node.Kind == SequenceNode && !isTomlArrayOfTables(node)
-}
-
 func (te *tomlEncoder) writeAttribute(w io.Writer, key string, value *CandidateNode) error {
-	if value.Tag == "!!null" {
-		return nil
-	}
-
 	te.wroteRootAttr = true // Mark that we wrote a root attribute
 
 	// Write head comment before the attribute
@@ -246,7 +185,7 @@ func (te *tomlEncoder) writeAttribute(w io.Writer, key string, value *CandidateN
 	}
 
 	// Write the attribute
-	line := tomlKey(key) + " = " + te.formatScalar(value)
+	line := key + " = " + te.formatScalar(value)
 
 	// Add line comment if present
 	if value.LineComment != "" {
@@ -271,7 +210,7 @@ func (te *tomlEncoder) writeArrayAttribute(w io.Writer, key string, seq *Candida
 
 	// Handle empty arrays
 	if len(seq.Content) == 0 {
-		line := tomlKey(key) + " = []"
+		line := key + " = []"
 		if seq.LineComment != "" {
 			lineComment := strings.TrimSpace(seq.LineComment)
 			if !strings.HasPrefix(lineComment, "#") {
@@ -294,7 +233,7 @@ func (te *tomlEncoder) writeArrayAttribute(w io.Writer, key string, seq *Candida
 
 	if hasElementComments {
 		// Write multiline array format with comments
-		if _, err := w.Write([]byte(tomlKey(key) + " = [\n")); err != nil {
+		if _, err := w.Write([]byte(key + " = [\n")); err != nil {
 			return err
 		}
 
@@ -385,7 +324,7 @@ func (te *tomlEncoder) writeArrayAttribute(w io.Writer, key string, seq *Candida
 		}
 	}
 
-	line := tomlKey(key) + " = [" + strings.Join(items, ", ") + "]"
+	line := key + " = [" + strings.Join(items, ", ") + "]"
 
 	// Add line comment if present
 	if seq.LineComment != "" {
@@ -433,24 +372,21 @@ func (te *tomlEncoder) mappingToInlineTable(m *CandidateNode) (string, error) {
 		v := m.Content[i+1]
 		switch v.Kind {
 		case ScalarNode:
-			if v.Tag == "!!null" {
+			parts = append(parts, fmt.Sprintf("%s = %s", k, te.formatScalar(v)))
-				continue
-			}
-			parts = append(parts, fmt.Sprintf("%s = %s", tomlKey(k), te.formatScalar(v)))
 		case SequenceNode:
 			// inline array in inline table
 			arr, err := te.sequenceToInlineArray(v)
 			if err != nil {
 				return "", err
 			}
-			parts = append(parts, fmt.Sprintf("%s = %s", tomlKey(k), arr))
+			parts = append(parts, fmt.Sprintf("%s = %s", k, arr))
 		case MappingNode:
 			// nested inline table
 			inline, err := te.mappingToInlineTable(v)
 			if err != nil {
 				return "", err
 			}
-			parts = append(parts, fmt.Sprintf("%s = %s", tomlKey(k), inline))
+			parts = append(parts, fmt.Sprintf("%s = %s", k, inline))
 		default:
 			return "", fmt.Errorf("unsupported inline table value kind: %v", v.Kind)
 		}
@@ -463,7 +399,7 @@ func (te *tomlEncoder) writeInlineTableAttribute(w io.Writer, key string, m *Can
 	if err != nil {
 		return err
 	}
-	_, err = w.Write([]byte(tomlKey(key) + " = " + inline + "\n"))
+	_, err = w.Write([]byte(key + " = " + inline + "\n"))
 	return err
 }
 
@@ -485,7 +421,7 @@ func (te *tomlEncoder) writeTableHeader(w io.Writer, path []string, m *Candidate
 	}
 
 	// Write table header [a.b.c]
-	header := "[" + tomlDottedKey(path) + "]\n"
+	header := "[" + strings.Join(path, ".") + "]\n"
 	_, err := w.Write([]byte(header))
 	return err
 }
@@ -493,21 +429,24 @@ func (te *tomlEncoder) writeTableHeader(w io.Writer, path []string, m *Candidate
 // encodeSeparateMapping handles a mapping that should be encoded as table sections.
 // It emits the table header for this mapping if it has any content, then processes children.
 func (te *tomlEncoder) encodeSeparateMapping(w io.Writer, path []string, m *CandidateNode) error {
-	// Check if this mapping has any non-mapping, non-array-of-tables children (i.e., attributes).
+	// Check if this mapping has any non-mapping, non-array-of-tables children (i.e., attributes)
-	// Inline mapping children also count as attributes since they render as key = { ... }.
 	hasAttrs := false
 	for i := 0; i < len(m.Content); i += 2 {
 		v := m.Content[i+1]
-		if v.Kind == ScalarNode && v.Tag != "!!null" {
+		if v.Kind == ScalarNode {
-			hasAttrs = true
-			break
-		}
-		if v.Kind == MappingNode && v.EncodeHint == EncodeHintInline {
 			hasAttrs = true
 			break
 		}
 		if v.Kind == SequenceNode {
-			if !isTomlArrayOfTables(v) {
+			// Check if it's NOT an array of tables
+			allMaps := true
+			for _, it := range v.Content {
+				if it.Kind != MappingNode {
+					allMaps = false
+					break
+				}
+			}
+			if !allMaps {
 				hasAttrs = true
 				break
 			}
@@ -525,26 +464,31 @@ func (te *tomlEncoder) encodeSeparateMapping(w io.Writer, path []string, m *Cand
 		return nil
 	}
 
-	// No attributes, just nested table structures - process children recursively
+	// No attributes, just nested structures - process children
 	for i := 0; i < len(m.Content); i += 2 {
 		k := m.Content[i].Value
 		v := m.Content[i+1]
 		switch v.Kind {
 		case MappingNode:
+			// Emit [path.k]
 			newPath := append(append([]string{}, path...), k)
-			if err := te.encodeSeparateMapping(w, newPath, v); err != nil {
+			if err := te.writeTableHeader(w, newPath, v); err != nil {
+				return err
+			}
+			if err := te.encodeMappingBodyWithPath(w, newPath, v); err != nil {
 				return err
 			}
 		case SequenceNode:
 			// If sequence of maps, emit [[path.k]] per element
-			if isTomlArrayOfTables(v) {
+			allMaps := true
-				key := tomlDottedKey(append(append([]string{}, path...), k))
+			for _, it := range v.Content {
-				if te.wroteRootAttr {
+				if it.Kind != MappingNode {
-					if _, err := w.Write([]byte("\n")); err != nil {
+					allMaps = false
-						return err
+					break
-					}
-					te.wroteRootAttr = false
 				}
+			}
+			if allMaps {
+				key := strings.Join(append(append([]string{}, path...), k), ".")
 				for _, it := range v.Content {
 					if _, err := w.Write([]byte("[[" + key + "]]\n")); err != nil {
 						return err
@@ -569,9 +513,42 @@ func (te *tomlEncoder) encodeSeparateMapping(w io.Writer, path []string, m *Cand
 	return nil
 }
 
+func (te *tomlEncoder) hasEncodeSeparateChild(m *CandidateNode) bool {
+	for i := 0; i < len(m.Content); i += 2 {
+		v := m.Content[i+1]
+		if v.Kind == MappingNode && v.EncodeSeparate {
+			return true
+		}
+	}
+	return false
+}
+
+func (te *tomlEncoder) hasStructuralChildren(m *CandidateNode) bool {
+	for i := 0; i < len(m.Content); i += 2 {
+		v := m.Content[i+1]
+		// Only consider it structural if mapping has EncodeSeparate or is non-empty
+		if v.Kind == MappingNode && v.EncodeSeparate {
+			return true
+		}
+		if v.Kind == SequenceNode {
+			allMaps := true
+			for _, it := range v.Content {
+				if it.Kind != MappingNode {
+					allMaps = false
+					break
+				}
+			}
+			if allMaps {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // encodeMappingBodyWithPath encodes attributes and nested arrays of tables using full dotted path context
 func (te *tomlEncoder) encodeMappingBodyWithPath(w io.Writer, path []string, m *CandidateNode) error {
-	// First, attributes (scalars, inline mappings, and non-map arrays)
+	// First, attributes (scalars and non-map arrays)
 	for i := 0; i < len(m.Content); i += 2 {
 		k := m.Content[i].Value
 		v := m.Content[i+1]
@@ -580,14 +557,15 @@ func (te *tomlEncoder) encodeMappingBodyWithPath(w io.Writer, path []string, m *
 			if err := te.writeAttribute(w, k, v); err != nil {
 				return err
 			}
-		case MappingNode:
+		case SequenceNode:
-			if v.EncodeHint == EncodeHintInline {
+			allMaps := true
-				if err := te.writeInlineTableAttribute(w, k, v); err != nil {
+			for _, it := range v.Content {
-					return err
+				if it.Kind != MappingNode {
+					allMaps = false
+					break
 				}
 			}
-		case SequenceNode:
+			if !allMaps {
-			if !isTomlArrayOfTables(v) {
 				if err := te.writeArrayAttribute(w, k, v); err != nil {
 					return err
 				}
@@ -600,8 +578,15 @@ func (te *tomlEncoder) encodeMappingBodyWithPath(w io.Writer, path []string, m *
 		k := m.Content[i].Value
 		v := m.Content[i+1]
 		if v.Kind == SequenceNode {
-			if isTomlArrayOfTables(v) {
+			allMaps := true
-				dotted := tomlDottedKey(append(append([]string{}, path...), k))
+			for _, it := range v.Content {
+				if it.Kind != MappingNode {
+					allMaps = false
+					break
+				}
+			}
+			if allMaps {
+				dotted := strings.Join(append(append([]string{}, path...), k), ".")
 				for _, it := range v.Content {
 					if _, err := w.Write([]byte("[[" + dotted + "]]\n")); err != nil {
 						return err
@@ -614,14 +599,12 @@ func (te *tomlEncoder) encodeMappingBodyWithPath(w io.Writer, path []string, m *
 		}
 	}
 
-	// Finally, child mappings: inline-hint ones were emitted above as attributes,
+	// Finally, child mappings that are not marked EncodeSeparate get inlined as attributes
-	// while all others are emitted as separate sub-table sections.
 	for i := 0; i < len(m.Content); i += 2 {
 		k := m.Content[i].Value
 		v := m.Content[i+1]
-		if v.Kind == MappingNode && v.EncodeHint != EncodeHintInline {
+		if v.Kind == MappingNode && !v.EncodeSeparate {
-			subPath := append(append([]string{}, path...), k)
+			if err := te.writeInlineTableAttribute(w, k, v); err != nil {
-			if err := te.encodeSeparateMapping(w, subPath, v); err != nil {
 				return err
 			}
 		}
@@ -677,7 +660,7 @@ func (te *tomlEncoder) colorizeToml(input []byte) []byte {
 
 		// Table sections - [section] or [[array]]
 		// Only treat '[' as a table section if it appears at the start of the line
-        // (possibly after whitespace). This avoids incorrectly colouring inline arrays like
+		// (possibly after whitespace). This avoids mis-colouring inline arrays like
 		// "ports = [8000, 8001]" as table sections.
 		if ch == '[' {
 			isSectionHeader := true

pkg/yqlib/encoder_xml.go

@@ -59,7 +59,7 @@ func (e *xmlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
 					return err
 				}
 				if _, err := e.writer.Write([]byte("\n")); err != nil {
-					log.Warningf("Unable to write newline, skipping: %v", err)
+					log.Warning("Unable to write newline, skipping: %w", err)
 				}
 			}
 		}
@@ -131,7 +131,7 @@ func (e *xmlEncoder) encodeTopLevelMap(encoder *xml.Encoder, node *CandidateNode
 				return err
 			}
 			if _, err := e.writer.Write([]byte("\n")); err != nil {
-				log.Warningf("Unable to write newline, skipping: %v", err)
+				log.Warning("Unable to write newline, skipping: %w", err)
 			}
 		} else if key.Value == e.prefs.DirectiveName {
 			var directive xml.Directive = []byte(value.Value)
@@ -139,7 +139,7 @@ func (e *xmlEncoder) encodeTopLevelMap(encoder *xml.Encoder, node *CandidateNode
 				return err
 			}
 			if _, err := e.writer.Write([]byte("\n")); err != nil {
-				log.Warningf("Unable to write newline, skipping: %v", err)
+				log.Warning("Unable to write newline, skipping: %w", err)
 			}
 		} else {
 

pkg/yqlib/encoder_yaml.go

@@ -29,7 +29,7 @@ func (ye *yamlEncoder) PrintLeadingContent(writer io.Writer, content string) err
 }
 
 func (ye *yamlEncoder) Encode(writer io.Writer, node *CandidateNode) error {
-	log.Debugf("encoderYaml - going to print %v", NodeToString(node))
+	log.Debug("encoderYaml - going to print %v", NodeToString(node))
 	// Detect line ending style from LeadingContent
 	lineEnding := "\n"
 	if strings.Contains(node.LeadingContent, "\r\n") {

pkg/yqlib/expression_parser.go

@@ -26,7 +26,7 @@ func newExpressionParser() ExpressionParserInterface {
 }
 
 func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNode, error) {
-	log.Debugf("Parsing expression: [%v]", expression)
+	log.Debug("Parsing expression: [%v]", expression)
 	tokens, err := p.pathTokeniser.Tokenise(expression)
 	if err != nil {
 		return nil, err

pkg/yqlib/expression_parser_test.go

@@ -95,7 +95,6 @@ func TestParserSingleOperation(t *testing.T) {
 	test.AssertResultComplex(t, nil, err)
 	if result == nil {
 		t.Fatal("Expected non-nil result for single operation")
-		return
 	}
 	if result.Operation == nil {
 		t.Fatal("Expected operation to be set")

pkg/yqlib/expression_postfix.go

@@ -3,7 +3,8 @@ package yqlib
 import (
 	"errors"
 	"fmt"
-	"log/slog"
+
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 type expressionPostFixer interface {
@@ -133,7 +134,7 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 		return nil, fmt.Errorf("bad expression - probably missing close bracket on %v", opStack[len(opStack)-1].toString(false))
 	}
 
-	if log.IsEnabledFor(slog.LevelDebug) {
+	if log.IsEnabledFor(logging.DEBUG) {
 		log.Debugf("PostFix Result:")
 		for _, currentToken := range result {
 			log.Debugf("> %v", currentToken.toString())

pkg/yqlib/file_utils.go

@@ -30,7 +30,7 @@ func tryRenameFile(from string, to string) error {
 }
 
 func tryRemoveTempFile(filename string) {
-	log.Debugf("Removing temp file: %v", filename)
+	log.Debug("Removing temp file: %v", filename)
 	removeErr := os.Remove(filename)
 	if removeErr != nil {
 		log.Errorf("Failed to remove temp file: %v", filename)
@@ -40,7 +40,7 @@ func tryRemoveTempFile(filename string) {
 // thanks https://stackoverflow.com/questions/21060945/simple-way-to-copy-a-file-in-golang
 func copyFileContents(src, dst string) (err error) {
 	// ignore CWE-22 gosec issue - that's more targeted for http based apps that run in a public directory,
-	// and ensuring that it's not possible to give a path to a file outside that directory.
+	// and ensuring that it's not possible to give a path to a file outside thar directory.
 
 	in, err := os.Open(src) // #nosec
 	if err != nil {
@@ -68,7 +68,8 @@ func SafelyCloseReader(reader io.Reader) {
 func safelyCloseFile(file *os.File) {
 	err := file.Close()
 	if err != nil {
-		log.Errorf("Error closing file %v: %v", file.Name(), err)
+		log.Error("Error closing file!")
+		log.Error(err.Error())
 	}
 }
 

pkg/yqlib/format.go

@@ -90,7 +90,7 @@ var LuaFormat = &Format{"lua", []string{"l"},
 
 var INIFormat = &Format{"ini", []string{"i"},
 	func() Encoder { return NewINIEncoder() },
-	func() Decoder { return NewINIDecoder(ConfiguredINIPreferences) },
+	func() Decoder { return NewINIDecoder() },
 }
 
 var Formats = []*Format{

pkg/yqlib/front_matter.go

@@ -58,7 +58,7 @@ func (f *frontMatterHandlerImpl) Split() error {
 		return err
 	}
 	f.yamlFrontMatterFilename = yamlTempFile.Name()
-	log.Debugf("yamlTempFile: %v", yamlTempFile.Name())
+	log.Debug("yamlTempFile: %v", yamlTempFile.Name())
 
 	lineCount := 0
 

pkg/yqlib/front_matter_test.go

@@ -108,55 +108,6 @@ yaml: doc
 	fmHandler.CleanUp()
 }
 
-func TestFrontMatterFilenamePreserved(t *testing.T) {
-	// Regression test for https://github.com/mikefarah/yq/issues/2538
-	// When using --front-matter, the filename operator should return
-	// the original filename, not the path to the temporary file.
-	file := createTestFile(`---
-name: john
----
-Some content
-`)
-	originalFilename := "/path/to/original/file.md"
-
-	fmHandler := NewFrontMatterHandler(file)
-	err := fmHandler.Split()
-	if err != nil {
-		panic(err)
-	}
-
-	tempFilename := fmHandler.GetYamlFrontMatterFilename()
-
-	// Register the alias (as the command code does)
-	SetFilenameAlias(tempFilename, originalFilename)
-	defer ClearFilenameAliases()
-
-	// Verify resolveFilename returns the original name
-	resolved := resolveFilename(tempFilename)
-	test.AssertResult(t, originalFilename, resolved)
-
-	// Read documents using the temp file, verify they get the original filename
-	reader, err := readStream(tempFilename)
-	if err != nil {
-		panic(err)
-	}
-	decoder := NewYamlDecoder(ConfiguredYamlPreferences)
-	docs, err := readDocuments(reader, tempFilename, 0, decoder)
-	if err != nil {
-		panic(err)
-	}
-
-	if docs.Len() == 0 {
-		t.Fatal("expected at least one document")
-	}
-
-	firstDoc := docs.Front().Value.(*CandidateNode)
-	test.AssertResult(t, originalFilename, firstDoc.filename)
-
-	tryRemoveTempFile(file)
-	fmHandler.CleanUp()
-}
-
 func TestFrontMatterSplitWithArray(t *testing.T) {
 	file := createTestFile(`[1,2,3]
 ---

pkg/yqlib/goccy_yaml_test.go

@@ -230,7 +230,8 @@ var goccyYamlFormatScenarios = []formatScenario{
 		description: "merge anchor",
 		skipDoc:     true,
 		input:       "a: &remember\n  c: mike\nb:\n  <<: *remember",
-		expected:    "a: &remember\n  c: mike\nb:\n  <<: *remember\n",
+		// fine to have !!merge as that's what the current impl does
+		expected: "a: &remember\n  c: mike\nb:\n  !!merge <<: *remember\n",
 	},
 	{
 		description: "custom tag",

pkg/yqlib/ini.go

@@ -1,21 +1,18 @@
 package yqlib
 
 type INIPreferences struct {
-	ColorsEnabled           bool
+	ColorsEnabled bool
-	PreserveSurroundedQuote bool
 }
 
 func NewDefaultINIPreferences() INIPreferences {
 	return INIPreferences{
-		ColorsEnabled:           false,
+		ColorsEnabled: false,
-		PreserveSurroundedQuote: false,
 	}
 }
 
 func (p *INIPreferences) Copy() INIPreferences {
 	return INIPreferences{
-		ColorsEnabled:           p.ColorsEnabled,
+		ColorsEnabled: p.ColorsEnabled,
-		PreserveSurroundedQuote: p.PreserveSurroundedQuote,
 	}
 }
 

pkg/yqlib/ini_test.go

@@ -5,7 +5,6 @@ package yqlib
 import (
 	"bufio"
 	"fmt"
-	"strings"
 	"testing"
 
 	"github.com/mikefarah/yq/v4/test"
@@ -23,16 +22,6 @@ const expectedSimpleINIYaml = `section:
   key: value
 `
 
-const quotedINIInput = `[section]
-color_theme = "Default"
-theme_background = "False"
-`
-
-const expectedQuotedINIOutput = `[section]
-color_theme      = "Default"
-theme_background = "False"
-`
-
 var iniScenarios = []formatScenario{
 	{
 		description:  "Parse INI: simple",
@@ -60,22 +49,6 @@ var iniScenarios = []formatScenario{
 	},
 }
 
-// iniPreserveQuotesPrefs returns INIPreferences with PreserveSurroundedQuote enabled.
-func iniPreserveQuotesPrefs() INIPreferences {
-	prefs := NewDefaultINIPreferences()
-	prefs.PreserveSurroundedQuote = true
-	return prefs
-}
-
-var iniPreserveQuotesScenarios = []formatScenario{
-	{
-		description:  "Roundtrip INI: preserve quotes",
-		input:        quotedINIInput,
-		expected:     expectedQuotedINIOutput,
-		scenarioType: "roundtrip",
-	},
-}
-
 func documentRoundtripINIScenario(w *bufio.Writer, s formatScenario) {
 	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
 
@@ -97,7 +70,7 @@ func documentRoundtripINIScenario(w *bufio.Writer, s formatScenario) {
 	}
 
 	writeOrPanic(w, "will output\n")
-	writeOrPanic(w, fmt.Sprintf("```ini\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(NewDefaultINIPreferences()), NewINIEncoder())))
+	writeOrPanic(w, fmt.Sprintf("```ini\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(), NewINIEncoder())))
 }
 
 func documentDecodeINIScenario(w *bufio.Writer, s formatScenario) {
@@ -121,7 +94,7 @@ func documentDecodeINIScenario(w *bufio.Writer, s formatScenario) {
 	}
 
 	writeOrPanic(w, "will output\n")
-	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(NewDefaultINIPreferences()), NewYamlEncoder(ConfiguredYamlPreferences))))
+	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", mustProcessFormatScenario(s, NewINIDecoder(), NewYamlEncoder(ConfiguredYamlPreferences))))
 }
 
 func testINIScenario(t *testing.T, s formatScenario) {
@@ -129,11 +102,11 @@ func testINIScenario(t *testing.T, s formatScenario) {
 	case "encode":
 		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewYamlDecoder(ConfiguredYamlPreferences), NewINIEncoder()), s.description)
 	case "decode":
-		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(NewDefaultINIPreferences()), NewYamlEncoder(ConfiguredYamlPreferences)), s.description)
+		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(), NewYamlEncoder(ConfiguredYamlPreferences)), s.description)
 	case "roundtrip":
-		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(NewDefaultINIPreferences()), NewINIEncoder()), s.description)
+		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(), NewINIEncoder()), s.description)
 	case "decode-error":
-		result, err := processFormatScenario(s, NewINIDecoder(NewDefaultINIPreferences()), NewINIEncoder())
+		result, err := processFormatScenario(s, NewINIDecoder(), NewINIEncoder())
 		if err == nil {
 			t.Errorf("Expected error '%v' but it worked: %v", s.expectedError, result)
 		} else {
@@ -202,21 +175,6 @@ func documentDecodeErrorINIScenario(w *bufio.Writer, s formatScenario) {
 	writeOrPanic(w, fmt.Sprintf("```\n%v\n```\n\n", s.expectedError))
 }
 
-func TestINIDecoderInitResetsFinished(t *testing.T) {
-	decoder := NewINIDecoder(NewDefaultINIPreferences())
-	firstDocuments, err := readDocuments(strings.NewReader("[first]\nkey = value\n"), "first.ini", 0, decoder)
-	if err != nil {
-		t.Fatal(err)
-	}
-	test.AssertResult(t, 1, firstDocuments.Len())
-
-	secondDocuments, err := readDocuments(strings.NewReader("[second]\nkey = value\n"), "second.ini", 1, decoder)
-	if err != nil {
-		t.Fatal(err)
-	}
-	test.AssertResult(t, 1, secondDocuments.Len())
-}
-
 func TestINIScenarios(t *testing.T) {
 	for _, tt := range iniScenarios {
 		testINIScenario(t, tt)
@@ -227,19 +185,3 @@ func TestINIScenarios(t *testing.T) {
 	}
 	documentScenarios(t, "usage", "convert", genericScenarios, documentINIScenario)
 }
-
-func testINIPreserveQuotesScenario(t *testing.T, s formatScenario) {
-	prefs := iniPreserveQuotesPrefs()
-	switch s.scenarioType {
-	case "roundtrip":
-		test.AssertResultWithContext(t, s.expected, mustProcessFormatScenario(s, NewINIDecoder(prefs), NewINIEncoder()), s.description)
-	default:
-		panic(fmt.Sprintf("unhandled scenario type %q", s.scenarioType))
-	}
-}
-
-func TestINIPreserveQuotesScenarios(t *testing.T) {
-	for _, tt := range iniPreserveQuotesScenarios {
-		testINIPreserveQuotesScenario(t, tt)
-	}
-}

pkg/yqlib/json_test.go

@@ -220,54 +220,6 @@ var jsonScenarios = []formatScenario{
 		expected:       "{\"stuff\":\"cool\"}\n{\"whatever\":\"cat\"}\n",
 		scenarioType:   "encode",
 	},
-	{
-		description:    "Encode json: preserve floats with trailing zero",
-		subdescription: "Whole-number floats keep their decimal point so downstream consumers see a JSON number with a fractional part (matches Go's encoding/json, Python's json, and jq).",
-		input:          `percentiles: [50.0, 95.0, 99.0, 99.9]`,
-		indent:         0,
-		expected:       "{\"percentiles\":[50.0,95.0,99.0,99.9]}\n",
-		scenarioType:   "encode",
-	},
-	{
-		description:  "Encode json: ints stay ints",
-		skipDoc:      true,
-		input:        `a: 50`,
-		indent:       0,
-		expected:     "{\"a\":50}\n",
-		scenarioType: "encode",
-	},
-	{
-		description:  "Encode json: !!float tagged whole number gets .0",
-		skipDoc:      true,
-		input:        `a: !!float 5`,
-		indent:       0,
-		expected:     "{\"a\":5.0}\n",
-		scenarioType: "encode",
-	},
-	{
-		description:  "Encode json: scientific notation float preserved",
-		skipDoc:      true,
-		input:        `a: 1.5e-3`,
-		indent:       0,
-		expected:     "{\"a\":1.5e-3}\n",
-		scenarioType: "encode",
-	},
-	{
-		description:  "Encode json: negative float preserved",
-		skipDoc:      true,
-		input:        `a: -7.0`,
-		indent:       0,
-		expected:     "{\"a\":-7.0}\n",
-		scenarioType: "encode",
-	},
-	{
-		description:  "Encode json: mixed int and float array",
-		skipDoc:      true,
-		input:        `a: [1, 2.0, 3, 4.5]`,
-		indent:       0,
-		expected:     "{\"a\":[1,2.0,3,4.5]}\n",
-		scenarioType: "encode",
-	},
 	{
 		description:  "Roundtrip JSON Lines / NDJSON",
 		input:        sampleNdJson,

pkg/yqlib/lexer.go

@@ -105,7 +105,7 @@ func handleToken(tokens []*token, index int, postProcessedTokens []*token) (toke
 	skipNextToken = false
 	currentToken := tokens[index]
 
-	log.Debugf("processing %v", currentToken.toString(true))
+	log.Debug("processing %v", currentToken.toString(true))
 
 	if currentToken.TokenType == traverseArrayCollect {
 		// `.[exp]`` works by creating a traversal array of [self, exp] and piping that into the traverse array operator
@@ -131,11 +131,6 @@ func handleToken(tokens []*token, index int, postProcessedTokens []*token) (toke
 			log.Debugf("previous token is : traverseArrayOpType")
 			// need to put the number 0 before this token, as that is implied
 			postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: createValueOperation(0, "0")})
-		} else if index >= 2 && tokens[index-1].TokenType == openCollect &&
-			(tokens[index-2].TokenType == operationToken || tokens[index-2].TokenType == closeCollect || tokens[index-2].TokenType == closeCollectObject) {
-			log.Debugf("previous token is : openCollect following a traversal, implying 0 start")
-			// need to put the number 0 before this token, as that is implied
-			postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: createValueOperation(0, "0")})
 		}
 	}
 

pkg/yqlib/lexer_participle.go

@@ -96,8 +96,6 @@ var participleYqRules = []*participleYqRule{
 	simpleOp("load_?str|str_?load", loadStringOpType),
 	{"LoadYaml", `load`, loadOp(NewYamlDecoder(LoadYamlPreferences)), 0},
 
-	simpleOp("system", systemOpType),
-
 	{"SplitDocument", `splitDoc|split_?doc`, opToken(splitDocumentOpType), 0},
 
 	simpleOp("select", selectOpType),
@@ -285,7 +283,7 @@ func pathToken(wrapped bool) yqAction {
 		if wrapped {
 			value = unwrap(value)
 		}
-		log.Debugf("PathToken %v", value)
+		log.Debug("PathToken %v", value)
 		op := &Operation{OperationType: traversePathOpType, Value: value, StringValue: value, Preferences: prefs}
 		return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
 	}
@@ -338,7 +336,7 @@ func flattenWithDepth() yqAction {
 
 func assignAllCommentsOp(updateAssign bool) yqAction {
 	return func(rawToken lexer.Token) (*token, error) {
-		log.Debugf("assignAllCommentsOp %v", rawToken.Value)
+		log.Debug("assignAllCommentsOp %v", rawToken.Value)
 		value := rawToken.Value
 		op := &Operation{
 			OperationType: assignCommentOpType,
@@ -353,7 +351,7 @@ func assignAllCommentsOp(updateAssign bool) yqAction {
 
 func assignOpToken(updateAssign bool) yqAction {
 	return func(rawToken lexer.Token) (*token, error) {
-		log.Debugf("assignOpToken %v", rawToken.Value)
+		log.Debug("assignOpToken %v", rawToken.Value)
 		value := rawToken.Value
 		prefs := assignPreferences{DontOverWriteAnchor: true}
 		if strings.Contains(value, "c") {
@@ -378,9 +376,9 @@ func nullValue() yqAction {
 
 func stringValue() yqAction {
 	return func(rawToken lexer.Token) (*token, error) {
-		log.Debugf("rawTokenvalue: %v", rawToken.Value)
+		log.Debug("rawTokenvalue: %v", rawToken.Value)
 		value := unwrap(rawToken.Value)
-		log.Debugf("unwrapped: %v", value)
+		log.Debug("unwrapped: %v", value)
 		value = processEscapeCharacters(value)
 		return &token{TokenType: operationToken, Operation: &Operation{
 			OperationType: stringInterpolationOpType,

pkg/yqlib/lib.go

@@ -4,10 +4,11 @@ package yqlib
 import (
 	"container/list"
 	"fmt"
-	"log/slog"
 	"math"
 	"strconv"
 	"strings"
+
+	logging "gopkg.in/op/go-logging.v1"
 )
 
 var ExpressionParser ExpressionParserInterface
@@ -18,17 +19,17 @@ func InitExpressionParser() {
 	}
 }
 
-var log = newLogger()
+var log = logging.MustGetLogger("yq-lib")
 
 var PrettyPrintExp = `(... | (select(tag != "!!str"), select(tag == "!!str") | select(test("(?i)^(y|yes|n|no|on|off)$") | not))  ) style=""`
 
 // GetLogger returns the yq logger instance.
-func GetLogger() *Logger {
+func GetLogger() *logging.Logger {
 	return log
 }
 
 func getContentValueByKey(content []*CandidateNode, key string) *CandidateNode {
-	for index := 0; index < len(content)-1; index = index + 2 {
+	for index := 0; index < len(content); index = index + 2 {
 		keyNode := content[index]
 		valueNode := content[index+1]
 		if keyNode.Value == key {
@@ -80,7 +81,7 @@ func recurseNodeObjectEqual(lhs *CandidateNode, rhs *CandidateNode) bool {
 		key := lhs.Content[index]
 		value := lhs.Content[index+1]
 
-		indexInRHS := findKeyInMap(rhs, key)
+		indexInRHS := findInArray(rhs, key)
 
 		if indexInRHS == -1 || !recursiveNodeEqual(value, rhs.Content[indexInRHS+1]) {
 			return false
@@ -250,7 +251,7 @@ func processEscapeCharacters(original string) string {
 
 	value := result.String()
 	if value != original {
-		log.Debugf("processEscapeCharacters from [%v] to [%v]", original, value)
+		log.Debug("processEscapeCharacters from [%v] to [%v]", original, value)
 	}
 	return value
 }
@@ -273,7 +274,7 @@ func footComment(node *CandidateNode) string {
 
 // use for debugging only
 func NodesToString(collection *list.List) string {
-	if !log.IsEnabledFor(slog.LevelDebug) {
+	if !log.IsEnabledFor(logging.DEBUG) {
 		return ""
 	}
 
@@ -285,7 +286,7 @@ func NodesToString(collection *list.List) string {
 }
 
 func NodeToString(node *CandidateNode) string {
-	if !log.IsEnabledFor(slog.LevelDebug) {
+	if !log.IsEnabledFor(logging.DEBUG) {
 		return ""
 	}
 	if node == nil {
@@ -303,7 +304,7 @@ func NodeToString(node *CandidateNode) string {
 }
 
 func NodeContentToString(node *CandidateNode, depth int) string {
-	if !log.IsEnabledFor(slog.LevelDebug) {
+	if !log.IsEnabledFor(logging.DEBUG) {
 		return ""
 	}
 	var sb strings.Builder

pkg/yqlib/lib_test.go

@@ -24,7 +24,7 @@ type parseSnippetScenario struct {
 var parseSnippetScenarios = []parseSnippetScenario{
 	{
 		snippet:       ":",
-		expectedError: "go-yaml load error in parser (while parsing a block mapping) at L1.C1: did not find expected key",
+		expectedError: "yaml: did not find expected key",
 	},
 	{
 		snippet: "",
@@ -300,24 +300,6 @@ func TestRecurseNodeObjectEqual(t *testing.T) {
 	test.AssertResult(t, true, recurseNodeObjectEqual(obj1, obj2))
 	test.AssertResult(t, false, recurseNodeObjectEqual(obj1, obj3))
 	test.AssertResult(t, false, recurseNodeObjectEqual(obj1, obj4))
-
-	// A null key must not match a null value in the other map.
-	// Regression test for https://issues.oss-fuzz.com/issues/383860504
-	nullKey := &CandidateNode{Kind: ScalarNode, Tag: "!!null"}
-	nullVal := &CandidateNode{Kind: ScalarNode, Tag: "!!null"}
-	intKey := createScalarNode(2, "2")
-	intKey.Tag = "!!int"
-	intVal := &CandidateNode{Kind: ScalarNode, Tag: "!!null"}
-
-	mapWithNullKey := &CandidateNode{
-		Kind:    MappingNode,
-		Content: []*CandidateNode{nullKey, nullVal},
-	}
-	mapWithIntKey := &CandidateNode{
-		Kind:    MappingNode,
-		Content: []*CandidateNode{intKey, intVal},
-	}
-	test.AssertResult(t, false, recurseNodeObjectEqual(mapWithNullKey, mapWithIntKey))
 }
 
 func TestParseInt(t *testing.T) {

pkg/yqlib/logger.go

@@ -1,77 +0,0 @@
-package yqlib
-
-import (
-	"fmt"
-	"log/slog"
-	"os"
-)
-
-// Logger wraps log/slog providing a printf-style interface used throughout yq.
-type Logger struct {
-	levelVar slog.LevelVar
-	slogger  *slog.Logger
-}
-
-func newLogger() *Logger {
-	l := &Logger{}
-	l.levelVar.Set(slog.LevelWarn)
-	handler := slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: &l.levelVar})
-	l.slogger = slog.New(handler)
-	return l
-}
-
-// SetLevel sets the minimum log level.
-func (l *Logger) SetLevel(level slog.Level) {
-	l.levelVar.Set(level)
-}
-
-// GetLevel returns the current log level.
-func (l *Logger) GetLevel() slog.Level {
-	return l.levelVar.Level()
-}
-
-// IsEnabledFor returns true if the given level is enabled.
-func (l *Logger) IsEnabledFor(level slog.Level) bool {
-	return l.levelVar.Level() <= level
-}
-
-// SetSlogger replaces the underlying slog.Logger (e.g. to configure output format).
-func (l *Logger) SetSlogger(logger *slog.Logger) {
-	l.slogger = logger
-}
-
-func (l *Logger) Debug(msg string) {
-	if l.IsEnabledFor(slog.LevelDebug) {
-		l.slogger.Debug(msg)
-	}
-}
-
-func (l *Logger) Debugf(format string, args ...interface{}) {
-	if l.IsEnabledFor(slog.LevelDebug) {
-		l.slogger.Debug(fmt.Sprintf(format, args...))
-	}
-}
-
-func (l *Logger) Info(msg string) {
-	l.slogger.Info(msg)
-}
-
-func (l *Logger) Infof(format string, args ...interface{}) {
-	l.slogger.Info(fmt.Sprintf(format, args...))
-}
-
-func (l *Logger) Warning(msg string) {
-	l.slogger.Warn(msg)
-}
-
-func (l *Logger) Warningf(format string, args ...interface{}) {
-	l.slogger.Warn(fmt.Sprintf(format, args...))
-}
-
-func (l *Logger) Error(msg string) {
-	l.slogger.Error(msg)
-}
-
-func (l *Logger) Errorf(format string, args ...interface{}) {
-	l.slogger.Error(fmt.Sprintf(format, args...))
-}

pkg/yqlib/no_ini.go

@@ -2,7 +2,7 @@
 
 package yqlib
 
-func NewINIDecoder(prefs INIPreferences) Decoder {
+func NewINIDecoder() Decoder {
 	return nil
 }
 

pkg/yqlib/operation.go

@@ -25,7 +25,7 @@ var valueToStringFunc = func(p *Operation) string {
 }
 
 func createValueOperation(value interface{}, stringValue string) *Operation {
-	log.Debugf("creating value op for string %v", stringValue)
+	log.Debug("creating value op for string %v", stringValue)
 	var node = createScalarNode(value, stringValue)
 
 	return &Operation{
@@ -164,8 +164,6 @@ var stringInterpolationOpType = &operationType{Type: "STRING_INT", NumArgs: 0, P
 var loadOpType = &operationType{Type: "LOAD", NumArgs: 1, Precedence: 52, Handler: loadOperator, CheckForPostTraverse: true}
 var loadStringOpType = &operationType{Type: "LOAD_STRING", NumArgs: 1, Precedence: 52, Handler: loadStringOperator}
 
-var systemOpType = &operationType{Type: "SYSTEM", NumArgs: 1, Precedence: 50, Handler: systemOperator}
-
 var keysOpType = &operationType{Type: "KEYS", NumArgs: 0, Precedence: 52, Handler: keysOperator, CheckForPostTraverse: true}
 
 var collectObjectOpType = &operationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: collectObjectOperator}

pkg/yqlib/operator_add.go

@@ -195,9 +195,9 @@ func addMaps(target *CandidateNode, lhsC *CandidateNode, rhsC *CandidateNode) {
 	for index := 0; index < len(rhs.Content); index = index + 2 {
 		key := rhs.Content[index]
 		value := rhs.Content[index+1]
-		log.Debugf("finding %v", key.Value)
+		log.Debug("finding %v", key.Value)
 		indexInLHS := findKeyInMap(target, key)
-		log.Debugf("indexInLhs %v", indexInLHS)
+		log.Debug("indexInLhs %v", indexInLHS)
 		if indexInLHS < 0 {
 			// not in there, append it
 			target.AddKeyValueChild(key, value)

pkg/yqlib/operator_add_test.go

@@ -527,18 +527,6 @@ var addOperatorScenarios = []expressionScenario{
 		expression:    `.a += [2]`,
 		expectedError: "!!seq () cannot be added to a !!str (a)",
 	},
-	{
-		// Regression test for https://issues.oss-fuzz.com/issues/383860504
-		// Adding a map to itself must not panic when sequence keys contain
-		// single-entry mappings with a null key in one and a non-null key
-		// in the other.
-		skipDoc:    true,
-		document:   "? [{~: ~}]\n: v1\n? [{2: ~}]\n: v2",
-		expression: `. += .`,
-		expected: []string{
-			"D0, P[], (!!map)::? [{~: ~}]\n: v1\n? [{2: ~}]\n: v2\n",
-		},
-	},
 }
 
 func TestAddOperatorScenarios(t *testing.T) {

pkg/yqlib/operator_anchors_aliases.go

@@ -170,10 +170,6 @@ func fixedReconstructAliasedMap(node *CandidateNode) error {
 				if mergeNodeSeq.Kind == AliasNode {
 					mergeNodeSeq = mergeNodeSeq.Alias
 				}
-				mergeNodeSeq = mergeNodeSeq.Copy()
-				if err := explodeNode(mergeNodeSeq, Context{}); err != nil {
-					return err
-				}
 				if mergeNodeSeq.Kind != MappingNode {
 					return fmt.Errorf("can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got sequence containing %v", mergeNodeSeq.Tag)
 				}
@@ -183,7 +179,12 @@ func fixedReconstructAliasedMap(node *CandidateNode) error {
 				})
 
 				for _, item := range itemsToAdd {
-					newContent = append(newContent, item.Copy())
+					// copy to ensure exploding doesn't modify the original node
+					itemCopy := item.Copy()
+					if err := explodeNode(itemCopy, Context{}); err != nil {
+						return err
+					}
+					newContent = append(newContent, itemCopy)
 				}
 			}
 		}
@@ -255,7 +256,7 @@ func explodeNode(node *CandidateNode, context Context) error {
 			node.Value = node.Alias.Value
 			node.Alias = nil
 		}
-		log.Debugf("now I'm %v", NodeToString(node))
+		log.Debug("now I'm %v", NodeToString(node))
 		return nil
 	case MappingNode:
 		// //check the map has an alias in it
@@ -303,7 +304,7 @@ func applyAlias(node *CandidateNode, alias *CandidateNode, aliasIndex int, newCo
 	if alias == nil {
 		return nil
 	}
-	log.Debugf("alias: %v", NodeToString(alias))
+	log.Debug("alias: %v", NodeToString(alias))
 	if alias.Kind != MappingNode {
 		return fmt.Errorf("can only use merge anchors with maps (!!map) or sequences (!!seq) of maps, but got sequence containing %v", alias.Tag)
 	}

pkg/yqlib/operator_anchors_aliases_test.go

@@ -31,7 +31,7 @@ thingOne:
     value: false
 thingTwo:
     name: item_2
-    <<: *item_value
+    !!merge <<: *item_value
 `
 
 var explodeMergeAnchorsFixedExpected = `D0, P[], (!!map)::foo:
@@ -198,15 +198,6 @@ var fixedAnchorOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::{a: 42}\n",
 		},
 	},
-	{
-		skipDoc:     true,
-		description: "Nested merge anchor with inline map",
-		document:    `{<<: {<<: {a: 42}}}`,
-		expression:  `explode(.)`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: 42}\n",
-		},
-	},
 	{
 		skipDoc:     true,
 		description: "Merge anchor with sequence with inline map",
@@ -288,63 +279,7 @@ var badAnchorOperatorScenarios = []expressionScenario{
 	},
 }
 
-var mixedMergeTagStyleDocument = `
-constants:
-    errorResponse: &errorResponse
-        status: 200
-endpoints:
-    - condition: true
-      !!merge <<: *errorResponse
-    - condition: false
-      <<: *errorResponse
-other:
-    !!merge <<: *errorResponse
-somethingElse:
-    <<: *errorResponse
-`
-
-var mixedMergeTagStyleExplodedDocument = `
-constants:
-    errorResponse:
-        status: 200
-endpoints:
-    - condition: true
-      status: 200
-    - condition: false
-      status: 200
-other:
-    status: 200
-somethingElse:
-    status: 200
-`
-
 var anchorOperatorScenarios = []expressionScenario{
-	{
-		// mergeObjects previously skipped all !!merge-tagged nodes. Since !!merge only appears on
-		// << map keys, this meant applyAssignment was never called for the << key. It was later
-		// autocreated by createStringScalarNode("<<") with tag !!str, silently dropping !!merge.
-		// DontFollowAlias:true already prevents aliases being followed, so the skip was redundant.
-		// Old (buggy) output: "D0, P[], (!!map)::base: &base\n    x: 1\ndest:\n    <<: *base\n"
-		skipDoc:     true,
-		description: "direct *+ preserves explicit !!merge tag on << key (regression for issue 2677)",
-		document:    "base: &base\n    x: 1\ndest:\n    !!merge <<: *base\n",
-		expression:  `. as $d | {} *+ $d`,
-		expected:    []string{"D0, P[], (!!map)::base: &base\n    x: 1\ndest:\n    !!merge <<: *base\n"},
-	},
-	{
-		skipDoc:     true,
-		description: "explicit !!merge tag on << key is preserved through ireduce merge",
-		document:    mixedMergeTagStyleDocument,
-		expression:  `. as $item ireduce ({}; . *+ $item)`,
-		expected:    []string{"D0, P[], (!!map)::" + mixedMergeTagStyleDocument},
-	},
-	{
-		skipDoc:     true,
-		description: "explode expands << merge keys regardless of explicit tag style (!!merge or plain)",
-		document:    mixedMergeTagStyleDocument,
-		expression:  `explode(.)`,
-		expected:    []string{"D0, P[], (!!map)::" + mixedMergeTagStyleExplodedDocument},
-	},
 	{
 		skipDoc:     true,
 		description: "merge anchor to alias alias",

pkg/yqlib/operator_assign.go

@@ -37,7 +37,7 @@ func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode
 
 	prefs := getAssignPreferences(expressionNode.Operation.Preferences)
 
-	log.Debugf("assignUpdateOperator prefs: %v", prefs)
+	log.Debug("assignUpdateOperator prefs: %v", prefs)
 
 	if !expressionNode.Operation.UpdateAssign {
 		// this works because we already ran against LHS with an editable context.

pkg/yqlib/operator_booleans.go

@@ -142,7 +142,7 @@ func notOperator(_ *dataTreeNavigator, context Context, _ *ExpressionNode) (Cont
 
 	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		log.Debugf("notOperation checking %v", candidate)
+		log.Debug("notOperation checking %v", candidate)
 		truthy := isTruthyNode(candidate)
 		result := createBooleanCandidate(candidate, !truthy)
 		results.PushBack(result)

pkg/yqlib/operator_contains.go

@@ -46,9 +46,9 @@ func containsObject(lhs *CandidateNode, rhs *CandidateNode) (bool, error) {
 		rhsKey := rhs.Content[index]
 		rhsValue := rhs.Content[index+1]
 		log.Debugf("Looking for %v in the lhs", rhsKey.Value)
-		lhsKeyIndex := findKeyInMap(lhs, rhsKey)
+		lhsKeyIndex := findInArray(lhs, rhsKey)
 		log.Debugf("index is %v", lhsKeyIndex)
-		if lhsKeyIndex < 0 {
+		if lhsKeyIndex < 0 || lhsKeyIndex%2 != 0 {
 			return false, nil
 		}
 		lhsValue := lhs.Content[lhsKeyIndex+1]

pkg/yqlib/operator_contains_test.go

@@ -65,16 +65,6 @@ var containsOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!bool)::false\n",
 		},
 	},
-	{
-		// Regression: findInArray could match a null key against a null
-		// value at an earlier odd index, producing a false negative.
-		skipDoc:    true,
-		document:   "? 1\n: ~\n? ~\n: x",
-		expression: `contains({~: "x"})`,
-		expected: []string{
-			"D0, P[], (!!bool)::true\n",
-		},
-	},
 	{
 		description: "String contains substring",
 		document:    `"foobar"`,

pkg/yqlib/operator_datetime.go

@@ -80,7 +80,7 @@ func formatDateTime(d *dataTreeNavigator, context Context, expressionNode *Expre
 
 		node, errorReading := parseSnippet(formattedTimeStr)
 		if errorReading != nil {
-			log.Debugf("could not parse %v - lets just leave it as a string: %v", formattedTimeStr, errorReading)
+			log.Debugf("could not parse %v - lets just leave it as a string: %w", formattedTimeStr, errorReading)
 			node = &CandidateNode{
 				Kind:  ScalarNode,
 				Tag:   "!!str",

pkg/yqlib/operator_delete.go

@@ -45,7 +45,7 @@ func removeFromContext(context Context, candidate *CandidateNode) (Context, erro
 		if nodeInContext != candidate {
 			newResults.PushBack(nodeInContext)
 		} else {
-			log.Infof("Need to delete this %v", NodeToString(nodeInContext))
+			log.Info("Need to delete this %v", NodeToString(nodeInContext))
 		}
 	}
 	return context.ChildContext(newResults), nil

pkg/yqlib/operator_divide_test.go

@@ -45,7 +45,7 @@ var divideOperatorScenarios = []expressionScenario{
 		document:       `{a: 1, b: -1}`,
 		expression:     `.a = .a / 0 | .b = .b / 0`,
 		expected: []string{
-			"D0, P[], (!!map)::{a: +Inf, b: -Inf}\n",
+			"D0, P[], (!!map)::{a: !!float +Inf, b: !!float -Inf}\n",
 		},
 	},
 	{

pkg/yqlib/operator_encoder_decoder.go

@@ -33,7 +33,7 @@ func configureEncoder(format *Format, indent int) Encoder {
 
 func encodeToString(candidate *CandidateNode, prefs encoderPreferences) (string, error) {
 	var output bytes.Buffer
-	log.Debugf("printing with indent: %v", prefs.indent)
+	log.Debug("printing with indent: %v", prefs.indent)
 
 	encoder := configureEncoder(prefs.format, prefs.indent)
 	if encoder == nil {

pkg/yqlib/operator_entries.go

@@ -157,10 +157,10 @@ func withEntriesOperator(d *dataTreeNavigator, context Context, expressionNode *
 		if err != nil {
 			return Context{}, err
 		}
-		log.Debugf("candidate %v", NodeToString(candidate))
+		log.Debug("candidate %v", NodeToString(candidate))
-		log.Debugf("candidate leading content: %v", candidate.LeadingContent)
+		log.Debug("candidate leading content: %v", candidate.LeadingContent)
 		collected.LeadingContent = candidate.LeadingContent
-		log.Debugf("candidate FootComment: [%v]", candidate.FootComment)
+		log.Debug("candidate FootComment: [%v]", candidate.FootComment)
 
 		collected.HeadComment = candidate.HeadComment
 		collected.FootComment = candidate.FootComment

pkg/yqlib/operator_env.go

@@ -21,7 +21,7 @@ func envOperator(_ *dataTreeNavigator, context Context, expressionNode *Expressi
 		return Context{}, fmt.Errorf("env operations have been disabled")
 	}
 	envName := expressionNode.Operation.CandidateNode.Value
-	log.Debugf("EnvOperator, env name: %v", envName)
+	log.Debug("EnvOperator, env name:", envName)
 
 	rawValue := os.Getenv(envName)
 
@@ -49,9 +49,9 @@ func envOperator(_ *dataTreeNavigator, context Context, expressionNode *Expressi
 		}
 
 	}
-	log.Debugf("ENV tag: %v", node.Tag)
+	log.Debug("ENV tag", node.Tag)
-	log.Debugf("ENV value: %v", node.Value)
+	log.Debug("ENV value", node.Value)
-	log.Debugf("ENV Kind: %v", node.Kind)
+	log.Debug("ENV Kind", node.Kind)
 
 	return context.SingleChildContext(node), nil
 }
@@ -78,7 +78,7 @@ func envsubstOperator(_ *dataTreeNavigator, context Context, expressionNode *Exp
 	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
 		node := el.Value.(*CandidateNode)
 		if node.Tag != "!!str" {
-			log.Warningf("EnvSubstOperator, env name: %v %v", node.Tag, node.Value)
+			log.Warning("EnvSubstOperator, env name:", node.Tag, node.Value)
 			return Context{}, fmt.Errorf("cannot substitute with %v, can only substitute strings. Hint: Most often you'll want to use '|=' over '=' for this operation", node.Tag)
 		}
 

pkg/yqlib/operator_load_test.go

@@ -77,7 +77,7 @@ var loadScenarios = []expressionScenario{
 		document:       `{something: {file: "thing.yml"}, over: {here: [{file: "thing.yml"}]}}`,
 		expression:     `(.. | select(has("file"))) |= load("../../examples/" + .file)`,
 		expected: []string{
-			"D0, P[], (!!map)::{something: {a: apple is included, b: cool.}, over: {here: [{a: apple is included,\n                b: cool.}]}}\n",
+			"D0, P[], (!!map)::{something: {a: apple is included, b: cool.}, over: {here: [{a: apple is included, b: cool.}]}}\n",
 		},
 	},
 	{

pkg/yqlib/operator_map.go

@@ -47,8 +47,8 @@ func mapOperator(d *dataTreeNavigator, context Context, expressionNode *Expressi
 		}
 
 		result, err := d.GetMatchingNodes(splatted, expressionNode.RHS)
-		log.Debugf("expressionNode.Rhs %v", expressionNode.RHS.Operation.OperationType)
+		log.Debug("expressionNode.Rhs %v", expressionNode.RHS.Operation.OperationType)
-		log.Debugf("result %v", result)
+		log.Debug("result %v", result)
 		if err != nil {
 			return Context{}, err
 		}

pkg/yqlib/operator_modulo_test.go

@@ -37,7 +37,7 @@ var moduloOperatorScenarios = []expressionScenario{
 		document:       `{a: 12, b: 2.5}`,
 		expression:     `.a = .a % .b`,
 		expected: []string{
-			"D0, P[], (!!map)::{a: 2, b: 2.5}\n",
+			"D0, P[], (!!map)::{a: !!float 2, b: 2.5}\n",
 		},
 	},
 	{
@@ -53,7 +53,7 @@ var moduloOperatorScenarios = []expressionScenario{
 		document:       `{a: 1.1, b: 0}`,
 		expression:     `.a = .a % .b`,
 		expected: []string{
-			"D0, P[], (!!map)::{a: NaN, b: 0}\n",
+			"D0, P[], (!!map)::{a: !!float NaN, b: 0}\n",
 		},
 	},
 	{
@@ -70,7 +70,7 @@ var moduloOperatorScenarios = []expressionScenario{
 		document:   "a: 2\nb: !goat 2.3",
 		expression: `.a = .a % .b`,
 		expected: []string{
-			"D0, P[], (!!map)::a: 2\nb: !goat 2.3\n",
+			"D0, P[], (!!map)::a: !!float 2\nb: !goat 2.3\n",
 		},
 	},
 	{

pkg/yqlib/operator_multiply.go

@@ -155,10 +155,8 @@ func repeatString(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error
 		return nil, err
 	} else if count < 0 {
 		return nil, fmt.Errorf("cannot repeat string by a negative number (%v)", count)
-	}
+	} else if count > 10000000 {
-	maxResultLen := 10 * 1024 * 1024 // 10 MiB
+		return nil, fmt.Errorf("cannot repeat string by more than 100 million (%v)", count)
-	if count > 0 && len(stringNode.Value) > maxResultLen/count {
-		return nil, fmt.Errorf("result of repeating string (%v bytes) by %v would exceed %v bytes", len(stringNode.Value), count, maxResultLen)
 	}
 	target.Value = strings.Repeat(stringNode.Value, count)
 
@@ -189,6 +187,10 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs
 
 		log.Debugf("going to applied assignment to LHS: %v with RHS: %v", NodeToString(lhs), NodeToString(candidate))
 
+		if candidate.Tag == "!!merge" {
+			continue
+		}
+
 		err := applyAssignment(d, context, pathIndexToStartFrom, lhs, candidate, preferences)
 		if err != nil {
 			return nil, err