@signalk/app-dock 1.2.1 → 1.3.1

package/README.md

@@ -37,6 +37,36 @@ Tip: double-tapping a clickable element in the underlying webapp will activate t
 
 Config changes made in **Plugin Config** apply automatically within ~5 seconds: structural changes (position, icon size, etc.) reload the dock page; changes to the app list hot-update in place.
 
+## Apps on another origin
+
+The dock notices a double-tap by listening inside each app's page, and a browser allows that only for pages on the same origin (scheme, host and port) as the dock. A page from another port or host is out of reach: the app itself, a page the app moves its frame to (such as a radar display opened directly on its own server), or one the app shows in a frame of its own. While any such page in the app on screen does not forward its taps, a small tab at the dock's edge opens the dock with a single tap.
+
+An app on another origin can bring back double-tap by forwarding its pointerdowns to the dock:
+
+```js
+if (window.self !== window.top) {
+  document.addEventListener(
+    'pointerdown',
+    (e) => {
+      window.top.postMessage(
+        {
+          type: 'signalk-app-dock:pointerdown',
+          x: e.clientX,
+          y: e.clientY,
+          t: performance.timeOrigin + e.timeStamp
+        },
+        '*'
+      )
+    },
+    { passive: true, capture: true }
+  )
+}
+```
+
+`t` is when the tap happened. It is optional, but a page that is busy, rendering a radar display for example, can post its messages late, and without `t` the dock can only go by when they arrive, which can split a double-tap in two.
+
+The dock accepts these messages only from a page of the app on screen that it cannot listen to itself, or a frame inside that page, and all they do is count towards a double-tap. The tab goes away once every such page has sent one. A page that loads again starts over: the tab is back until its first tap.
+
 ## Install as an app
 
 The dock ships a web app manifest, so iOS and Android can install it to the home screen and launch it like a native app -- no Safari/Chrome chrome, no URL bar.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalk/app-dock",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "macOS-style configurable app dock for switching between SignalK webapps on touch screens",
   "repository": {
     "url": "https://github.com/SignalK/app-dock"
@@ -22,6 +22,11 @@
     ]
   },
   "main": "plugin/index.js",
+  "files": [
+    "plugin/",
+    "public/",
+    "docs/screenshots/"
+  ],
   "scripts": {
     "build:config": "webpack",
     "prepublishOnly": "webpack",

package/public/dock.css

@@ -99,6 +99,68 @@ body {
   }
 }
 
+/* ─── Handle over an app on another origin ─────────────────────────────────── */
+/* The padding is the touch target; the bar itself is drawn by ::before. */
+#dock-handle {
+  position: fixed;
+  z-index: 5;
+  display: none;
+  padding: 12px 18px;
+  border: none;
+  background: transparent;
+  -webkit-appearance: none;
+  appearance: none;
+  cursor: pointer;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+}
+
+#dock-handle.visible {
+  display: block;
+}
+
+#dock-handle::before {
+  content: '';
+  display: block;
+  width: 56px;
+  height: 6px;
+  border-radius: 3px;
+  background: rgba(255, 255, 255, 0.6);
+  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.35);
+}
+
+#dock-handle.pos-bottom {
+  bottom: env(safe-area-inset-bottom, 0px);
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+#dock-handle.pos-top {
+  top: env(safe-area-inset-top, 0px);
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+#dock-handle.pos-left {
+  left: env(safe-area-inset-left, 0px);
+  top: 50%;
+  transform: translateY(-50%);
+  padding: 18px 12px;
+}
+
+#dock-handle.pos-right {
+  right: env(safe-area-inset-right, 0px);
+  top: 50%;
+  transform: translateY(-50%);
+  padding: 18px 12px;
+}
+
+#dock-handle.pos-left::before,
+#dock-handle.pos-right::before {
+  width: 6px;
+  height: 56px;
+}
+
 /* ─── Backdrop ──────────────────────────────────────────────────────────────── */
 #dock-backdrop {
   position: fixed;

package/public/dock.js

@@ -164,6 +164,7 @@
   const $loadingLabel = document.getElementById('loading-label')
   const $idleHint = document.getElementById('idle-hint')
   const $idleHintText = document.getElementById('idle-hint-text')
+  const $dockHandle = document.getElementById('dock-handle')
 
   // ─── State ───────────────────────────────────────────────────────────────────
   let dockVisible = false
@@ -250,6 +251,7 @@
   const pos = cfg.position
   $dock.classList.add(`pos-${pos}`)
   $dockInner.classList.add(`align-${pos}`)
+  $dockHandle.classList.add(`pos-${pos}`)
 
   const isVertical = pos === 'left' || pos === 'right'
   if (isVertical) $dockInner.classList.add('layout-vertical')
@@ -576,6 +578,7 @@
     dockShownAt = Date.now()
     $dock.classList.add('visible')
     $backdrop.classList.add('visible')
+    updateHandle()
   }
 
   function hideDock() {
@@ -585,6 +588,7 @@
     $dock.classList.remove('visible')
     $backdrop.classList.remove('visible')
     resetMagnification()
+    updateHandle()
   }
 
   $backdrop.addEventListener('click', (e) => {
@@ -649,6 +653,7 @@
     }
 
     iframes[app.url].classList.add('active')
+    updateHandle()
     hideDock()
   }
 
@@ -665,6 +670,22 @@
   let lastTapTime = 0
   let lastTapX = 0
   let lastTapY = 0
+  // Coordinates are in the dock's viewport unless a tap names another space:
+  // two taps pair up only within the same one.
+  let lastTapSpace = null
+
+  // Taps are timed by when they happened, not when their handler ran: a page
+  // busy rendering can hold a pointerdown back long enough to split a
+  // double-tap. Times are on the clock every document in the browser shares,
+  // performance.timeOrigin plus the page's own high-resolution time.
+  function nowTime() {
+    return performance.timeOrigin + performance.now()
+  }
+
+  function eventTime(doc, e) {
+    const perf = doc.defaultView && doc.defaultView.performance
+    return perf ? perf.timeOrigin + e.timeStamp : nowTime()
+  }
 
   function triggerDock() {
     if (DEBUG) console.log('[Dock] triggerDock called, dockVisible=', dockVisible)
@@ -679,15 +700,14 @@
 
   const DEBUG = new URLSearchParams(location.search).has('debugDock')
 
-  function handleTap(clientX, clientY) {
+  function handleTap(clientX, clientY, space = null, time = nowTime()) {
     if (dockVisible) return
-    const now = Date.now()
     const dx = clientX - lastTapX
     const dy = clientY - lastTapY
     const dist = Math.round(Math.sqrt(dx * dx + dy * dy))
-    const close = dist <= DOUBLE_TAP_SLOP
-    const gap = now - lastTapTime
-    const match = gap < DOUBLE_TAP_MS && close
+    const close = dist <= DOUBLE_TAP_SLOP && space === lastTapSpace
+    const gap = time - lastTapTime
+    const match = gap >= 0 && gap < DOUBLE_TAP_MS && close
     if (DEBUG) {
       console.log('[Dock] tap', { x: Math.round(clientX), y: Math.round(clientY), gap, dist, close, match })
     }
@@ -695,9 +715,10 @@
       lastTapTime = 0
       triggerDock()
     } else {
-      lastTapTime = now
+      lastTapTime = time
       lastTapX = clientX
       lastTapY = clientY
+      lastTapSpace = space
     }
   }
 
@@ -713,22 +734,23 @@
 
     // Dedupe: touchstart and pointerdown often both fire for the same gesture.
     // We accept whichever arrives first and ignore the other if it's within
-    // 50 ms (the browser's synthesized-event coalescence window).
-    let lastEventAt = 0
+    // 50 ms (the browser's synthesized-event coalescence window). The window is
+    // measured in event time: after the page stalls, two real taps can be
+    // handled back to back, and neither may be taken for the other's twin.
+    let lastEventAt = -Infinity
     const COALESCE_MS = 50
 
-    const onDown = (x, y) => {
-      const now = Date.now()
-      if (now - lastEventAt < COALESCE_MS) return
-      lastEventAt = now
-      handleTap(x, y)
+    const onDown = (x, y, time) => {
+      if (Math.abs(time - lastEventAt) < COALESCE_MS) return
+      lastEventAt = time
+      handleTap(x, y, null, time)
     }
 
     doc.addEventListener(
       'pointerdown',
       (e) => {
         const o = offset()
-        onDown(e.clientX + o.x, e.clientY + o.y)
+        onDown(e.clientX + o.x, e.clientY + o.y, eventTime(doc, e))
       },
       { passive: true, capture: true }
     )
@@ -743,7 +765,7 @@
         if (!e.touches || e.touches.length === 0) return
         const t = e.touches[0]
         const o = offset()
-        onDown(t.clientX + o.x, t.clientY + o.y)
+        onDown(t.clientX + o.x, t.clientY + o.y, eventTime(doc, e))
       },
       { passive: true, capture: true }
     )
@@ -756,12 +778,14 @@
 
   function attachToIframe(frame) {
     const wire = () => {
-      let doc
+      let doc = null
       try {
         doc = frame.contentDocument
       } catch {
-        return // cross-origin; can't reach
+        // cross-origin; can't reach
       }
+      const app = appFrameOf(frame)
+      if (app) noteFrameReach(app, frame, doc !== null)
       if (!doc || attachedDocs.has(doc)) return
       attachedDocs.add(doc)
       attachTapListener(doc, frame)
@@ -786,11 +810,140 @@
           const nested = n.querySelectorAll && n.querySelectorAll('iframe')
           if (nested) nested.forEach((f) => attachToIframe(f))
         })
+        // A removed frame may have been the one keeping the handle up.
+        if (r.removedNodes.length > 0) updateHandle()
       }
     })
     obs.observe(root, { childList: true, subtree: true })
   }
 
+  // ─── Apps on another origin ──────────────────────────────────────────────────
+  // The listeners above cannot reach a page from another origin, so a
+  // double-tap over one goes unseen. That page may be the app itself or a
+  // frame inside it. Such a page can forward its pointerdowns instead, and
+  // while any page in the active app is out of reach and not forwarding, a
+  // tab at the dock's edge opens the dock with a single tap.
+  //
+  // A forwarded pointerdown is a message posted to the dock's window:
+  //   window.top.postMessage({ type: 'signalk-app-dock:pointerdown', x: e.clientX, y: e.clientY }, '*')
+  // It counts only from inside a frame of the active app that the listeners
+  // cannot reach, so no tap is counted twice, and all it can do is feed the
+  // double-tap detection.
+  const FORWARDED_POINTERDOWN = 'signalk-app-dock:pointerdown'
+  const FORWARD_COALESCE_MS = 50
+  // Per app frame, the frames in it (itself included) the listeners cannot
+  // reach, and which of those have sent a pointerdown of their own since they
+  // loaded.
+  const unreachableFrames = new WeakMap()
+  const forwardingFrames = new WeakSet()
+  let lastForwardedAt = -Infinity
+
+  // The app frame a frame belongs to: the frame itself, or the one holding
+  // the document it sits in, found through same-origin parents.
+  function appFrameOf(frame) {
+    let f = frame
+    while (f && f.parentElement !== $iframeContainer) {
+      const win = f.ownerDocument && f.ownerDocument.defaultView
+      f = win ? win.frameElement : null
+    }
+    return f
+  }
+
+  // Runs on every load of a frame in an app. A new document starts over:
+  // whether it forwards is not known until it does, and an app frame's new
+  // document brings its own frames.
+  function noteFrameReach(app, frame, reachable) {
+    forwardingFrames.delete(frame)
+    let frames = unreachableFrames.get(app)
+    if (frame === app || !frames) {
+      frames = new Set()
+      unreachableFrames.set(app, frames)
+    }
+    if (reachable) frames.delete(frame)
+    else frames.add(frame)
+    updateHandle()
+  }
+
+  // Frames removed from their document, or left in one that has been
+  // navigated away, are dropped as they are found.
+  function liveUnreachableFrames(app) {
+    const frames = (app && unreachableFrames.get(app)) || new Set()
+    for (const f of frames) {
+      if (!f.isConnected || !f.ownerDocument.defaultView) frames.delete(f)
+    }
+    return frames
+  }
+
+  function updateHandle() {
+    const app = $iframeContainer.querySelector('iframe.active')
+    let show = false
+    if (!dockVisible) {
+      for (const f of liveUnreachableFrames(app)) {
+        if (!forwardingFrames.has(f)) show = true
+      }
+    }
+    $dockHandle.classList.toggle('visible', show)
+  }
+
+  // Where a frame's content starts in the dock's viewport, adding up the
+  // frames it sits in.
+  function offsetInDock(frame) {
+    let x = 0
+    let y = 0
+    for (let f = frame; f; ) {
+      const r = f.getBoundingClientRect()
+      x += r.left
+      y += r.top
+      if (f.parentElement === $iframeContainer) break
+      const win = f.ownerDocument.defaultView
+      f = win ? win.frameElement : null
+    }
+    return { x, y }
+  }
+
+  function isInsideFrame(source, frameWindow) {
+    for (let w = source; w; w = w.parent) {
+      if (w === frameWindow) return true
+      if (w === w.parent) return false
+    }
+    return false
+  }
+
+  window.addEventListener('message', (e) => {
+    const data = e.data
+    if (!data || data.type !== FORWARDED_POINTERDOWN) return
+    if (!Number.isFinite(data.x) || !Number.isFinite(data.y)) return
+    const app = $iframeContainer.querySelector('iframe.active')
+    if (!app || !e.source) return
+    let from = null
+    for (const f of liveUnreachableFrames(app)) {
+      if (isInsideFrame(e.source, f.contentWindow)) from = f
+    }
+    if (!from) return
+    // A frame inside the page forwarding says nothing about taps on the page
+    // around it, so only the page's own message stops the handle.
+    if (e.source === from.contentWindow) {
+      forwardingFrames.add(from)
+      updateHandle()
+    }
+    // The page can say when the tap happened. Without that, or with a time
+    // that has not come yet, the message's arrival stands in for it.
+    const received = nowTime()
+    const time = Number.isFinite(data.t) && data.t <= received ? data.t : received
+    if (Math.abs(time - lastForwardedAt) < FORWARD_COALESCE_MS) return
+    lastForwardedAt = time
+    // A frame inside the page sits somewhere the dock cannot see, so its
+    // taps keep their own coordinates and pair up only with each other.
+    if (e.source === from.contentWindow) {
+      const o = offsetInDock(from)
+      handleTap(data.x + o.x, data.y + o.y, null, time)
+    } else {
+      handleTap(data.x, data.y, e.source, time)
+    }
+  })
+
+  $dockHandle.addEventListener('click', triggerDock)
+
   attachTapListener(document, null)
   attachedDocs.add(document)
   scanAndObserveDoc(document)

package/public/index.html

@@ -28,6 +28,10 @@
       <div id="idle-hint-text"></div>
     </div>
 
+    <!-- Tab that opens the dock over an app on another origin, where a
+         double-tap cannot be detected -->
+    <button id="dock-handle" type="button" aria-label="Open the dock"></button>
+
     <!-- Dimming overlay shown when dock is open; tap to close -->
     <div id="dock-backdrop"></div>
 

package/.gitattributes

@@ -1,5 +0,0 @@
-# Force LF line endings on checkout regardless of the host's
-# core.autocrlf setting. Prettier/eslint enforce LF; without this,
-# Windows CI runners check out CRLF and `prettier --check` reports
-# every line as "Delete `␍`".
-* text=auto eol=lf

package/.github/release.yml

@@ -1,37 +0,0 @@
-# Categories for the release notes GitHub generates for each tag, built from
-# the titles of the PRs merged since the previous one. release-please asks
-# GitHub for these notes (changelog-type: github in
-# release-please-config.json), and so does release_on_tag.yml for a
-# pre-release tag pushed by hand.
-#
-# A PR lands in the first category it matches, so the catch-all is last.
-# workflows/label-by-title.yml sets the label from the PR title's type, and
-# this file and that workflow name the same labels. A label set by hand
-# places a PR the same way until its title is edited; an unlabelled one
-# still appears, under Other.
-changelog:
-  exclude:
-    labels:
-      - skip-changelog
-      # release-please's own release PR, merged right before each tag, which
-      # would otherwise list itself.
-      - 'autorelease: pending'
-      - 'autorelease: tagged'
-  categories:
-    - title: 🚀 Features
-      labels:
-        - feature
-        - enhancement
-    - title: 🐛 Fixes
-      labels:
-        - bug
-        - fix
-    - title: 📖 Documentation
-      labels:
-        - documentation
-    - title: 📦 Dependencies
-      labels:
-        - dependencies
-    - title: Other
-      labels:
-        - '*'

package/.github/workflows/ci.yml

@@ -1,11 +0,0 @@
-name: SignalK Plugin CI
-
-on:
-  push:
-    branches: [main, master]
-  pull_request:
-    branches: [main, master]
-
-jobs:
-  test:
-    uses: SignalK/signalk-server/.github/workflows/plugin-ci.yml@master

package/.github/workflows/label-by-title.yml

@@ -1,67 +0,0 @@
-name: label-by-title
-
-on:
-  pull_request_target:
-    types: [opened, edited, reopened]
-
-permissions: {}
-
-jobs:
-  # .github/release.yml sorts the release notes by label, and a pull request
-  # opened from the command line carries none. The label follows the title's
-  # conventional-commit type. Only the title is read, with no checkout and
-  # nothing from the pull request run here, which is what makes
-  # pull_request_target safe to use and what lets a pull request from a fork
-  # be labelled.
-  #
-  # `edited` also fires for a body or base-branch edit; those leave the labels
-  # alone, so a label set by hand stays until the title changes.
-  label:
-    if: ${{ github.event.action != 'edited' || github.event.changes.title }}
-    # One run per pull request at a time: two overlapping runs would each read
-    # the labels, then each edit, and could leave two managed labels behind.
-    # Set on the job, after the condition above, so that a body edit, which
-    # skips the job, cannot cancel a title edit's run.
-    concurrency:
-      group: label-by-title-${{ github.event.pull_request.number }}
-      cancel-in-progress: true
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      pull-requests: write
-    steps:
-      - env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.pull_request.number }}
-          TITLE: ${{ github.event.pull_request.title }}
-        run: |
-          # The labels this workflow owns: one of them at a time, so a title
-          # edited from feat to fix swaps the label rather than adding one.
-          # A type not listed gets none of them and lands under Other.
-          managed="enhancement bug documentation skip-changelog"
-          conventional='^([a-z]+)(\([^)]*\))?!?: '
-          type=""
-          if [[ "$TITLE" =~ $conventional ]]; then
-            type="${BASH_REMATCH[1]}"
-          fi
-          case "$type" in
-            feat|perf) wanted=enhancement ;;
-            fix) wanted=bug ;;
-            docs) wanted=documentation ;;
-            build|ci|test|chore|refactor|style) wanted=skip-changelog ;;
-            *) wanted="" ;;
-          esac
-          current=$(gh pr view "$NUMBER" --repo "$REPO" --json labels --jq '[.labels[].name] | join(" ")')
-          args=()
-          for label in $managed; do
-            case " $current " in *" $label "*) has=1 ;; *) has=0 ;; esac
-            if [ "$label" = "$wanted" ] && [ "$has" = 0 ]; then args+=(--add-label "$label"); fi
-            if [ "$label" != "$wanted" ] && [ "$has" = 1 ]; then args+=(--remove-label "$label"); fi
-          done
-          if [ "${#args[@]}" = 0 ]; then
-            echo "#$NUMBER '$TITLE': nothing to change (${wanted:-no managed label})"
-          else
-            gh pr edit "$NUMBER" --repo "$REPO" "${args[@]}"
-            echo "#$NUMBER '$TITLE': ${args[*]}"
-          fi

package/.github/workflows/release-please.yml

@@ -1,109 +0,0 @@
-name: release-please
-
-on:
-  push:
-    branches: [main]
-  # The gate below runs release-please only for a push that carries a commit
-  # users get, so a release pull request it has already opened is not
-  # refreshed by a docs or ci merge, and a config change is exactly such a
-  # merge. This trigger re-runs it on demand, which is what rewrites an
-  # outstanding release pull request against the current configuration.
-  workflow_dispatch:
-
-permissions: {}
-
-# One release-please run at a time: a push and a manual run, or two pushes
-# landing close together, would each read the release pull request's state
-# and each write it, and the later write could undo the earlier one.
-# cancel-in-progress is false so a run already creating a tag or dispatching
-# the publish is never killed part-way. A run waiting behind it can still be
-# replaced by a newer one, which costs nothing here: release-please derives
-# the release pull request from the commit range, so the newest run produces
-# the same result the superseded one would have.
-#
-# The group is a constant rather than keyed on github.ref: the action is
-# given no target-branch, so every run, including a dispatch launched from
-# some other branch, acts on the default branch's release pull request.
-concurrency:
-  group: release-please
-  cancel-in-progress: false
-
-jobs:
-  # GitHub's release notes are never empty, so release-please would propose
-  # a release after every merge, a docs or ci change included. Only a push
-  # carrying a change users get, or the merge of the release PR itself,
-  # which is what creates the tag, goes on to it.
-  #
-  # Every commit in the push is checked, so a merge commit's PR commits count
-  # through their own subjects. A breaking change counts whatever its type, a
-  # `revert:` because what it undoes has shipped, and a `Release-As:` footer,
-  # matched in any case as release-please does, because it asks for a release
-  # on any subject. GitHub's own `Revert "…"` subject is not conventional, so
-  # release-please ignores it and it is not let through here either. The last
-  # alternative is the release PR's own title, pull-request-title-pattern in
-  # release-please-config.json, and must change with it, or the release PR's
-  # merge is judged non-releasable and no tag is ever created. The payload
-  # holds at most 2048 commits, so a push that fills it may hide more and is
-  # let through.
-  gate:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    outputs:
-      releasable: ${{ steps.check.outputs.releasable }}
-    steps:
-      # A manual run carries no commits to judge, and asking for one is the
-      # statement that it should happen, so it bypasses the check below
-      # rather than being skipped by it for having an empty payload.
-      - id: check
-        env:
-          DISPATCHED: ${{ github.event_name == 'workflow_dispatch' }}
-          MESSAGES: ${{ toJSON(github.event.commits.*.message) }}
-          RELEASABLE: '^((feat|fix|perf|revert)(\([^)]*\))?!?: |[a-z]+(\([^)]*\))?!: |chore\(release\): v?[0-9])'
-        run: |
-          if [ "$DISPATCHED" = true ]; then
-            echo "releasable=true" >> "$GITHUB_OUTPUT"
-            echo "Run requested manually; release-please not gated."
-            exit 0
-          fi
-          if jq -e --arg re "$RELEASABLE" '(length >= 2048) or ([.[] | (split("\n")[0] | test($re)) or test("\nBREAKING[- ]CHANGE: ") or test("\nrelease-as: "; "i")] | any)' <<< "$MESSAGES" > /dev/null; then
-            echo "releasable=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "releasable=false" >> "$GITHUB_OUTPUT"
-            echo "No releasable commit in this push; release-please not run."
-          fi
-
-  release-please:
-    needs: gate
-    if: ${{ needs.gate.outputs.releasable == 'true' }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: write
-      pull-requests: write
-      # release-please creates its `autorelease: pending` / `autorelease:
-      # tagged` labels through the issues API the first time it needs them.
-      issues: write
-    outputs:
-      releases_created: ${{ steps.rp.outputs.releases_created }}
-      tag_name: ${{ steps.rp.outputs.tag_name }}
-    steps:
-      - uses: googleapis/release-please-action@v5
-        id: rp
-
-  # The tag release-please just pushed does not start release_on_tag.yml by
-  # itself: an event raised with GITHUB_TOKEN starts no workflow, with
-  # workflow_dispatch as the exception. So release_on_tag.yml is dispatched on
-  # the tag. It has to stay the file that publishes, since npm's trusted
-  # publishing is bound to that workflow file. This is its own job, so that
-  # the right to start workflows is held by nothing but this one command.
-  publish:
-    needs: release-please
-    if: ${{ needs.release-please.outputs.releases_created == 'true' }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      actions: write
-    steps:
-      - env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh workflow run release_on_tag.yml --repo "$GITHUB_REPOSITORY" --ref "${{ needs.release-please.outputs.tag_name }}"